數據結構之樹-第二篇

數據結構之樹-第一篇

1、此時，將元素30從隊首拿出來，進行訪問，之後將30的左孩子29、右孩子42入隊，那麼此時隊首元素就是13了。

此時，將將元素13從隊首拿出來，進行訪問，之後將13的左孩子、右孩子入隊，由於13是葉子節點沒有左右孩子，所以沒有元素入隊了。

此時，看隊首元素是22，將元素22從隊首拿出來，進行訪問，之後將22的左孩子、右孩子入隊，由於22是葉子節點沒有左右孩子，所以沒有元素入隊了。

此時，看隊首元素是29，將元素29從隊首拿出來，進行訪問，之後將29的左孩子、右孩子入隊，由於29是葉子節點沒有左右孩子，所以沒有元素入隊了。

此時，看隊首元素是42，將元素42從隊首拿出來，進行訪問，之後將42的左孩子、右孩子入隊，由於42是葉子節點沒有左右孩子，所以沒有元素入隊了。

最後，查看隊列中隊首是誰，現在整個隊列都爲空了，沒有隊首元素，說明沒有任何元素排隊了，那麼，廣度優先遍歷也就是我們的層序遍歷就結束了。

2、刪除二分搜索樹的最小值，對於下面這個二分搜索樹，最小值就是一個葉子節點13，在這種情況下，非常的簡單，直接將這個葉子節點刪除即可，對於整棵二分搜索樹，不需要改變任何結構。

同理，此時這個二分搜索樹的最小值也是一個葉子節點15，在這種情況下，非常的簡單，直接將這個葉子節點刪除掉即可，對於整棵二分搜索樹，不需要改變任何結構。

但是，複雜的是，在這種情況下，此時在這種二分搜索樹中最小值是22，但是此時22這個節點不是葉子節點，22這個節點向左走再也走不動了，但是22這個節點有右子樹，在這種情況下，只需要將22這個節點刪除，將它的整個右子樹都變成是41的左子樹，就完成了這個刪除操作。

同理，刪除二分搜索樹的最大值，如果是葉子節點直接刪除掉即可，對於整棵二分搜索樹，不需要改變任何結構，同理，但是如果不是葉子節點，它向右走再也走不動了，但是58這個節點有左子樹，在這種情況下，只需要刪除58這個節點，然後將它的整個左子樹都變成是41的右子樹，就完成了這個刪除操作。 

3、如果刪除的節點只有左孩子的節點，在邏輯上和刪除最大節點的邏輯是一致的，注意，只有左孩子的節點不一定是最大值所在的節點，刪除滿足這種特性的節點，刪除方式就是將該節點刪除之後，將這個節點的左孩子所在的這棵二叉樹，也就是左子樹取代被刪除的節點的位置，連到原來這個節點的父親節點的右孩子節點上。比如58這個節點，將58節點刪除之後，將58的左子樹掛到58這個位置。

如果刪除的只有右孩子的節點，比如58這個節點，只有右孩子，在邏輯上和刪除最小值的邏輯是一致的，注意，只有右孩子的節點不一定是最小值所在的節點，刪除滿足這種特性的節點，刪除方式就是將該節點刪除之後，將這個節點的右孩子所在的這棵二叉樹，連接到被刪除節點的這個位置上。

二分搜索樹中刪除節點真正難的地方是刪除左右還有孩子的節點，比如刪除58這個節點如何刪除。刪除左右都有孩子的節點d，將58這個節點暫時起名爲d，這個d節點既有左孩子又有右孩子，在這種情況下，如何刪除呢，此時需要將d節點的左右子樹融合起來，那麼如何進行融合呢，對於這個d節點，既有左子樹，又有右子樹，根據二分搜索樹的定義，d節點的左子樹的所有節點元素都小於d節點元素，d節點的右子樹的所有節點元素都大於d節點元素，此時，將d節點刪除掉了，需要找到一個節點替代58這個節點的位置，如何進行找呢，此時，找到的58這個節點的後繼，也就是，在58這個節點的左右子樹中離58最近餓，比58還要大的這個節點，其實就是59，根據58的右子樹中所有對應的那個最小值的節點，這也很好理解，58的右子樹中所有的元素最小值的那個節點，因爲根據二分搜索樹，58右子樹中所有元素都比58大，其中最小的那個元素就是比58大，離58最近的那個元素，這裏面的最近，不是位置近，是大小的意思。

此時，讓s的左子樹等於d的左子樹，s -> node.left = d -> node.left;最後，刪除d節點，s是新的子樹的根節點。
4、數據結構之樹，代碼實現，如下所示。

 

package com.tree;


import java.util.*;

/**
 * 1、二分搜索樹，二分搜索樹存儲的內容支持泛型，但是不是支持所有的類型，應該對類型有一個限制，
 * 這個限制是這個類型必須擁有可比較性，對泛型E進行限制，這個限制就是繼承Comparable<E>接口，
 * 這個類型E必須具有可比較性。
 * <p>
 * <p>
 * 2、對於前序、中序、後序遍歷來說，不管是遞歸寫法還是非遞歸寫法，對於我們這棵二分搜索樹來說，
 * 我們都是在遍歷的過程中一紮到底，這樣的一種遍歷方式，其實還有另外一個名字，叫做，深度優先遍歷。
 * 對於這棵樹來說，都會先來到這棵樹最深的地方，直到不能再深了，纔開始返回回去，
 * 這種遍歷叫做深度優先遍歷。和深度優先遍歷相對的是另外一種遍歷方式，叫做廣度優先遍歷，
 * 廣度優先遍歷遍歷出來的結果，這個順序其實是整個二分搜索樹的層序遍歷的順序。
 */
