JAVA数据结构之二分搜索树【BST】

• 定义子节点类型

public class Node{
    public E e;
    public Node left,right;

    public Node(E e){
        this.e = e;
        right = null;
        left = null;
    }
}

• BST的API
• 需求
  
  1. 增：add
  2. 删：remove removeMax removeMin
  3. 改：
  4. 查：minimum maximum contains size isEmpty preOrder inOrder postOrder levelOrder

public class BST<E extends Comparable<E>>{
    private Node root;
    private int size;

    /*************构造函数****************/
    public BST(){
        root = null;
        size = 0;
    }
    /***********增********************/
    public void add(E e){
        root = add(root,e);
    }
    private Node add(Node node, E e){
        //当该node下无任何节点时
        if(node == null){
            size++;
            return new Node(e);
        }
        //当该BST有节点时
        //e比根节点的e大时，向右边查找，否则向左边
        //e和相等时,直接返回
        if(e.compareTo(node.e)>0){
            return add(node.right,e);
        }else if(e.compareTo(node.e)<0){
            return add(node.left,e);
        }else{
            return node;
        }
    }
    /***********删********************/
    //移除最小的元素
    public E removeMin(){
        E ret = minimum();
        //移除元素，挂接元素
        removeMin(root);
        return ret;
    }
    private Node removeMin(Node node){
        //需要考虑两种情况
        //1.最小节点无右节点
        //2.最小节点有右节点
        if(node.left==null){
        //不管右节点是否为空，两个情况一起考虑
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        //如果不为空，继续递归
        node.left = removeMin(node.left);

        return node;
    }
     //移除最大的元素
    public E removeMax(){
        E ret = maximum();
        //移除元素，挂接元素
        removeMax(root);
        return ret;
    }
    private Node removeMax(Node node){
        //需要考虑两种情况
        //1.最大节点无左节点
        //2.最大节点有左节点
        if(node.left==null){
        //不管右节点是否为空，两个连在一起
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        //如果不为空，继续递归
        node.right = removeMax(node.right);

        return node;
    }

    public void remove(E e){
        remove(root,e);
    }
    private Node remove(Node node,E e){
        if(Node == null){
            return null;
        }
        if(e.compareTo(node.e)<0){
            node.left = remove(node.left,e);
            return node;
        }else if(e.compareTo(node.e) > 0){
            node.right = remove(node.right,e);
            return node;
        }else{// = 0
            //删除节点左子树为空的情况
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            //删除待删除右子树为空的情况
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size--;     
                return leftNode;
            }
            //这里是用后继节点替代删除节点 ；还可以有驱节点删除节点
            //删除节点，左右子树均不为空的情况
            //找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
            //用这个节点顶替待删除的节点位置
            Node successor = minimum(node.left);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.right = node.left = null;
            return successor;

    }
    /***********查********************/
    //BST元素个数
    public int size(){
        return size;
    }
    //BST是否为空
    public boolean isEmpty(){
        return size == 0;
    }
    //BST是否包含某个元素
    public boolean contains(E e){
        return contains(root,e);
    }
    private boolean contains(Node node,E e){
        if(node == null){
            return false;
        }

         if (e.compareTo(node.e) == 0) {
            return true;
        } else if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else {
            return contains(node.right, e);
        }
    }

    //先序遍历
    public void preOrder(){
        preOrder(root);
    }
    private void preOrder(Node node){
        //终止条件
        if(node == null){
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    //中序遍历
    public void inOrder(){
        inOrder(root);
    }
    private void inOrder(Node node){
        //终止条件
        if(node == null){
            return;
        }

        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

    //后序遍历
    public void postOrder(){
        postOrder(root);
    }
    private void postOrder(Node node){
        //终止条件
        if(node == null){
            return;
        }

        postOrder(node.left);
        postOrder(node.right); System.out.println(node.e);
    }
    //层序遍历，非递归，用队列实现 重点
    private void levelOrder(){
        Queue<E> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            Node cur = queue.remove();
            if(cur.left!=null){
                queue.add(cur.left);
            }
            if(cur.right!=null){
                queue.add(cur.right);
            }

        }
    }
    //查询BST最小值
    public E minimum(){
         if (size == 0) {
            throw new IllegalArgumentException("BST is empty");
        }
        return minimum(root).e;
    }
    //递归写法
    private Node minimum(Node node){
         if (node.left == null) {
            return node;
        } else {
            return minimum(node.left);
        }
    }
    //非递归
    private Node miniNR(Node node){
       while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    //查询BST最大值
    public E maximum(){
         if (size == 0) {
            throw new IllegalArgumentException("BST is empty");
        }
        return maximum(root).e;
    }
    //递归写法
    private Node maximum(Node node){
         if (node.right == null) {
            return node;
        } else {
            return minimum(node.right);
        }
    }
    //非递归
    private Node maxiNR(Node node){
       while (node.right != null) {
            node = node.right;
        }
        return node;
    }
}