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;
    }
}