public class BinarySearchTree<E extends Comparable<E>> {

    // 二分搜索樹的節點類，私有內部類。
    private class Node {
        private E e;// 存儲元素e;
        private Node left;// 指向左子樹，指向左孩子。
        private Node right;// 指向右子樹，指向右孩子。

        /**
         * 含參構造函數
         *
         * @param e
         */
        public Node(E e) {
            this.e = e;// 用戶存儲的元素e。
            left = null;// 左孩子初始化爲空。
            right = null;// 右孩子初始化爲空。
        }
    }

    private Node root;// 根節點
    private int size;// 二分搜索樹存儲了多少個元素

    /**
     * 無參構造函數，和默認構造函數做的事情一樣的。
     */
    public BinarySearchTree() {
        // 初始化的時候，二分搜索樹一個元素都沒有存儲
        root = null;
        size = 0;// 大小初始化爲0
    }

    /**
     * 返回二分搜索樹的含有多少個元素
     *
     * @return
     */
    public int size() {
        // 二分搜索樹的大小
        return size;
    }

    /**
     * 判斷二分搜索樹是否爲空。
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

//    /**
//     * 向二分搜索樹中添加新的元素e.
//     * <p>
//     * 在公開的二分搜索樹的調用的add方法。在將遞歸調用中，  是將新的元素e作爲node子節點插入進去的。
//     * 這個時候，形成了一個邏輯上的不統一，遞歸函數中，e元素和node.e元素進行了兩輪比較，第一輪比較，
//     * 在比較完他們的大小的同時，還要看一下node的左右兩邊是不是爲空，如果爲空直接插入，
//     * 對於第二輪比較，我們知道我們不能直接作爲Node的孩子插入這個元素e，只要再次遞歸的調用add的函數。
//     *
//     * @param e
//     */
//    public void add(E e) {
//        // 判斷，如果根節點是空的時候，直接指向新創建的節點即可
//        if (root == null) {
//            // 對根節點進行特殊的處理，如果根爲空的時候，就直接創建一個新的節點。
//            root = new Node(e);
//            // 維護size
//            size++;
//        } else {
//            // 否則，根節點不是空的時候。從根節點開始添加一個元素。
//            // 注意，由於需要遞歸的調用，對於每一個節點的左子樹也是一個更小的二分搜索樹的根節點，
//            // 對於每一個節點的右子樹也是一個更小的二分搜索樹的根節點。
//            // 所以在遞歸的過程中，創建一個新的遞歸的函數。
//
//            // 如果根不爲空，嘗試從根節點開始插入元素e。
//            add(root, e);
//        }
//
//    }
//
//    /**
//     * 私有的遞歸添加方法
//     * <p>
//     * 整體上是，向以node爲根的二分搜索樹中插入元素E，遞歸算法。
//     * <p>
//     * 之所以設置Node，就是因爲在插入的過程中，我們要不斷地轉換到新的更小的二分搜索樹中，
//     * 去找到這個新的元素e真正應該插入的位置，那麼相應的，我們在遞歸調用的過程中，
//     * 相當於二分搜索樹的根在逐漸變化的，所以，我們需要靠這個參數來體現這個變化。
//     *
//     * @param node Node結構本身都是對用戶屏蔽的，用戶不需要了解二分搜索樹中節點的結構。
//     * @param e
//     */
//    private void add(Node node, E e) {
//        // 精髓，將新的元素e插入給node的左孩子還是node的右孩子。
//        // 對當前的node來說，如果想插入到左邊，但是左孩子不爲空的話，再遞歸的將新的元素e插入到add(node.left, e);node的左子樹。
//        // 如果想插入到右邊，但是右孩子不爲空的話，再遞歸的將新的元素e插入到add(node.right, e);node的右子樹。
//
//
//        // 第一部分，遞歸終止的條件。
//        // 先檢查一下元素e，是不是等於node的元素e。
//        if (e.equals(node.e)) {
//            // 如果相等，說明要插入的元素已經存在於二分搜索樹中了。
//            return;
//            // 主要的插入代碼，就是下面的判斷，然後將元素e進行插入到左子樹還是右子樹的操作。
//        } else if (e.compareTo(node.e) < 0 && node.left == null) {
//            // 如果待插入元素e小於node的元素e，則把元素e插入到node的左子樹上面。
//            // 由於元素E滿足Comparable<E>類型的，所以應該是使用compareTo方法比較，不是基礎數據類型，不能使用大於號小於號比較。
//
//            // 如果此時node的左子樹又等於空，直接創建一個Node，將元素存儲到Node裏面即可。
//            // 此時元素e就變成了node的左孩子了。
//            node.left = new Node(e);
//            // 維護size的大小。
//            size++;
//            // return表示此次插入操作也完成了。
//            return;
//        } else if (e.compareTo(node.e) > 0 && node.right == null) {
//            // 如果待插入元素e大於node節點的元素e，則把元素e插入到node的右子樹上面。
//            // 此時，如果node的右孩子又等於空，直接創建一個Node，將元素存儲到Node即可。
//            // 此時，元素就變成了node的右孩子了。
//            node.right = new Node(e);
//            // 維護size的大小。
//            size++;
//            // return表示此次插入操作也完成了。
//            return;
//        }
//
//
//        // 遞歸的第二部分。遞歸調用的邏輯。
//        if (e.compareTo(node.e) < 0) {
//            // 如果待插入元素e小於node的元素e，遞歸調用add方法，參數一是向左子樹添加左孩子。
//            // 向左子樹添加元素e。
//            add(node.left, e);
//        } else if (e.compareTo(node.e) > 0) {
//            // 如果待插入元素e大於node的元素e，遞歸調用add方法，參數一是向右子樹添加右孩子。
//            // 向右子樹添加元素e。
//            add(node.right, e);
//        }
//    }


