目錄

• 1、二分法引言
• 2、二叉搜尋樹定義
• 3、二叉搜尋樹的CRUD
• 4、二叉搜尋樹的兩種極端情況
• 5、二叉搜尋樹總結

前言
在【演算法04】樹與二叉樹中，已經介紹過了關於樹的一些基本概念以及二叉樹的前中後序遍歷，而這篇文章將是在二叉樹的基礎上來展開講解的二叉搜尋樹，也就是說二叉搜尋樹建立在樹的基礎之上。至於博主為何要花一整篇文章來講這個二叉搜尋樹呢？原因很簡單，紅-黑樹是基於二叉搜尋樹的，如果對二叉搜尋樹不瞭解，那還談何紅-黑樹？紅-黑樹的重要性我想各位沒吃過佩奇肉也肯定看過宜春跑....是的，jdk1.8的Map 就是散列表+紅黑樹實現的！

@

首先要明確的是二叉搜尋樹又稱二叉排序樹、二叉查詢樹，簡統稱BST

1、二分法引言

在正式將二叉搜尋樹之前，宜春還是想先談談人生談談生活從而切入二叉搜尋樹。

一天，程式設計師老方給宜春打電話：靚仔，我今天下單了一雙皮鞋，老靚了，價格不菲啊！
宜春：得了吧你，啥條件啊我還不知道，還皮鞋，老鼠皮的鞋吧，如果是真牛皮的皮鞋我把它吃嘍！！！
老方：你還真別說，這皮鞋還真是比真牛皮還真的假牛皮的皮鞋，老靚了，你猜猜我買它花了多少銀子，反正是100以內，看你能不能再最少次數猜出來，要是五次機會之內猜出來就親自下廚，燉給你吃，嘎嘣脆，嘿嘿...
宜春：你就嘚瑟吧，還是你懂我，知道我好這一口（自黑）....咳咳咳，50塊
老方：不對，價格高了
宜春：25
老方：不對，價格還高了
宜春：12.5
....

一個一個字看這裡的估計在座各位個個都是人才，就一個簡簡單單的二分法猜數字的遊戲，通過對猜測數字“大了”、“小了”的情況判斷，來猜出最終的數字。當然，本改三言兩語就可以描述的，宜春花了這麼長串字串來描述，估計宜春TM也是個人才....實際上呢，宜春就想活躍活躍下氣氛，把各位的腦細胞集中一下下，當然耽誤了各位時間，屬實抱歉，宜春線上捱揍....

不知各位有沒有想過，為何二分法就是有足夠的優勢呢？如果100以內我直接猜25不行麼？這樣豈不是更可能定出價格？其實直接猜25或者更小這是一種極端的猜測，如果確實比25小，那範圍就是在25以內了，那你有沒有想過:如果大於25呢？範圍就直接轉成了75了！隨著這種極端思想的推進，會發現
每次擇半查詢會更加準確和更好的能應對各種不確定的情景！擇半查詢複雜度為 O(log_2 n)，即最多需要 O(log_2 n) 次可以猜到最終數字。

到這裡，要開始正式介紹二叉搜尋樹了，實際上二叉搜尋樹就類似於上面提到過的二分查詢，有類似的韻味。

2、二叉搜尋樹定義

二叉查詢樹（Binary Search Tree，BST）是一種特殊的二叉樹，一棵二叉搜尋樹（BST）是一棵二叉樹，其中，對於樹中每個節點而言：
1、若其左子樹存在，則其左子樹中每個節點的值都不大於該節點值；
2、若其右子樹存在，則其右子樹中每個節點的值都不小於該節點值。

3、二叉搜尋樹的CRUD

我想提一下的是：我們知道遍歷樹是使用前中後序遍歷方法，但是遍歷二叉搜尋樹最好是使用中序遍歷法，如果不理解為何使用中序遍歷，那麼你有三種選擇：
一、自行【演算法04】樹與二叉樹進去補補基礎樹基礎
二、留言提問，宜春看到就回
三、前面二者都拒絕 ，那你就優秀了....

3.1、查詢

如果要在二叉查詢樹中查詢任意一個節點，假設它是X ，我們可以分為以下幾步：

1、如果二叉查詢樹為空，則返回空操作，否則，執行一下操作；
2、先取根節點，如果節點 X 等於根節點，則返回；
3、如果節點小於根節點，則遞迴查詢左子樹；
4、如果節點大於根節點，則遞迴查詢右子樹。

