二分搜索树的基本实现

基本操作的动画演示

插入（略）

搜索（略）

删除节点

代码

package com.yunche.datastructure;import java.util.LinkedList;
import java.util.Queue;/*** @ClassName: BST* @Description: 二叉搜索树：每个节点的左子树的值都小于节点的值，每个节点的右子树的值都大于节点的值* 注：二叉搜索树不一定是完全二叉树* @author: yunche* @date: 2018/12/27*/
public class BST<K extends Comparable<K>, V> {/*** 内部私有节点类*/private class Node {private K key;private V value;private Node left;private Node right;public Node(K key, V value) {this.key = key;this.value = value;left = right = null;}}/*** 根节点*/private Node root;/*** 节点个数*/private int count;/*** 返回节点的个数** @return*/public int size() {return count;}/*** 返回二叉搜索树是否为空** @return*/public boolean isEmpty() {return count == 0;}/*** 构造函数默认构造一棵空的二叉搜索树*/public BST() {root = null;count = 0;}/*** 向二叉搜索树中插入一个新的(key, value)数据对** @param key* @param value*/public void insert(K key, V value) {root = insert(root, key, value);}/*** 判断二叉搜索树中是否包含该键** @param key* @return*/public boolean contain(K key) {return contain(root, key);}/*** 在二叉搜索树中，搜索该键对应的值，并返回，若盖建不存在，返回null** @param key* @return*/public V search(K key) {return search(root, key);}/*** 二叉搜索树的前序遍历*/public void preOrder() {preOrder(root);}/*** 二分搜索树的中序遍历*/public void inOrder() {inOrder(root);}/*** 二分搜索树的后序遍历*/public void postOrder() {postOrder(root);}/*** 二分搜索树的层序遍历*/public void levelOrder() {//使用LinkedList作为队列Queue<Node> queue = new LinkedList<Node>();if (root != null) {queue.add(root);}while (!queue.isEmpty()) {Node node = queue.remove();System.out.println(node.key);if (node.left != null) {queue.add(node.left);}if (node.right != null) {queue.add(node.right);}}}/*** 返回二分搜索树中最小的键值** @return*/public K min() {if (root != null) {return min(root).key;}return null;}/*** 返回二分搜索树中最大的键值** @return*/public K max() {if (root != null) {return max(root).key;}return null;}/*** 从二分搜索树中删除最小的键值*/public void removeMin() {if (root != null) {root = removeMin(root);}}/*** 从二分搜索树中删除最大的键值*/public void removeMax() {if (root != null) {root = removeMax(root);}}/*** 删除指定键的节点** @param key*/public void remove(K key) {root = remove(key, root);}/*** @param node  该插入的节点位置* @param key* @param value* @return 返回插入后的新节点*/private Node insert(Node node, K key, V value) {//递归边界if (node == null) {count++;return new Node(key, value);}if (node.key.compareTo(key) == 0) {node.value = value;} else if (key.compareTo(node.key) < 0) {node.left = insert(node.left, key, value);} else {node.right = insert(node.right, key, value);}return node;}/*** 递归contain算法，返回在以node为根节点的树中是否存在该键** @param node* @param key* @return*/private boolean contain(Node node, K key) {//递归边界if (node == null) {return false;}if (key.compareTo(node.key) == 0) {return true;} else if (key.compareTo(node.key) < 0) {return contain(node.left, key);} else {return contain(node.right, key);}}/*** 递归search算法** @param node 待搜索树的根节点* @param key  待搜索的键* @return*/private V search(Node node, K key) {//递归边界if (node == null) {return null;}if (key.compareTo(node.key) == 0) {return node.value;} else if (key.compareTo(node.key) < 0) {return search(node.left, key);} else {return search(node.right, key);}}/*** 将以node为根节点的树进行先序遍历,递归算法** @param node*/private void preOrder(Node node) {//递归边界if (node == null) {return;}System.out.println(node.key);preOrder(node.left);preOrder(node.right);}/*** 将以node为根节点的树进行中序遍历,递归算法** @param node*/private void inOrder(Node node) {//递归边界if (node == null) {return;}inOrder(node.left);System.out.println(node.key);inOrder(node.right);}/*** 将以node为根节点的树进行后序遍历,递归算法** @param node*/private void postOrder(Node node) {//递归边界if (node == null) {return;}postOrder(node.left);postOrder(node.right);System.out.println(node.key);}/*** 返回最小键值的节点，递归算法** @param node 待搜索树的根节点* @return*/private Node min(Node node) {//递归边界if (node.left == null) {return node;}return min(node.left);}/*** 返回最大键值的节点，递归算法** @param node 待搜索树的根节点* @return*/private Node max(Node node) {//递归边界if (node.right == null) {return node;}return max(node.right);}/*** 删除最小键值节点 递归算法** @param node 最小键值所在树的根节点* @return 返回删除节点后新的二分搜索树的根*/private Node removeMin(Node node) {//递归边界if (node.left == null) {Node childRight = node.right;node.right = null;count--;return childRight;}node.left = removeMin(node.left);return node;}/*** 删除最大键值节点 递归算法** @param node 最大键值所在树的根节点* @return 返回删除节点后新的二分搜索树的根*/private Node removeMax(Node node) {//递归边界if (node.right == null) {Node childLeft = node.left;node.left = null;count--;return childLeft;}node.right = removeMax(node.right);return node;}/*** 删除指定键值对应的节点，并返回删除后新的根节点. 递归算法** @param key  要删除的键值* @param node 删除键值的节点位于以该节点为根的树里* @return 删除后子树新的根节点.*/private Node remove(K key, Node node) {//递归边界if (node == null) {return null;}if (key.compareTo(node.key) == 0) {//将该节点右子树中的最小键值的节点放在现在节点的位置//并使该位置（删除节点的位置）上的新节点的左孩子指向原该位置上原来节点的左孩子//并使该位置（删除节点的位置）上的新节点的右孩子指向原该位置上原来节点的右孩子if (node.right == null) {Node leftNode = node.left;node = null;count--;return leftNode;}Node successor = min(node.right);successor.right = removeMin(node.right);successor.left = node.left;node = null;return successor;} else if (key.compareTo(node.key) < 0) {node.left = remove(key, node.left);} else {node.right = remove(key, node.right);}return node;}public static void main(String[] args) {BST<Integer, Integer> bst = new BST<Integer, Integer>();// 取n个取值范围在[0...m)的随机整数放进二分搜索树中int N = 10;int M = 100;for (int i = 0; i < N; i++) {Integer key = new Integer((int) (Math.random() * M));// 为了后续测试方便,这里value值取和key值一样bst.insert(key, key);System.out.print(key + " ");}System.out.println();// 测试二分搜索树的size()System.out.println("size: " + bst.size());System.out.println();//        //若要测试，取消该代码片段注释即可
//        //********测试遍历(前中后) 和层序遍历开始********//
//        // 测试二分搜索树的前序遍历 preOrder
//        System.out.println("preOrder: ");
//        bst.preOrder();
//        System.out.println();
//
//        // 测试二分搜索树的中序遍历 inOrder
//        System.out.println("inOrder: ");
//        bst.inOrder();
//        System.out.println();
//
//        // 测试二分搜索树的后序遍历 postOrder
//        System.out.println("postOrder: ");
//        bst.postOrder();
//        System.out.println();
//        //********测试插入、遍历(前中后)和层序遍历 结束**********//
//
//
//        // 测试二分搜索树的层序遍历 levelOrder
//        System.out.println("levelOrder: ");
//        bst.levelOrder();
//        System.out.println();
//********测试遍历(前中后) 和层序遍历结束*******////        //*****测试搜索最小、最大键值 开始**********
//        System.out.println("min: " + bst.min());
//        System.out.println("max: " + bst.max());
//        //*****测试搜索最小、最大键值  结束**********//        //******* 测试 removeMin 和 removeMax开始
//        // 输出的元素应该是从小到大排列的
//        System.out.println("Test removeMin: ");
//        while( !bst.isEmpty() ){
//            System.out.print("min: " + bst.min() + " , ");
//            bst.removeMin();
//            System.out.println("After removeMin, size = " + bst.size() );
//        }
//        System.out.println();
//
//
//        for(int i = 0 ; i < N ; i ++){
//            Integer key = new Integer((int)(Math.random()*M));
//            // 为了后续测试方便,这里value值取和key值一样
//            bst.insert(key, key);
//        }
//        // 注意, 由于随机生成的数据有重复, 所以bst中的数据数量大概率是小于n的
//
//        // 测试 removeMax
//        // 输出的元素应该是从大到小排列的
//        System.out.println("Test removeMax: ");
//        while( !bst.isEmpty() ){
//            System.out.print("max: " + bst.max() + " , ");
//            bst.removeMax();
//            System.out.println("After removeMax, size = " + bst.size() );
//        }
//        //******* 测试 removeMin 和 removeMax结束//        //******测试 remove 开始
//        BST<Integer, Integer> bstDelete = new BST<Integer, Integer>();
//        bstDelete.insert(2, 2);
//        bstDelete.insert(1, 1);
//        bstDelete.insert(3, 3);
//        bstDelete.insert(4, 4);
//        bstDelete.insert(0, 0);
//        bstDelete.remove(1);
//        System.out.println("levelOrder: ");
//        bstDelete.levelOrder();
//        System.out.println("inOrder: ");
//        bstDelete.inOrder();
//        System.out.println();
//        //***测试remove 结束}}