    /**
     * 向二分搜索樹中添加新的元素e。
     *
     * @param e
     */
    public void add(E e) {
        // 此時，不需要對root爲空進行特殊判斷。
        // 向root中插入元素e。如果root爲空的話，直接返回一個新的節點，將元素存儲到該新的節點裏面。
        root = add(root, e);
    }

    /**
     * 深入理解遞歸終止條件。
     * <p>
     * 返回插入新節點後二叉搜索樹的根。
     * <p>
     * 向以node爲根的二分搜索樹中插入元素e，遞歸算法。
     * <p>
     * <p>
     * 對於新的add遞歸函數，將向以node爲根的二分搜索樹中插入元素e，並且返回在做完這個操作以後這個二分搜索樹的根節點，
     * 如果我們傳入的這個node爲空的話，插入新的元素以後，就產生新的根節點，就是創建了一個Node e,
     * 否則的話，我們來比較我們待插入的元素e和當前的node e的大小關係，如果小於零的話，向左子樹添加一個左孩子，
     * 如果大於零的話，向右子樹添加一個右孩子。如果等於零的話，什麼都不操作。
     * 不管向左子樹添加元素還是向右子樹添加元素，插入完成之後，都將當前node的左孩子和右孩子進行重新賦值，
     * 在重新賦值以後，這個node依賴是這個以node爲根的二分搜索樹。相應的根節點將他返回回去。
     * <p>
     * 鏈表的遞歸插入和二分搜索樹的添加具有高度相似性的，在二分搜索樹中需要判斷一下，是要插入到左子樹還是右子樹。
     *
     * @param node
     * @param e
     * @return
     */
    private Node add(Node node, E e) {
        // 空本身也是一種二分搜索樹，空本身也是一顆二叉樹，換句話說，如果走遞歸函數，走到node爲空的時候
        // 一定要創建一個Node節點。上面的add方法實現，其實還沒有遞歸到底部。

        // 精髓，如果待插入元素e小於node的元素e，此時不管node.left是不是爲空，就再遞歸一層，
        // 如果遞歸的這一層，node等於空的話，也就是，現在要新插入一個元素，插入到哪裏，插入到空這顆
        // 二叉樹上，那麼，很顯然，這個位置本身就應該是這個節點。


        // 如果按照上面的思想，如果此時node等於空的話，此時，肯定要插入一個節點。
        if (node == null) {
            // 維護size的大小。
            size++;
            // 如果此時，直接創建一個Node的話，沒有和二叉樹掛接起來。
            // 如何讓此節點掛接到二叉樹上呢，直接將創建的節點return返回回去即可，返回給調用的上層。
            return new Node(e);
        }

        // 遞歸的第二部分。遞歸調用的邏輯。
        if (e.compareTo(node.e) < 0) {
            // 如果待插入元素e小於node的元素e，遞歸調用add方法，參數一是向左子樹添加左孩子。
            // 向左子樹添加元素e。
            // 向左子樹添加元素e的時候，爲了讓整顆二叉樹發生改變，在node的左子樹中插入元素e，
            // 插入的結果，有可能是變化的，所以就要讓node的左子樹連接住這個變化。

            // 注意，如果此時，node.left是空的話，這次add操作相應的就會返回一個新的Node節點，
            // 對於這個新的節點，我們的node.left被賦值這個新的節點，相當於我們就改變了整棵二叉樹。
            node.left = add(node.left, e);
        } else if (e.compareTo(node.e) > 0) {
            // 如果待插入元素e大於node的元素e，遞歸調用add方法，參數一是向右子樹添加右孩子。
            // 向右子樹添加元素e。
            node.right = add(node.right, e);
        }

        // 注意，如果如果待插入元素e等於node的元素e，不進行任何操作。

        // 最後將以node爲根的二叉樹返回回去。
        // 不管在第二部分產生了什麼變化，如果我們的node不爲空的話，我們進去了第二部分，
        // 向以node爲根的二分搜索樹中插入元素e之後，最終，插入了這個節點以後，
        // 二分搜索樹的根呢，還是這個node。
        return node;
    }


    /**
     * 查看二分搜索樹中是否包含元素e
     *
     * @param e
     * @return
     */
    public boolean contains(E e) {
        // 遞歸實現，遞歸的過程中，就要從這個二分搜索樹的根節點開始，逐漸的轉移在新的二分搜索樹的子樹中，
        // 縮小問題規模，縮小查詢的樹的規模，直到發現找到這個元素e或者找不到這個元素e。

        // 整體是看以我們這整棵二分搜索樹爲根的二分搜索樹中是否包含元素e。
        return contains(root, e);
    }