//查詢的邏輯程式碼實現：
    /**
     * @param value 希望查詢結點的值
     * @return 如果找到返回該結點，否則返回null
     */
    public Node search(int value) {
        if(value == this.value) { //找到就是該結點
            return this;
        } else if(value < this.value) {//如果查詢的值小於當前結點，向左子樹遞迴查詢
            //如果左子結點為空
            if(this.left  == null) {
                return null;
            }
            return this.left.search(value);
        } else { //如果查詢的值不小於當前結點，向右子樹遞迴查詢
            if(this.right == null) {
                return null;
            }
            return this.right.search(value);
        }

    }

3.2、插入

在二叉樹中插入一個節點，仔細想想，會發現插入某一個節點一般都是插入到葉節點上，所以只需從根結點開始，依次遍歷比較要插入的資料和節點的大小關係。

==二叉查詢樹有一個很重要的特性就是插入的實現難度和查詢差不多==。插入節點其實可以有如下三種情況：

1、如果樹是空的，則直接將新節點插入，否則，執行下面步驟。
2、要插入的資料比根節點資料大，則到右子樹中插入新資料，如果右子樹為空，則將新資料直接插入到右子節點的位置；不為空，則繼續遍歷右子樹，查詢插入位置。
3、要插入的資料比根節點資料小，則到左子樹中插入資料，如果左子樹為空，則直接將新資料插入到左子節點的位置；不為空，則繼續遍歷左子樹，查詢插入的位置。

 //新增結點的邏輯程式碼
    //遞迴的形式新增結點，注意需要滿足二叉排序樹的要求
    public void add(Node node) {
        if(node == null) {
            return;
        }
       if(root == null) {
            root = node;//如果root為空則直接讓root指向node
        } 
        //判斷傳入的結點的值，和當前子樹的根結點的值關係
      if(node.value < this.value) {
            //如果當前結點左子結點為null
            if(this.left == null) {
                this.left = node;
            } else {
                //遞迴的向左子樹新增
                this.left.add(node);
            }
        } else { //新增的結點的值大於 當前結點的值
            if(this.right == null) {
                this.right = node;
            } else {
                //遞迴的向右子樹新增
                this.right.add(node);
            }

        }
    }

3.3、刪除

可以這麼說，刪除相對查詢和插入來說比較複雜一些，為啥會複雜一些呢？因為要刪除某一個節點，首先要查詢到這個節點然後將其刪除，刪除之後還需要將該二叉搜尋樹還原成一顆二叉搜尋樹。因此針對要刪除節點的子節點位置的不同，同樣一般分為三種情況來處理：

