目錄

①概念

②操作-查找

③操作-插入

④操作-洗掉

⑤性能分析

①概念

二叉搜索樹又稱二叉排序樹，它或者是一棵空樹**，或者是具有以下性質的二叉樹:

若它的左子樹不為空，則左子樹上所有節點的值都小于根節點的值

若它的右子樹不為空，則右子樹上所有節點的值都大于根節點的值

它的左右子樹也分別為二叉搜索樹

②操作-查找

二叉搜索樹的查找類似于二分法查找

public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if(cur.val == key) {
                return cur;
            }else if(cur.val < key) {
                cur = cur.right;
            }else {
                cur = cur.left;
            }
        }
        return null;
    }

③操作-插入

  public boolean insert(int key) {
        Node node = new Node(key);
        if(root == null) {
            root = node;
            return true;
        }

        Node cur = root;
        Node parent = null;

        while(cur != null) {
            if(cur.val == key) {
                return false;
            }else if(cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
        //parent
        if(parent.val > key) {
            parent.left = node;
        }else {
            parent.right = node;
        }

        return true;
    }

④操作-洗掉

洗掉操作較為復雜，但理解了其原理還是比較容易

設待洗掉結點為 cur, 待洗掉結點的雙親結點為 parent

1. cur.left == null

1. cur 是 root，則 root = cur.right

2. cur 不是 root，cur 是 parent.left，則 parent.left = cur.right

3. cur 不是 root，cur 是 parent.right，則 parent.right = cur.right

2. cur.right == null

1. cur 是 root，則 root = cur.left

2. cur 不是 root，cur 是 parent.left，則 parent.left = cur.left

3. cur 不是 root，cur 是 parent.right，則 parent.right = cur.left

第二種情況和第一種情況相同，只是方向相反，這里不再畫圖

3. cur.left != null && cur.right != null

需要使用替換法進行洗掉，即在它的右子樹中尋找中序下的第一個結點(關鍵碼最小)，用它的值填補到被洗掉節點中，再來處理該結點的洗掉問題

當我們在左右子樹都不為空的情況下進行洗掉，洗掉該節點會破壞樹的結構，因此用替罪羊的方法來解決，實際洗掉的程序還是上面的兩種情況，這里還是用到了搜索二叉樹的性質

public void remove(Node parent,Node cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            Node targetParent =  cur;
            Node target = cur.right;
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }

  public void removeKey(int key) {
        if(root == null) {
            return;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if(cur.val == key) {
                remove(parent,cur);
                return;
            }else if(cur.val < key){
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }

⑤性能分析

插入和洗掉操作都必須先查找，查找效率代表了二叉搜索樹中各個操作的性能，

對有n個結點的二叉搜索樹，若每個元素查找的概率相等，則二叉搜索樹平均查找長度是結點在二叉搜索樹的深度 的函式，即結點越深，則比較次數越多，

但對于同一個關鍵碼集合，如果各關鍵碼插入的次序不同，可能得到不同結構的二叉搜索樹：

最優情況下，二叉搜索樹為完全二叉樹，其平均比較次數為：

最差情況下，二叉搜索樹退化為單支樹，其平均比較次數為：

⑥完整代碼

public class TextDemo {

    public static class Node {
        public int val;
        public Node left;
        public Node right;

        public Node (int val) {
            this.val = val;
        }
    }


    public Node root;

    /**
     * 查找
     * @param key
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if(cur.val == key) {
                return cur;
            }else if(cur.val < key) {
                cur = cur.right;
            }else {
                cur = cur.left;
            }
        }
        return null;
    }

    /**
     *
     * @param key
     * @return
     */
    public boolean insert(int key) {
        Node node = new Node(key);
        if(root == null) {
            root = node;
            return true;
        }

        Node cur = root;
        Node parent = null;

        while(cur != null) {
            if(cur.val == key) {
                return false;
            }else if(cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
        //parent
        if(parent.val > key) {
            parent.left = node;
        }else {
            parent.right = node;
        }

        return true;
    }

    public void remove(Node parent,Node cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            Node targetParent =  cur;
            Node target = cur.right;
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }

    public void removeKey(int key) {
        if(root == null) {
            return;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if(cur.val == key) {
                remove(parent,cur);
                return;
            }else if(cur.val < key){
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }

}