    /**
     * 看以node爲根的二分搜索樹中是否包含元素e，遞歸算法
     * <p>
     * 二分搜索樹查詢元素，對於查詢元素來說，我們只要不停的看節點node裏面保存的元素就好了。
     * 不牽扯到二分搜索樹，添加一個元素之後，又如何把它掛接到整個二分搜索樹中。
     *
     * @param node 節點Node
     * @param e    帶查詢的元素e
     * @return
     */
    private boolean contains(Node node, E e) {
        // 遞歸的第一部分
        if (node == null) {
            // 如果node節點爲空，是不包含元素e的，此時直接返回false
            return false;
        }

        // 遞歸的第二部分，開始邏輯判斷
        if (e.compareTo(node.e) == 0) {
            // 如果待查詢元素e和node的元素e相等
            return true;
        } else if (e.compareTo(node.e) < 0) {
            // 如果待查詢元素e小於node的元素e，如果此二分搜索樹中還包含元素e的話，那麼只可能在node的左子樹
            return contains(node.left, e);
        } else {
            // 如果待查詢元素e大於node的元素e，如果此二分搜索樹中還包含元素e的話，那麼只可能在node的右子樹
            return contains(node.right, e);
        }
    }


    /**
     * 二分搜索樹的前序遍歷。二分搜索樹的遍歷操作，就是把所有節點都訪問一遍。
     * 對於二分搜索樹的遍歷操作來說，兩棵子樹都要顧及，區別於添加或者查詢是否包含，
     * 只走左子樹或者右子樹。
     * <p>
     * <p>
     * 二分搜索樹的前序遍歷。爲什麼這種遍歷稱爲前序遍歷呢，是因爲先訪問這個節點，
     * 再訪問左右子樹，也就是說，訪問這個節點放在了訪問左右子樹的前面，所以叫做前序遍歷。
     * 基於此，也就有了二叉樹的中序遍歷和後序遍歷。
     */
    public void preOrder() {
        // 需要指定遞歸的調用，指定是那一棵二叉樹進行的前序遍歷。

        // 用戶的初始的調用，只需要對root根節點調用遞歸的preOrder就行了。
        preOrder(root);
    }

    /**
     * 前序遍歷以node爲根的二分搜索樹，遞歸算法。
     * <p>
     * 前序遍歷思路。
     * 首先先遍歷這個節點，再遍歷這個節點的左子樹，之後遍歷這個節點的右子樹。
     * <p>
     * 前序遍歷是最自然的遍歷方式，同時也是最常用的遍歷方式。如果沒有特殊情況下，在大多數情況下都是使用前序遍歷。
     *
     * @param node
     */
    private void preOrder(Node node) {
        // 遞歸的第一部分
        if (node == null) {
            // 如果node爲空的話，直接返回
            return;
        }

        // 遞歸的第二部分，開始遍歷
        System.out.println(node.e);
        // 遞歸的調用根節點root的左子樹。
        preOrder(node.left);   // 此處是循環遍歷左孩子，直到左孩子爲空，直接返回。
        // 遞歸的調用根節點root的右子樹。
        preOrder(node.right);  // 執行完上面循環遍歷左孩子，執行下面的循環遍歷右孩子，直到右孩子是空，直接返回。
//        // 此時，完成了二分搜索樹的前序遍歷。


        // 升級版遞歸過程
//        if (node != null) {
//            // 遞歸的第二部分，開始遍歷
//            System.out.println(node.e);
//            // 遞歸的調用根節點root的左子樹。
//            preOrder(node.left);
//            // 遞歸的調用根節點root的右子樹。
//            preOrder(node.right);
//            // 此時，完成了二分搜索樹的前序遍歷。
//        }
    }


    /**
     * 二分搜索樹的的前序遍歷的非遞歸方式實現。
     */
    public void preOrderNonRecursive() {
        // 棧的作用是記錄下面要到底要訪問那些節點，記錄下一次依次要訪問那些節點。
        // 泛型是Node類型的，存儲的二叉樹節點類型的對象。
        Stack<Node> stack = new Stack<Node>();
        // 初始的時候將root根節點push進去
        stack.push(root);

        // 進行循環操作，只要stack.isEmpty()爲false，說明了棧裏面有元素。
        // !stack.isEmpty()說明了記錄了下面要訪問那個節點。
        while (!stack.isEmpty()) {
            // 只要棧不爲空，說明記錄了下面要訪問那個節點。
            // 就要進行訪問這個節點。

            // 當前訪問的節點。
            Node current = stack.pop();//將當前的棧頂元素拿出來。
            // 此時current就是當前要訪問的節點。當前要訪問的節點直接打印即可。
            System.out.println(current.e);


            // 訪問了當前節點之後，就要依次訪問當前節點的左子樹，右子樹。
            // 由於棧是後入先出的，所以先將當前節點的右子樹push進去。
            // 此時應該判斷當前節點的右子樹是否爲空，如果爲空，就不要壓入棧了。
            if (current.right != null) {
                stack.push(current.right);// 右子樹壓入棧
            }
            // 此時應該判斷當前節點的左子樹是否爲空，如果爲空，就不要壓入棧了。
            if (current.left != null) {
                stack.push(current.left);//左子樹壓入棧
            }
        }

    }