1、 第一種情況，如果要刪除的節點沒有子節點，直接將父節點指向要刪除節點的指標指向 null。比如途中要刪除的節點 0。
2、第二種情況，如果要刪除的節點只有一個節點，即只有左子節點或右子節點，則將父節點指向要刪除節點的指標指向要刪除節點的子節點即可。比如途中要刪除的節點1。
3、第三種情況，如果要刪除的節點有兩個子節點，則需要先找到這個節點右子樹中的最小節點或者左子樹中的最大節點，將其替換到要刪除的節點上。然後刪除這個右子樹中的最小節點或左子樹中的最大節點，比如圖中要刪除的節點 6。

 //刪除結點邏輯程式碼
    public void delNode(int value) {
        if(root == null) {
            return;
        }else {
            //1.需求先去找到要刪除的結點  targetNode
            Node targetNode = search(value);
            //如果沒有找到要刪除的結點
            if(targetNode == null) {
                return;
            }
            //如果我們發現當前這顆二叉排序樹只有一個結點
            if(root.left == null && root.right == null) {
                root = null;
                return;
            }

            //去找到targetNode的父結點
            Node parent = searchParent(value);
            //如果要刪除的結點是葉子結點
            if(targetNode.left == null && targetNode.right == null) {
                //判斷targetNode 是父結點的左子結點，還是右子結點
                if(parent.left != null && parent.left.value == value) { //是左子結點
                    parent.left = null;
                } else if (parent.right != null && parent.right.value == value) {//是由子結點
                    parent.right = null;
                }
            } else if (targetNode.left != null && targetNode.right != null) { //刪除有兩顆子樹的節點
                int minVal = delRightTreeMin(targetNode.right);
                targetNode.value = minVal;


            } else { // 刪除只有一顆子樹的結點
                //如果要刪除的結點有左子結點
                if(targetNode.left != null) {
                    if(parent != null) {
                        //如果 targetNode 是 parent 的左子結點
                        if(parent.left.value == value) {
                            parent.left = targetNode.left;
                        } else { //  targetNode 是 parent 的右子結點
                            parent.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;
                    }
                } else { //如果要刪除的結點有右子結點
                    if(parent != null) {
                        //如果 targetNode 是 parent 的左子結點
                        if(parent.left.value == value) {
                            parent.left = targetNode.right;
                        } else { //如果 targetNode 是 parent 的右子結點
                            parent.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;
                    }
                }

            }

        }
    }

3.4、整體程式碼

為了連貫一下思維，可以自行編輯main方法進行測試！

package dataStructure;

//建立二叉排序樹
class BinarySortTree {
    private Node root;

    public Node getRoot() {
        return root;
    }

    //查詢要刪除的結點
    public Node search(int value) {
        if(root == null) {
            return null;
        } else {
            return root.search(value);
        }
    }

    //查詢父結點
    public Node searchParent(int value) {
        if(root == null) {
            return null;
        } else {
            return root.searchParent(value);
        }
    }

    //編寫方法:
    //1. 返回的 以node 為根結點的二叉排序樹的最小結點的值
    //2. 刪除node 為根結點的二叉排序樹的最小結點
    /**
     *
     * @param node 傳入的結點(當做二叉排序樹的根結點)
     * @return 返回的 以node 為根結點的二叉排序樹的最小結點的值
     */
    public int delRightTreeMin(Node node) {
        Node target = node;
        //迴圈的查詢左子節點，就會找到最小值
        while(target.left != null) {
            target = target.left;
        }
        //這時 target就指向了最小結點
        //刪除最小結點
        delNode(target.value);
        return target.value;
    }


    //刪除結點
    public void delNode(int value) {
        if(root == null) {
            return;
        }else {
            //1.需求先去找到要刪除的結點  targetNode
            Node targetNode = search(value);
            //如果沒有找到要刪除的結點
            if(targetNode == null) {
                return;
            }
            //如果我們發現當前這顆二叉排序樹只有一個結點
            if(root.left == null && root.right == null) {
                root = null;
                return;
            }

            //去找到targetNode的父結點
            Node parent = searchParent(value);
            //如果要刪除的結點是葉子結點
            if(targetNode.left == null && targetNode.right == null) {
                //判斷targetNode 是父結點的左子結點，還是右子結點
                if(parent.left != null && parent.left.value == value) { //是左子結點
                    parent.left = null;
                } else if (parent.right != null && parent.right.value == value) {//是由子結點
                    parent.right = null;
                }
            } else if (targetNode.left != null && targetNode.right != null) { //刪除有兩顆子樹的節點
                int minVal = delRightTreeMin(targetNode.right);
                targetNode.value = minVal;


            } else { // 刪除只有一顆子樹的結點
                //如果要刪除的結點有左子結點
                if(targetNode.left != null) {
                    if(parent != null) {
                        //如果 targetNode 是 parent 的左子結點
                        if(parent.left.value == value) {
                            parent.left = targetNode.left;
                        } else { //  targetNode 是 parent 的右子結點
                            parent.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;
                    }
                } else { //如果要刪除的結點有右子結點
                    if(parent != null) {
                        //如果 targetNode 是 parent 的左子結點
                        if(parent.left.value == value) {
                            parent.left = targetNode.right;
                        } else { //如果 targetNode 是 parent 的右子結點
                            parent.right = targetNode.right;
                        }
                    } else {
                        root = targetNode.right;
                    }
                }

            }

        }
    }

    //新增結點的方法
    public void add(Node node) {
        if(root == null) {
            root = node;//如果root為空則直接讓root指向node
        } else {
            root.add(node);
        }
    }
    //中序遍歷
    public void infixOrder() {
        if(root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉排序樹為空，不能遍歷");
        }
    }
}

//建立Node結點
class Node {
    int value;
    Node left;
    Node right;
    public Node(int value) {

        this.value = value;
    }


    //查詢要刪除的結點
    /**
     *
     * @param value 希望刪除的結點的值
     * @return 如果找到返回該結點，否則返回null
     */
    public Node search(int value) {
        if(value == this.value) { //找到就是該結點
            return this;
        } else if(value < this.value) {//如果查詢的值小於當前結點，向左子樹遞迴查詢
            //如果左子結點為空
            if(this.left  == null) {
                return null;
            }
            return this.left.search(value);
        } else { //如果查詢的值不小於當前結點，向右子樹遞迴查詢
            if(this.right == null) {
                return null;
            }
            return this.right.search(value);
        }

    }
    //查詢要刪除結點的父結點
    /**
     *
     * @param value 要找到的結點的值
     * @return 返回的是要刪除的結點的父結點，如果沒有就返回null
     */
    public Node searchParent(int value) {
        //如果當前結點就是要刪除的結點的父結點，就返回
        if((this.left != null && this.left.value == value) ||
                (this.right != null && this.right.value == value)) {
            return this;
        } else {
            //如果查詢的值小於當前結點的值, 並且當前結點的左子結點不為空
            if(value < this.value && this.left != null) {
                return this.left.searchParent(value); //向左子樹遞迴查詢
            } else if (value >= this.value && this.right != null) {
                return this.right.searchParent(value); //向右子樹遞迴查詢
            } else {
                return null; // 沒有找到父結點
            }
        }

    }

    @Override
    public String toString() {
        return "Node [value=" + value + "]";
    }


    //新增結點的方法
    //遞迴的形式新增結點，注意需要滿足二叉排序樹的要求
    public void add(Node node) {
        if(node == null) {
            return;
        }

        //判斷傳入的結點的值，和當前子樹的根結點的值關係
        if(node.value < this.value) {
            //如果當前結點左子結點為null
            if(this.left == null) {
                this.left = node;
            } else {
                //遞迴的向左子樹新增
                this.left.add(node);
            }
        } else { //新增的結點的值大於 當前結點的值
            if(this.right == null) {
                this.right = node;
            } else {
                //遞迴的向右子樹新增
                this.right.add(node);
            }

        }
    }

    //中序遍歷
    public void infixOrder() {
        if(this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this);
        if(this.right != null) {
            this.right.infixOrder();
        }
    }

}


public class BinarySortTreeDemo { //==========至於main方法的測試程式碼可自行調整測試！！！！！！！！！
    public static void main(String[] args) {
        int[] arr = {4,7, 2, 13, 11, 5, 1, 9, 3};
        BinarySortTree binarySortTree = new BinarySortTree();
        for(int i = 0; i< arr.length; i++) {
            binarySortTree.add(new Node(arr[i]));
        }
        binarySortTree.add(new Node(4));

        System.out.println("中序遍歷二叉排序樹~");
        binarySortTree.infixOrder(); 
    }
}

4、二叉搜尋樹的兩種極端情況

1、變成一顆 完全二叉樹，所有節點儘量填滿樹的每一層，上一層填滿後還有剩餘節點的話，則由左向右儘量填滿下一層。如下圖所示，即為一顆完全二叉樹；

2、每一層只有一個節點的二叉樹。如下圖所示：

我敲，這不是蛇皮怪單鏈表嗎，是的，給我們的感覺就是樹形怪退化為蛇皮怪單鏈表了！在這種情況下，樹中每層只有一個節點，該狀態的樹結構更傾向於一種線性結構，節點的查詢類似於陣列的遍歷，複雜度為 O(n)。

也正是因此，後面就出現了平衡二叉樹，就涉及到了左旋右旋花裡胡哨的蛇皮操作，當然這只是提一下，並不在本文的範疇之內，不過後續應該會寫這方面的文章，儘量吧.....

5、二叉搜尋樹總結

二叉搜尋樹又稱二叉排序樹、二叉查詢樹，簡統稱BST

根據二叉搜尋樹的特性，==可知比較次數等於給定值節點在二叉排序樹中的層數==。遍歷的話使用中序遍歷。如果二叉排序樹是平衡的，則n個節點的二叉排序樹的高度為Log2n+1,其查詢效率為O(Log2n)，近似於折半查詢。如果二叉排序樹完全不平衡，則其深度可達到n，查詢效率為O(n)，退化為順序查詢。一般的，二叉排序樹的查詢效能在O(Log2n)到O(n)之間。因此，為了獲得較好的查詢效能，就要構造一棵平衡的二叉排序樹。而平衡二叉樹可能又要涉及到了左旋右旋花裡胡哨的蛇皮操作，當然這只是提一下，並不在本文的範疇之內，不過後續應該會寫這方面的文章，儘量吧.....

如果本文對你有一點點幫助，那麼請點個讚唄，謝謝~

最後，若有不足或者不正之處，歡迎指正批評，感激不盡！如果有疑問歡迎留言，絕對第一時間回覆！

歡迎各位關注我的公眾號，裡面有一些java學習資料和一大波java電子書籍，比如說周志明老師的深入java虛擬機器、java程式設計思想、核心技術卷、大話設計模式、java併發程式設計實戰.....都是java的聖經，不說了快上Tomcat車，咋們走！最主要的是一起探討技術，嚮往技術，追求技術，說好了來了就是盆友喔...

相關推薦