    /**
     * 二分搜索樹的中序遍歷。
     * <p>
     * 二分搜索樹的的中序遍歷，先訪問這個節點的左子樹，再訪問這個節點，再訪問這個節點的右子樹。
     * 中序遍歷的中就體現在訪問該節點放在遍歷這個節點的左子樹和右子樹的中間。
     */
    public void inOrder() {
        inOrder(root);
    }

    /**
     * 中序遍歷以node爲根的二分搜索樹，遞歸算法。
     * <p>
     * <p>
     * 二分搜索樹的中序遍歷結果是順序的。有時候，因爲這個功能，二分搜索樹也叫做排序樹。
     *
     * @param node
     */
    private void inOrder(Node node) {
        // 遞歸的第一部分，遞歸終止的條件
        if (node == null) {
            // 如果node爲空的話，直接返回
            return;
        }

        // 遞歸的第二部分，開始遍歷
        // 遞歸的調用根節點root的左子樹。
        inOrder(node.left);   // 此處是循環遍歷左孩子，直到左孩子爲空，直接返回。
        // 此程序就是簡單的打印node節點的元素。就是訪問這個節點元素的過程。
        System.out.println(node.e);
        // 遞歸的調用根節點root的右子樹。
        inOrder(node.right);  // 執行完上面循環遍歷左孩子，執行下面的循環遍歷右孩子，直到右孩子是空，直接返回。
        // 此時，完成了二分搜索樹的中序遍歷。
    }


    /**
     * 後續遍歷，二分搜索樹的後序遍歷。
     */
    public void postOrder() {
        postOrder(root);
    }

    /**
     * 二分搜索樹的的後序遍歷。
     * <p>
     * 二分搜索樹的的後序遍歷，先訪問這個節點的左子樹，再訪問這個節點的右子樹，最後再訪問這個節點。
     * <p>
     * 後續遍歷必須先處理完左子樹，再處理完右子樹，最後處理這個節點。
     * <p>
     * 後續遍歷的一個應用，爲二分搜索樹釋放內存。先釋放左右孩子的內存，最後釋放這個節點的內存。
     *
     * @param node
     */
    private void postOrder(Node node) {
        // 遞歸的第一部分，遞歸終止的條件
        if (node == null) {
            // 如果node爲空的話，直接返回
            return;
        }

        // 遞歸的第二部分，開始遍歷
        // 遞歸的調用根節點root的左子樹。
        postOrder(node.left);   // 此處是循環遍歷左孩子，直到左孩子爲空，直接返回。
        // 遞歸的調用根節點root的右子樹。
        postOrder(node.right);  // 執行完上面循環遍歷左孩子，執行下面的循環遍歷右孩子，直到右孩子是空，直接返回。
        // 此程序就是簡單的打印node節點的元素。就是訪問這個節點元素的過程。
        System.out.println(node.e);
        // 此時，完成了二分搜索樹的後序遍歷。
    }


    /**
     * 二分搜索樹的層序遍歷
     * <p>
     * <p>
     * 相對於深度優先遍歷，廣度優先遍歷最大的有點，可以更快的找到你想要查詢的那個元素，
     * 這樣的區別，主要用於搜索策略上，而不是用於遍歷這種操作上，
     * 因爲遍歷需要將所有的元素都訪問一遍，在這種情況下，深度優先遍歷，
     * 廣度優先遍歷是沒有區別的。但是如果想要在一棵樹中找到某個問題的解的話，
     * 對於深度優先遍歷來說，將從根節點一下子訪問到樹的最深的地方，
     * 但是問題的解很可能在樹的上面，所以深度優先遍歷先估計左子樹，
     * 需要很長的時間才能訪問到最上面，在這種情況下，廣度優先遍歷就很有意義了，
     * 這種問題的模型，最常用於算法設計中的最短路徑的。
     */
    public void levelOrder() {
        // 由於Queue是接口，這裏使用鏈表的方式實現該Queue。
        Queue<Node> queue = new LinkedList<Node>();
        // 將根節點添加到隊列中
        queue.add(root);
        // 循環遍歷，當隊列不爲空的時候，queue.isEmpty()結果爲false表示隊列不爲空，
        // 當!queue.isEmpty()表示隊列不爲空的時候，繼續循環遍歷。
        while (!queue.isEmpty()) {
            // 聲明一個當前的節點current，也就是我們隊列中的元素出隊之後的那個元素，
            // 就是我們當前要訪問的這個元素。
            Node current = queue.remove();
            // 對於當前要訪問的這個元素，可以進行打印輸出
            System.out.println(current.e);

            // 之後，根據當前訪問的元素來看當前的這個節點左右孩子，如果有左孩子或者右孩子進行入隊。
            if (current.left != null) {
                queue.add(current.left);
            }
            // 如果當前節點有右孩子，就將當前節點的右孩子進行入隊操作。
            if (current.right != null) {
                queue.add(current.right);
            }
        }

    }


    /**
     * 尋找二分搜索樹的最小元素。
     * <p>
     * <p>
     * 此時，使用遞歸的算法比寫非遞歸的算法，要麻煩一點，因爲這裏相當於我們不停的只想左走，
     * 根本不考慮每一個節點的它的右子樹，或者是右孩子，那麼此時呢，我們跟操作一個鏈表是沒有區別的，
     * 相當於我們在操作對於每一個節點的next就是node.left這樣的一個鏈表，找它的尾節點而已。
     *
     * @return
     */
    public E minimum() {
        // 首先，判斷二分搜索樹中元素個數爲零，說明二分搜索樹中沒有元素，就拋出異常。
        if (size == 0) {
            // 首先，判斷二分搜索樹中元素個數爲零，就拋出異常。
            throw new IllegalArgumentException("BinarySearchTree is Empty.");
        }

        // 調用遞歸的方式進行查詢最小值
        Node minimum = minimum(root);
        // 此時將返回的最小節點的元素值e返回即可。
        return minimum.e;
    }

    /**
     * 返回以node爲根的二分搜索樹的最小值所在的節點。
     *
     * @param node
     */
    private Node minimum(Node node) {
        // 遞歸算法，第一個部分，遞歸終止的條件
        // 如果向左走，走不動了，這個就是最左節點了，即最小值
        if (node.left == null) {
            return node;
        } else {
            // 遞歸算法，第二部分，即如果節點最左節點不爲空
            // 將這個節點的左孩子作爲node傳遞進去，依次查看最左節點的值。
            return minimum(node.left);
        }
    }


    /**
     * 尋找二分搜索樹的最大元素。
     *
     * @return
     */
    public E maximum() {
        // 首先，判斷二分搜索樹中元素個數爲零，說明二分搜索樹中沒有元素，就拋出異常。
        if (size == 0) {
            // 首先，判斷二分搜索樹中元素個數爲零，就拋出異常。
            throw new IllegalArgumentException("BinarySearchTree is Empty.");
        }

        // 調用遞歸的方式進行查詢最大值
        Node maximum = maximum(root);
        // 此時將返回的最大節點的元素值e返回即可。
        return maximum.e;
    }

    /**
     * 返回以node爲根的二分搜索樹的最大值所在的節點。
     *
     * @param node
     */
    private Node maximum(Node node) {
        // 遞歸算法，第一個部分，遞歸終止的條件
        // 如果向右走，走不動了，這個就是最右節點了，即最大值
        if (node.right == null) {
            return node;
        } else {
            // 遞歸算法，第二部分，即如果節點最右節點不爲空
            // 將這個節點的右孩子作爲node傳遞進去，依次查看最右節點的值。
            return maximum(node.right);
        }
    }


    /**
     * 從二分搜索樹中刪除最小值所在節點，返回最小值。
     *
     * @return
     */
    public E removeMin() {
        // 將刪除的元素刪除掉
        E ret = minimum();

        // 設計刪除最小值的邏輯。最小值所在的節點從二分搜索樹中刪除掉。
        // 從根節點開始，嘗試從root節點開始，刪除最小值所在的節點。

        // 將刪除最小值以後的節點返回給root根節點。
        // 換句話說，我們從root爲根的二分搜索樹刪除掉了最小值，
        // 之後又返回了刪除掉最小值之後的那棵二分搜索樹對應的根節點。
        // 這個根節點就是新的root。
        root = removeMin(root);

        // 最後，將待刪除元素刪除掉就行了。
        return ret;
    }

    /**
     * 刪除掉以node爲根的二分搜索樹中的最小節點。
     * 返回刪除節點後新的二分搜索樹的根。
     * <p>
     * <p>
     * 這個邏輯就是在這種情況下，刪除node節點的左子樹對應的最小值，刪除掉之後，對於我們當前
     * 這個以node爲根的二分搜索樹，在做完這些操作之後，它的根節點依然是node，將它返回回去。
     *
     * @param node
     */
    private Node removeMin(Node node) {
        // 遞歸調用，遞歸到底，終止條件。
        // 就是節點左子樹爲空的時候，就是向左走，直到不能再走的時候，就終止條件
        // 就是當前這個節點不能再向左走了，即當前這個節點就是最小值。
        // 所在的節點，就是這個待刪除的節點。
        if (node.left == null) {
            // 我們要刪除當前這個節點，但是當前這個節點可能有右子樹的，則右子樹的部分不可以丟失掉。
            // reightNode保存當前節點的右子樹。
            Node reightNode = node.right;
            // 保存當前節點的右子樹之後，就將當前節點的右子樹置空就行了。
            // 將當前節點的右子樹和這個二分搜索樹脫離關係。
            node.right = null;
            // 返回保存的右子樹，爲什麼返回這個呢，因爲這個函數做的事情就是刪除掉以node爲根的二分搜索樹中的最小節點，
            // 返回刪除節點後新的二分搜索樹的根，此時，最小節點就是node節點本身，將node刪除掉之後，
            // 新的二分搜索樹的根就是node.right，就是node的右孩子，它就是node的右子樹對應的那個根節點。
            // 如果node的右孩子爲空，沒有關係，就說明node的右子樹爲空，一棵空樹，它的根節點還是空。

            // 維護size的大小。因爲刪除掉一個元素，所以要維護size的大小。
            size--;
            return reightNode;
            // 這就是刪除最小節點這個算法來說，遞歸到底的情況。
        }


        // 如果此時，沒有遞歸到底，就說明還有左孩子。
        // 就是進行遞歸操作的第二部分就行了。去刪除掉這個當前節點node的左子樹所對應的最小值。
        // Node removeMin = removeMin(node.left);
        // 刪除掉以node爲根的二分搜索樹中的最小節點。
        // 返回刪除節點後新的二分搜索樹的根。
        // 這樣纔可以真正改變二分搜索樹的結構。
        // node.left = removeMin;
        node.left = removeMin(node.left);

        // 返回當前節點
        return node;
    }


    /**
     * 從二分搜索樹中刪除最大值所在節點，返回最大值。
     * <p>
     * 刪除最大值，類比刪除最小值的思路即可。
     *
     * @return
     */
    public E removeMax() {
        // 將刪除的元素刪除掉
        E ret = maximum();

        root = removeMax(root);

        // 最後，將待刪除元素刪除掉就行了。
        return ret;
    }


    /**
     * 刪除掉以node爲根的二分搜索樹中的最大節點。
     * 返回刪除節點後新的二分搜索樹的根。
     *
     * @param node
     */
    private Node removeMax(Node node) {
        // 當走到該節點最右孩子的時候，即最右孩子是空的時候，就走到了最底。
        if (node.right == null) {
            // 保存當前節點的左子樹。因爲對於當前節點，右子樹已經爲空了。
            // 刪除掉這個節點之後，這個節點的左子樹的根節點就是新的根節點，
            Node leftNode = node.left;
            // 保存當前節點的左子樹之後，就將當前節點的左子樹置空就行了。
            // 將當前節點的左子樹和這個二分搜索樹脫離關係。
            node.left = null;
            // 刪除節點，維護size的大小
            size--;
            // 刪除掉這個節點之後，那麼，這個節點的左子樹的根節點，就是新的根節點。
            return leftNode;
        }

        // 如果遞歸沒有到到底的話，我們做的事情就是去刪除當前這個節點右子樹中的最大值，
        // 將最終的結果返回給當前的這個節點的右孩子。然後返回node節點。
        node.right = removeMax(node.right);

        // 返回當前節點
        return node;
    }


    /**
     * 從二分搜索樹中刪除元素爲e的節點。
     *
     * @param e
     */
    public void remove(E e) {
        // 參數一是根節點，參數二是待刪除元素

        // 將刪除掉元素e之後d得到的新的二分搜索樹的根節點返回回來
        root = remove(root, e);
    }

    /**
     * 刪除掉以node爲根的二分搜索樹中值爲e的節點，遞歸算法。
     * 返回刪除節點後新的二分搜索樹的根。
     * <p>
     * <p>
     * 刪除左右都有孩子的節點d，找到p = max(d -> node.left)。p是d的前驅。
     * 此刪除方法是找到待刪除節點的後繼，也可以找到當前節點的前驅。
     *
     * @param node
     * @param e
     */
    private Node remove(Node node, E e) {
        // 如果node節點爲空，直接返回空即可。
        // 另外一層含義，在二分搜索樹中找這個元素爲e的節點，根本沒有找到，最後找到node爲空的位置了，
        // 直接返回空就行了。
        if (node == null) {
            return null;
        }

        // 遞歸函數，開始近邏輯
        // 如果待刪除元素e和當前節點的元素e進行比較，如果待刪除元素e小於該節點的元素e
        if (e.compareTo(node.e) < 0) {
            // 此時，去該節點的左子樹，去找到待刪除元素節點
            // 遞歸調用，去node的左子樹，去刪除這個元素e。
            // 最後將刪除的結果賦給該節點左子樹。
            node.left = remove(node.left, e);
            return node;
        } else if (e.compareTo(node.e) > 0) {
            // 如果待刪除元素e大於該節點的元素e
            // 去當前節點的右子樹去尋找待刪除元素節點
            // 將刪除後的結果返回給當前節點的右孩子
            node.right = remove(node.right, e);
            return node;
        } else {
            // 當前節點元素e等於待刪除節點元素e，即e == node.e，
            // 相等的時候，此時就是要刪除這個節點的。

            // 如果當前節點node的左子樹爲空的時候，待刪除節點左子樹爲空的情況
            if (node.left == null) {
                // 保存該節點的右子樹
                Node rightNode = node.right;
                // 將node和這棵樹斷開關係
                node.right = null;
                // 維護size的大小
                size--;
                // 返回原來那個node的右孩子。也就是右子樹的根節點，此時就將node刪除掉了
                return rightNode;
            }

            // 如果當前節點的右子樹爲空，待刪除節點右子樹爲空的情況。
            if (node.right == null) {
                // 保存該節點的左子樹
                Node leftNode = node.left;
                // 將node節點和這棵樹斷開關係
                node.left = null;
                // 維護size的大小
                size--;
                //返回原來那個節點node的左孩子，也就是左子樹的根節點，此時就將node刪除掉了。
                return leftNode;
            }

            // 待刪除節點左右子樹均爲不爲空的情況。
            // 核心思路，找到比待刪除節點大的最小節點，即待刪除節點右子樹的最小節點
            // 用這個節點頂替待刪除節點的位置。

            // 找到當前節點node的右子樹中的最小節點，找到比待刪除節點大的最小節點。
            // 此時的successor就是node的後繼。
            Node successor = minimum(node.right);
            // 此時將當前節點node的右子樹中的最小節點刪除掉，並將二分搜索樹的根節點返回。
            // 將新的二分搜索樹的根節點賦值給後繼節點的右子樹。
            successor.right = removeMin(node.left);

            // 因爲removeMin操作，刪除了一個節點，但是此時當前節點的右子樹的最小值還未被刪除
            // 被successor後繼者指向了。所以這裏做一些size加加操作，
            size++;

            // 將當前節點的左子樹賦值給後繼節點的左子樹上。
            successor.left = node.left;
            // 將node節點沒有用了，將node節點的左孩子和右孩子置空。讓node節點和二分搜索樹脫離關係
            node.left = node.right = null;

            // 由於此時，將當前節點node刪除掉了，所以這裏做一些size減減操作。
            size--;

            // 返回後繼節點
            return successor;
        }

    }


    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        // 使用一種形式展示整個二分搜索樹，可以先展現根節點，再展現左子樹，再展現右子樹。
        // 上述這種過程就是一個前序遍歷的過程。
        // 參數一，當前遍歷的二分搜索樹的根節點，初始調用的時候就是root。
        // 參數二，當前遍歷的這棵二分搜索樹的它的深度是多少，根節點的深度是0。
        // 參數三，將字符串傳入進去，爲了方便生成字符串。
        generateBSTString(root, 0, stringBuilder);

        return stringBuilder.toString();
    }

    /**
     * 生成以node爲根節點，深度爲depth的描述二叉樹的字符串。
     *
     * @param node          節點
     * @param depth         深度
     * @param stringBuilder 字符串
     */
    private void generateBSTString(Node node, int depth, StringBuilder stringBuilder) {
        // 遞歸的第一部分
        if (node == null) {
            // 顯示的，將在字符串中追加一個空字符串null。
            // 爲了表現出當前的空節點對應的二分搜索樹的層次，封裝了一個方法。
            stringBuilder.append(generateDepthString(depth) + "null\n");
            return;
        }


        // 遞歸的第二部分
        // 噹噹前節點不爲空的時候，就可以直接訪問當前的node節點了。
        // 將當前節點信息放入到字符串了
        stringBuilder.append(generateDepthString(depth) + node.e + "\n");

        // 遞歸進行調用
        generateBSTString(node.left, depth + 1, stringBuilder);
        generateBSTString(node.right, depth + 1, stringBuilder);
    }

    /**
     * 爲了表現出二分搜索樹的深度
     *
     * @param depth
     * @return
     */
    private String generateDepthString(int depth) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            stringBuilder.append("--");
        }
        return stringBuilder.toString();
    }


    public static void main(String[] args) {
        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<Integer>();
        int[] nums = new int[]{1, 5, 3, 6, 8, 4, 2};
//        for (int i = 0; i < nums.length; i++) {
//            // 二分搜索樹的新增
//            binarySearchTree.add(nums[i]);
//        }
        for (int num : nums) {
            binarySearchTree.add(num);
        }


        // 二分搜索樹的前序遍歷
        binarySearchTree.preOrder();
        System.out.println();


        // 二分搜索樹的中序遍歷
        binarySearchTree.inOrder();
        System.out.println();

        // 二分搜索樹的後序遍歷
        binarySearchTree.postOrder();
        System.out.println();

        // 二分搜索樹的非遞歸的前序遍歷。
        binarySearchTree.preOrderNonRecursive();
        System.out.println();

        // 二分搜索樹的非遞歸的層序遍歷。
        binarySearchTree.levelOrder();
        System.out.println();

        // 二分搜索樹的遞歸的刪除任意元素
        System.out.println("二分搜索樹的遞歸的刪除任意元素.");
        binarySearchTree.remove(5);
        System.out.println(binarySearchTree);


//        System.out.println(binarySearchTree.toString());
//        5
//        --3
//        ----2
//        ------null
//        ------null
//        ----4
//        ------null
//        ------null
//        --6
//        ----null
//        ----8
//        ------null
//        ------null


        // 二分搜索樹的遞歸的刪除最小值
//        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<Integer>();
//        Random random = new Random();
//        int n = 1000;
//        for (int i = 0; i < n; i++) {
//            // 隨機添加1000個0-10000之間的數字。有可能重複，總數可能小於1000
//            binarySearchTree.add(random.nextInt(10000));
//        }
//
//        ArrayList<Integer> nums = new ArrayList<Integer>();
//        while (!binarySearchTree.isEmpty()) {
//            nums.add(binarySearchTree.removeMin());
//        }
//        System.out.println(nums);
//
//        // 判斷是否是從小到大排序的
//        for (int i = 1; i < nums.size(); i++) {
//            if (nums.get(i - 1) > nums.get(i)) {
//                throw new IllegalArgumentException("Error.");
//            }
//        }
//        System.out.println("removeMin test completed.");


        // 二分搜索樹的遞歸的刪除最大值
//        BinarySearchTree<Integer> binarySearchTree2 = new BinarySearchTree<Integer>();
//        Random random2 = new Random();
//        int n2 = 1000;
//        for (int i = 0; i < n2; i++) {
//            // 隨機添加1000個0-10000之間的數字。有可能重複，總數可能小於1000
//            binarySearchTree2.add(random2.nextInt(10000));
//        }
//
//        ArrayList<Integer> nums2 = new ArrayList<Integer>();
//        while (!binarySearchTree2.isEmpty()) {
//            nums2.add(binarySearchTree2.removeMax());
//        }
//        System.out.println(nums2);
//
//        // 判斷是否是從小到大排序的
//        for (int i = 1; i < nums2.size(); i++) {
//            if (nums2.get(i - 1) < nums2.get(i)) {
//                throw new IllegalArgumentException("Error.");
//            }
//        }
//        System.out.println("removeMax test completed.");

    }

}