01玩转数据结构_06_二分搜索树

为什么要研究树结构：

因为生活中本身就有这很多的树结构实例。

例如：电脑中的文件系统，图书馆中的图书分类等等。。。

一个公司中也可以体现树这种结构。

为什么要有树结构：

无论是在生活中，还是在计算机中，大量充斥着树结构，那么为什么呢？

因为高效，快速。

二分搜索树基础：

二叉树：

当然，如果一个节点有多个分叉，那么就形成了多叉树。后面的字典树其实就是个多叉树。 

不过，二叉树是使用最多的。这里的例子绝大部分都是二叉树。

二叉树的特点：

没有孩子的节点称之为 叶子节点。

整个二叉树中只有一个节点没有父亲节点，就是根节点。 

二叉树的结构：

二叉树具有天然的递归结构。

它的左子树也是个二叉树，它的右子树也是个二叉树。  

上面图片中的二叉树 是 “满” 的。 不过二叉树不一定是满的，如下面的图片： 

二分搜索树 Binary Search Tree：

二分搜索树也是二叉树。

二分搜索树除了是二叉树以外还具有自己独特的性质：

它的每个节点的值都要大于其左子树的所有的节点的值，

它的每个节点的值都要小于其右子树的所有的节点的值。 

也就是说，二分搜索树的每个子树也都是二分搜索树。 

下面的图是个更大的二分搜索树：

二分搜索树为什么这么定义呢？

因为这样定义的话， 对于一个节点，它的左子树的每个节点的值都小于该节点的值，它的有子树的每个节点的值都大于该节点的值。 

41的左子树根本不需要遍历，这就大大的加块的遍历查找的速度了。我们在生活中使用树这种结构也是这个原因。

这里需要注意的是：树中存储的元素要有可比较性。如果要存储自己自定义的数据类型，通常我们要给出 两个自定义类型之间是如何进行比较的。 

package cn.zcb.demo02;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;  
    }



}

向二分搜索树中添加元素--分析：

刚一开始树中一个元素都没有：如下图：

添加一个元素41，那么41就成为了根。 

现在又来了个22，因为它是小于41，所以它要变为41的左孩子。 

假设树已经为如下情况：

此时又来了个60.

60先和41比较，因为它是大于41的，所以它一定要插在41的右子树，

此时，58和60比较，因为60大于58，故它应该插在58的右子树！

然后58的右子树为空，所以就插入到58的右子树。 

再如：如果此时要插入28的话，

因为28小于41，所以应该插在41的左子树。

因为28大于22，所以应该插在22的右子树。

因为28小于33，所以应该插入33的左子树。

因为33左子树为空，所以就应该插在33的左孩子！ 

再如：如果此时要插入50的话，

因为50大于41，所以要插在41的右子树，

因为50小于58，所以要插在58的左子树，

因为50=50，所以就不作任何操作了。（我们这里是这样操作的。）

如果感兴趣，也可以自己实现一个包含重复元素的二分搜索树。 

注：前面说的 数组 和 链表是可以有重复元素的。

其实，看到底有没有重复元素，要依具体的应用来看。

向二分搜索树中添加元素--代码实现：

其实，对于这个需求，非递归实现也很简单，

，如下图：

不过，我们这里采用递归算法，采用递归不是说，非递归不重要。只是加深递归的理解。 

递归算法的开销还是很大的。

这里的代码都是递归的。对于非递归的代码，有时间可以尝试。 

package cn.zcb.demo02;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        if(this.root == null){ //如果根节点为空，
            this.root = new Node(t);
            this.size ++;
        }else{
            //调用递归函数
            add(this.root,t);
        }

    }
    //此时 node 为根节点。
    private void add(Node node,T t){
        if(t.equals(node.t) )
            return;  //此时相等，不作任何事情
        else if(t.compareTo(node.t) < 0 && node.left == null ){
            var newNode = new Node(t);
            node.left = newNode;
            this.size ++;
            return;
        }else if(t.compareTo(node.t) >0 && node.right == null){
            var newNode = new Node(t);
            node.right = newNode;
            this.size ++;
            return;
        }   //上面都是终止条件 。。。。。。  下面是递归链条！  

        if(t.compareTo(node.t) < 0) //此时的node.left 和node.right一定不等于null了
            add(node.left,t);
        else
            add(node.right,t);
    }
}

上面代码针对 根节点和其他的节点插入时候，逻辑没有统一，下面是改进版：

package cn.zcb.demo02;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }

}

如果有时间，我们也应该尝试一下使用链表来实现！！！

区别：树来存的要判断插入左子树 还是右子树，

而用链表的话，直接插入到next中就行了。（next有两个，左，右两个next ）

如何在二分搜索树中查询元素：

看当前的树中是否包含 元素。

package cn.zcb.demo02;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }


    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }






}

二分搜索树中遍历操作--前序遍历：

在插入和查找的代码中，我们每次值选择一个子树进入，但是对于遍历就不是这样了。

由于我们要访问二叉树中所有的节点，所以对于一个节点，它的左右子树都要有所顾及。

通常这种遍历，我们也称之为前序遍历（先访问该节点，然后再访问左右子树！）

package cn.zcb.demo02;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }

    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }

    // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(this.root);

    }
    //遍历  以 node 为根节点的二分搜索树
    private void preOrder(Node node){
        if(node == null)
            return;
        else
            System.out.println(node.t); //t一定是可以比较的。上面接口已经限制了。

        preOrder(node.left); //先递归完 左子树之后，再递归右子树。
        preOrder(node.right);
    }


    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        generateBinarySearchTreeString(this.root,0,builder); //builder是传出参数
        return builder.toString();
    }

    //生成以 node 为根节点，深度为depth 的 描述二叉树的 字符串
    private void generateBinarySearchTreeString(Node node,int depth,StringBuilder builder){
        if(node == null){
            builder.append(generateDepthInfo(depth)+"|null 
");
            return;
        }
        builder.append(generateDepthInfo(depth)+node.t+"
"); //不要忘了！！！

        generateBinarySearchTreeString(node.left,depth+1,builder);
        generateBinarySearchTreeString(node.right,depth+1,builder);
    }
    //生成 关于深度的字符串。
    private String generateDepthInfo(int depth){
        StringBuilder res = new StringBuilder();
        for (int i =0;i<depth;i++ ){
            res.append("=");  //一个= 对应一个深度。
        }
        return res.toString();
    }

}

package cn.zcb.demo02;

public class Test{
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        int [] nums = {5,3,6,8,4,2};
        for (int num :nums)
            bst.add(num);

        bst.preOrder();//前序遍历

        //直接打印 二叉树
        System.out.println(bst);  //每个等号 代表一个深度！



    }
}
/* 输出
5
3
2
4
6
8
5
=3
==2
===|null 
===|null 
==4
===|null 
===|null 
=6
==|null 
==8
===|null 
===|null 
*
* */

上面的代码输出的可读性仍然不是特别的易读。

思考题：如何能像下图一样打印输出呢？

这个需要用到后面说的二叉树的程序遍历！而且也要计算每个数字之前有多少个空格，这算是个比较难的挑战！

二分搜索树中遍历操作的另外两种--中序和后序  遍历：

对于树的遍历，前序遍历是最自然的遍历方式，是最常用的遍历方式！

下面看：中序遍历 和 后序遍历：

package cn.zcb.demo02;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }

    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }

    // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(this.root);

    }
    //遍历  以 node 为根节点的二分搜索树
    private void preOrder(Node node){
        if(node == null)
            return;
        else
            System.out.println(node.t); //t一定是可以比较的。上面接口已经限制了。

        preOrder(node.left); //先递归完 左子树之后，再递归右子树。
        preOrder(node.right);
    }


    //二分搜索树的中序遍历  先左 中 然后再右
    public void midOrder(){
        midOrder(this.root);
    }
    //中序遍历 遍历以node 为根节点的树
    private void midOrder(Node node){
        if(node == null)
            return;

        //先遍历该节点的左子树
        midOrder(node.left);
        System.out.println(node.t);
        midOrder(node.right);
    }

    //二分搜索树后序遍历  先左 右 然后 当前节点
    public void lastOrder(){
        lastOrder(this.root);
    }
    //后序遍历 遍历 以node 为根节点的二叉搜索树
    private void lastOrder(Node node){
        if(node == null)
            return;

        //先遍历 左子树
        lastOrder(node.left);
        lastOrder(node.right);
        System.out.println(node.t);
    }


    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        generateBinarySearchTreeString(this.root,0,builder); //builder是传出参数
        return builder.toString();
    }

    //生成以 node 为根节点，深度为depth 的 描述二叉树的 字符串
    private void generateBinarySearchTreeString(Node node,int depth,StringBuilder builder){
        if(node == null){
            builder.append(generateDepthInfo(depth)+"|null 
");
            return;
        }
        builder.append(generateDepthInfo(depth)+node.t+"
"); //不要忘了！！！

        generateBinarySearchTreeString(node.left,depth+1,builder);
        generateBinarySearchTreeString(node.right,depth+1,builder);
    }
    //生成 关于深度的字符串。
    private String generateDepthInfo(int depth){
        StringBuilder res = new StringBuilder();
        for (int i =0;i<depth;i++ ){
            res.append("=");  //一个= 对应一个深度。
        }
        return res.toString();
    }

}

package cn.zcb.demo02;

public class Test{
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        int [] nums = {5,3,6,8,4,2};
        for (int num :nums)
            bst.add(num);

        bst.preOrder();//前序遍历
        System.out.println("============");
        bst.midOrder();//中序遍历  根据结果可以发现中序的结果就是当前二分搜索树存储元素的排序输出。

        System.out.println("============");
        bst.lastOrder();//后序遍历

        System.out.println("============");
        //直接打印 二叉树
        System.out.println(bst);  //每个等号 代表一个深度！



    }
}
/* 输出
* */

由上面代码的输出容易发现中序的输出是有顺序的。

中序的性质：输出是 整个树中元素的  顺序输出 。 

后序遍历的应用：如果需要释放内存。我们需要将一个 节点的孩子先释放完毕，才能释放自己。所以这时可以采用后序遍历 释放！（Java用不到，C/C++可以用到）

二分搜索树的前序遍历 的非递归实现：

模拟系统栈：

栈的作用是用来帮我们记录下次要访问的元素 ！

1，首先将28压入栈

然后访问28，

2，将28的两个孩子压入栈（先压 30，后压16）

这时访问16，

3，将16的两个孩子压入栈（先压 22，后压13）

然后，访问13 ，因为13没有孩子了，所以访问22，因为22也没孩子，所以访问30.

4，将30的两个孩子压入栈（先压 42，后压29）

然后访问29,29没孩子，访问42,42没孩子了，而且此时栈为空。所以访问结束。

下面看代码：

package cn.zcb.demo02;

import java.util.Stack;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }

    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }

    // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(this.root);

    }
    //遍历  以 node 为根节点的二分搜索树
    private void preOrder(Node node){
        if(node == null)
            return;
        else
            System.out.println(node.t); //t一定是可以比较的。上面接口已经限制了。

        preOrder(node.left); //先递归完 左子树之后，再递归右子树。
        preOrder(node.right);
    }

    // 二分搜索树的前序遍历 （使用非递归 NR 实现，利用 栈 来实现！！！）
    public void preOrderNR(){
        Stack<Node> stk = new Stack<>();
        stk.push(this.root); //将根节点的值压入栈中。

        while (!stk.isEmpty()){
            Node temp = stk.pop();
            System.out.println(temp.t); //访问

            if(temp.right != null)
                stk.push(temp.right);
            if(temp.left != null)
                stk.push(temp.left);
        }
    }


    //二分搜索树的中序遍历  先左 中 然后再右
    public void midOrder(){
        midOrder(this.root);
    }
    //中序遍历 遍历以node 为根节点的树
    private void midOrder(Node node){
        if(node == null)
            return;

        //先遍历该节点的左子树
        midOrder(node.left);
        System.out.println(node.t);
        midOrder(node.right);
    }

    //二分搜索树后序遍历  先左 右 然后 当前节点
    public void lastOrder(){
        lastOrder(this.root);
    }
    //后序遍历 遍历 以node 为根节点的二叉搜索树
    private void lastOrder(Node node){
        if(node == null)
            return;

        //先遍历 左子树
        lastOrder(node.left);
        lastOrder(node.right);
        System.out.println(node.t);
    }


    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        generateBinarySearchTreeString(this.root,0,builder); //builder是传出参数
        return builder.toString();
    }

    //生成以 node 为根节点，深度为depth 的 描述二叉树的 字符串
    private void generateBinarySearchTreeString(Node node,int depth,StringBuilder builder){
        if(node == null){
            builder.append(generateDepthInfo(depth)+"|null 
");
            return;
        }
        builder.append(generateDepthInfo(depth)+node.t+"
"); //不要忘了！！！

        generateBinarySearchTreeString(node.left,depth+1,builder);
        generateBinarySearchTreeString(node.right,depth+1,builder);
    }
    //生成 关于深度的字符串。
    private String generateDepthInfo(int depth){
        StringBuilder res = new StringBuilder();
        for (int i =0;i<depth;i++ ){
            res.append("=");  //一个= 对应一个深度。
        }
        return res.toString();
    }

}

package cn.zcb.demo02;

public class Test{
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        int [] nums = {5,3,6,8,4,2};
        for (int num :nums)
            bst.add(num);

        bst.preOrderNR();// 非递归的方法 进行前序遍历！
    }
}
/* 输出
5
3
2
4
6
8
* */

这里我们发现，二分搜索树的非递归实现，比递归实现复杂很多，我们必须要使用一个数据结构来辅助完成！（这里使用的是栈！）

不过，无论是递归还是非递归实现，我们会发现，对于树的遍历，我们都是“一扎到底”！这种的模式叫做深度优先遍历。
和深度优先遍历对应的就是广度优先遍历。
广度优先遍历的结果其实是二分搜索树的层序遍历结果！

二分搜索树的层序遍历：

这里我们使用的方法是非递归的方式，
而且这里要借助 队列这种数据结构的帮助！

1，初始化时将28入队,

此时访问28，

2，将28的左右两个孩子16,30分别入队

此时访问16，如下：

3，将16的左右两个孩子分别入队

此时访问30. 

4，将30的左右两个孩子29,42分别入队

此时访问13，

13 没有孩子了，故不入队。

此时访问22，

22没有孩子了，故不入队。

此时访问29，

29 没有孩子了，故不入队。

此时访问42，

42没有孩子了，故不入队。

最后队列为空，遍历结束！

规律：访问一个元素，就将它的孩子压入队列。  

层序遍历代码：

package cn.zcb.demo02;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }

    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }

    // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(this.root);

    }
    //遍历  以 node 为根节点的二分搜索树
    private void preOrder(Node node){
        if(node == null)
            return;
        else
            System.out.println(node.t); //t一定是可以比较的。上面接口已经限制了。

        preOrder(node.left); //先递归完 左子树之后，再递归右子树。
        preOrder(node.right);
    }

    // 二分搜索树的前序遍历 （使用非递归 NR 实现，利用 栈 来实现！！！）
    public void preOrderNR(){
        Stack<Node> stk = new Stack<>();
        stk.push(this.root); //将根节点的值压入栈中。

        while (!stk.isEmpty()){
            Node temp = stk.pop();
            System.out.println(temp.t); //访问

            if(temp.right != null)
                stk.push(temp.right);
            if(temp.left != null)
                stk.push(temp.left);
        }
    }


    //二分搜索树的中序遍历  先左 中 然后再右
    public void midOrder(){
        midOrder(this.root);
    }
    //中序遍历 遍历以node 为根节点的树
    private void midOrder(Node node){
        if(node == null)
            return;

        //先遍历该节点的左子树
        midOrder(node.left);
        System.out.println(node.t);
        midOrder(node.right);
    }

    //二分搜索树后序遍历  先左 右 然后 当前节点
    public void lastOrder(){
        lastOrder(this.root);
    }
    //后序遍历 遍历 以node 为根节点的二叉搜索树
    private void lastOrder(Node node){
        if(node == null)
            return;

        //先遍历 左子树
        lastOrder(node.left);
        lastOrder(node.right);
        System.out.println(node.t);
    }

    //二分搜索树的 层序遍历
    public void levelOrder(){
        Queue<Node> queue = new LinkedList<>(); //因为 Queue本质是个接口，我们要选择它的一个实现类

        queue.add(this.root);

        while (!queue.isEmpty()){
            Node temp = queue.remove();
            System.out.println(temp.t); //访问

            if(temp.left != null)
                queue.add(temp.left);
            if(temp.right != null)
                queue.add(temp.right);
        }
    }




    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        generateBinarySearchTreeString(this.root,0,builder); //builder是传出参数
        return builder.toString();
    }

    //生成以 node 为根节点，深度为depth 的 描述二叉树的 字符串
    private void generateBinarySearchTreeString(Node node,int depth,StringBuilder builder){
        if(node == null){
            builder.append(generateDepthInfo(depth)+"|null 
");
            return;
        }
        builder.append(generateDepthInfo(depth)+node.t+"
"); //不要忘了！！！

        generateBinarySearchTreeString(node.left,depth+1,builder);
        generateBinarySearchTreeString(node.right,depth+1,builder);
    }
    //生成 关于深度的字符串。
    private String generateDepthInfo(int depth){
        StringBuilder res = new StringBuilder();
        for (int i =0;i<depth;i++ ){
            res.append("=");  //一个= 对应一个深度。
        }
        return res.toString();
    }

}

package cn.zcb.demo02;

public class Test{
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        int [] nums = {5,3,6,8,4,2};
        for (int num :nums)
            bst.add(num);

        bst.levelOrder();// 树结构的层序遍历！
    }
}
/* 输出
5
3
6
2
4
8
* */

对于遍历来说，深度优先遍历和 广度优先遍历差不多，它们都要将每个元素都走一遍，

但是对于查找来说，就不一样了。
如果我们要查找的元素在深度很小的地方，这时如果用深度优先，程序会一股脑的“一扎到底”！
此时使用广度优先就有好处了。所以对于查找来说，广度优先 比较好！

广度优先 的意义：
更快的找到问题的解，
常用于算法设计中---求最短路径，

图中也有深度优先和广度优先的应用！

二分搜索树 之 删除节点：

在树中删除节点是比较复杂的，这里先从简单的开始---删除二分搜索树中的最小值和最大值！

删除二分搜索树的最小值 和 最大值 ：

我们根据二分搜索树的特点，很容易知道
树中的最小值是 从根节点向左子树找，直到最后一个没有左子树的节点的值。
树中的最大值是 从根节点向右子树找，直到最后一个没有右子树的节点的值。

对于上图就是

最小值：13，最大值：42

下图是
最小值：16，最大值：30

package cn.zcb.demo02;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }

    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }

    // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(this.root);

    }
    //遍历  以 node 为根节点的二分搜索树
    private void preOrder(Node node){
        if(node == null)
            return;
        else
            System.out.println(node.t); //t一定是可以比较的。上面接口已经限制了。

        preOrder(node.left); //先递归完 左子树之后，再递归右子树。
        preOrder(node.right);
    }

    // 二分搜索树的前序遍历 （使用非递归 NR 实现，利用 栈 来实现！！！）
    public void preOrderNR(){
        Stack<Node> stk = new Stack<>();
        stk.push(this.root); //将根节点的值压入栈中。

        while (!stk.isEmpty()){
            Node temp = stk.pop();
            System.out.println(temp.t); //访问

            if(temp.right != null)
                stk.push(temp.right);
            if(temp.left != null)
                stk.push(temp.left);
        }
    }


    //二分搜索树的中序遍历  先左 中 然后再右
    public void midOrder(){
        midOrder(this.root);
    }
    //中序遍历 遍历以node 为根节点的树
    private void midOrder(Node node){
        if(node == null)
            return;

        //先遍历该节点的左子树
        midOrder(node.left);
        System.out.println(node.t);
        midOrder(node.right);
    }

    //二分搜索树后序遍历  先左 右 然后 当前节点
    public void lastOrder(){
        lastOrder(this.root);
    }
    //后序遍历 遍历 以node 为根节点的二叉搜索树
    private void lastOrder(Node node){
        if(node == null)
            return;

        //先遍历 左子树
        lastOrder(node.left);
        lastOrder(node.right);
        System.out.println(node.t);
    }

    //二分搜索树的 层序遍历
    public void levelOrder(){
        Queue<Node> queue = new LinkedList<>(); //因为 Queue本质是个接口，我们要选择它的一个实现类

        queue.add(this.root);

        while (!queue.isEmpty()){
            Node temp = queue.remove();
            System.out.println(temp.t); //访问

            if(temp.left != null)
                queue.add(temp.left);
            if(temp.right != null)
                queue.add(temp.right);
        }
    }

    //寻找二分搜索树中的最小值
    public T getMinimum(){
        if(this.size == 0)
            throw new IllegalArgumentException("此时，树中为空！");

        return getMinimum(this.root);
    }
    //返回以 node为根节点中的 最小值 。
    private T getMinimum(Node node){
        if(node.left == null)
            return node.t;
        return getMinimum(node.left);
    }


    //寻找二分搜索树中的最大值
    public T getMaximum(){
        if(this.size == 0)
            throw new IllegalArgumentException("此时，树中为空！");
        return getMaximum(this.root);
    }
    //返回以 node为根节点中的 最大值 。
    private T getMaximum(Node node){
        if(node.right == null)
            return node.t;
        return getMaximum(node.right);
    }






    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        generateBinarySearchTreeString(this.root,0,builder); //builder是传出参数
        return builder.toString();
    }

    //生成以 node 为根节点，深度为depth 的 描述二叉树的 字符串
    private void generateBinarySearchTreeString(Node node,int depth,StringBuilder builder){
        if(node == null){
            builder.append(generateDepthInfo(depth)+"|null 
");
            return;
        }
        builder.append(generateDepthInfo(depth)+node.t+"
"); //不要忘了！！！

        generateBinarySearchTreeString(node.left,depth+1,builder);
        generateBinarySearchTreeString(node.right,depth+1,builder);
    }
    //生成 关于深度的字符串。
    private String generateDepthInfo(int depth){
        StringBuilder res = new StringBuilder();
        for (int i =0;i<depth;i++ ){
            res.append("=");  //一个= 对应一个深度。
        }
        return res.toString();
    }

}

package cn.zcb.demo02;

public class Test{
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        int [] nums = {5,3,6,8,4,2};
        for (int num :nums)
            bst.add(num);

        int ret =  bst.getMinimum();
        int ret2 = bst.getMaximum();
        System.out.println("最小值 "+ret);//最小值
        System.out.println("最大值 "+ret2);//最大值

    }
}
/* 输出
最小值 2
最大值 8
* */

上面代码，我们可以寻找到 树中的最小值和最大值。

下面看如何删除最小值和最大值

删除时，

1,如果该节点是叶子节点，那么直接将其删除就可以了。

上图中直接将15删除就可以了！

2,如果该节点是不是叶子节点，此时要将该节点删除，之后将其右子树 放到自己父节点的左子树（即将自己带有的右子树放到自己原来的位置）。

删除最大值 的时候和最小值 思想一致

下面代码实现：

package cn.zcb.demo02;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }

    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }

    // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(this.root);

    }
    //遍历  以 node 为根节点的二分搜索树
    private void preOrder(Node node){
        if(node == null)
            return;
        else
            System.out.println(node.t); //t一定是可以比较的。上面接口已经限制了。

        preOrder(node.left); //先递归完 左子树之后，再递归右子树。
        preOrder(node.right);
    }

    // 二分搜索树的前序遍历 （使用非递归 NR 实现，利用 栈 来实现！！！）
    public void preOrderNR(){
        Stack<Node> stk = new Stack<>();
        stk.push(this.root); //将根节点的值压入栈中。

        while (!stk.isEmpty()){
            Node temp = stk.pop();
            System.out.println(temp.t); //访问

            if(temp.right != null)
                stk.push(temp.right);
            if(temp.left != null)
                stk.push(temp.left);
        }
    }


    //二分搜索树的中序遍历  先左 中 然后再右
    public void midOrder(){
        midOrder(this.root);
    }
    //中序遍历 遍历以node 为根节点的树
    private void midOrder(Node node){
        if(node == null)
            return;

        //先遍历该节点的左子树
        midOrder(node.left);
        System.out.println(node.t);
        midOrder(node.right);
    }

    //二分搜索树后序遍历  先左 右 然后 当前节点
    public void lastOrder(){
        lastOrder(this.root);
    }
    //后序遍历 遍历 以node 为根节点的二叉搜索树
    private void lastOrder(Node node){
        if(node == null)
            return;

        //先遍历 左子树
        lastOrder(node.left);
        lastOrder(node.right);
        System.out.println(node.t);
    }

    //二分搜索树的 层序遍历
    public void levelOrder(){
        Queue<Node> queue = new LinkedList<>(); //因为 Queue本质是个接口，我们要选择它的一个实现类

        queue.add(this.root);

        while (!queue.isEmpty()){
            Node temp = queue.remove();
            System.out.println(temp.t); //访问

            if(temp.left != null)
                queue.add(temp.left);
            if(temp.right != null)
                queue.add(temp.right);
        }
    }

    //寻找二分搜索树中的最小值
    public T getMinimum(){
        if(this.size == 0)
            throw new IllegalArgumentException("此时，树中为空！");

        return getMinimum(this.root);
    }
    //返回以 node为根节点中的 最小值 。
    private T getMinimum(Node node){
        if(node.left == null)
            return node.t;
        return getMinimum(node.left);
    }


    //寻找二分搜索树中的最大值
    public T getMaximum(){
        if(this.size == 0)
            throw new IllegalArgumentException("此时，树中为空！");
        return getMaximum(this.root);
    }
    //返回以 node为根节点中的 最大值 。
    private T getMaximum(Node node){
        if(node.right == null)
            return node.t;
        return getMaximum(node.right);
    }

    //从二分搜索树中 删除最小值所在的节点。返回最小值
    public T removeMin(){
        T ret = getMinimum();  //获取最小值

        //删除最小值所在的节点。
        this.root = removeMin(this.root);
        return ret;
    }
    //删除掉 以 node为根节点的树中的最小节点，
    //并将删除节点后的  新的二分搜索树的根节点 返回出来
    private Node removeMin(Node node){
        if(node.left == null) {
            Node temp = node.right; //此时node.right 可能为null ，也可能不为空，
            node.right = null;
            this.size --;
            return temp;
        }

        node.left = removeMin(node.left);
        return node;
    }

    //从二分搜索树中 删除最大值所在的节点。返回最大值
    public T removeMax(){
        T ret = getMaximum();

        this.root = removeMax(this.root);
        return ret;
    }

    //删除 以 node 为根节点 的二叉树，
    //返回 删除最小值节点 之后的新的 二叉树的 根节点
    private Node removeMax(Node node){
        if(node.right == null){
            Node temp = node.left; //此时node.left 可能为null ，也可能不为空，
            node.left = null;
            this.size --;
            return temp;
        }
        node.right = removeMax(node.right);
        return node;
    }








    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        generateBinarySearchTreeString(this.root,0,builder); //builder是传出参数
        return builder.toString();
    }

    //生成以 node 为根节点，深度为depth 的 描述二叉树的 字符串
    private void generateBinarySearchTreeString(Node node,int depth,StringBuilder builder){
        if(node == null){
            builder.append(generateDepthInfo(depth)+"|null 
");
            return;
        }
        builder.append(generateDepthInfo(depth)+node.t+"
"); //不要忘了！！！

        generateBinarySearchTreeString(node.left,depth+1,builder);
        generateBinarySearchTreeString(node.right,depth+1,builder);
    }
    //生成 关于深度的字符串。
    private String generateDepthInfo(int depth){
        StringBuilder res = new StringBuilder();
        for (int i =0;i<depth;i++ ){
            res.append("=");  //一个= 对应一个深度。
        }
        return res.toString();
    }

}

package cn.zcb.demo02;

import java.util.ArrayList;
import java.util.Random;

public class Test{
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();

        Random random = new Random();
        int n = 1000; //1000个【0-9999】的随机数 加入到二叉树中！ 最终二叉树中的个数不一定是1000个，因为这里的二叉树中不能有重复的值！
        for (int i =0;i<n;i++){
            bst.add(random.nextInt(10000));
        }

        ArrayList <Integer> arrayList =  new ArrayList<>();
        while (!bst.isEmpty()){ //当二叉树不为空时，就移除它的最小值。并将最小值加入到 我们的arrayList 中！
            arrayList.add(bst.removeMin());
        }
        System.out.println(arrayList); //此时的arrayList 中的顺序应当是 从小到大  ！
        System.out.println("二叉树的节点数量是 "+arrayList.size());

        //代码验证 arrayList是否为 从小到大
        for (int i=0;i<arrayList.size() -1 ;i++){
            if(arrayList.get(i) > arrayList.get(i+1))
                throw new IllegalArgumentException("Error");
        }
        //如果经过这个循环，没有抛出异常，就说明arrayList 是从小到大！ 
        //对于 removeMax() 的测试和removeMin()一致！
    }
}
/* 输出
[26, 45, 46, 57, 60, 67, 83, 87, 88, 89, 97, 103, 130, 135, 140, 142, 149, 158, 185, 226, 250,.....]
二叉树的节点数量是 962
* */

删除二分搜索树的任意值：

对于删除一个节点：
要分下面几个情况：
1，删除只有左孩子的节点
2，删除只有右孩子的节点
上面两种情况，也包含了删除叶子节点的情况。 （它们的代码类似于删除最大值和删除最小值）
最麻烦的是下面这种：
3，删除既有左孩子又有右孩子的节点。 （方法是：1962年，Hibbard 提出的--Hibbard Deletion）

第三种情况：如何删除58呢？

把58删除之后，要把剩下的两个子树融合在一起，
如何解决呢？
需要找一个节点，把58给替代了。寻找方法是找一个58 的后继节点（比58大，而且离58 最近！！！）
这里找的就是59！

如何找到的呢？
其实就是58 的右子树中的最小值的那个节点。即 min(d->right);

找到59 之后，将它从它删除并让它替换掉58！如图：

此时就可以放心的把d给删除了 ：

package cn.zcb.demo02;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinarySearchTree<T extends Comparable<T>> {
    //这里对树中存储的类型做了限制，它必须具有可比较性。
    private class Node{
        public T t;
        public Node left,right;

        //Node 构造函数
        public Node(T t){
            this.t = t;
            this.left = null;
            this.right = null;
        }

    }

    //二分搜索树 的成员变量：1，根节点，2，size
    private Node root;
    private int size;
    //二分搜索树的构造函数
    public BinarySearchTree(){
        //此时一个元素都没有存
        this.root = null ;
        this.size = 0;
    }

    public int getSize(){
        return this.size;
    }
    public boolean isEmpty(){
        return this.size == 0;
    }

    //向二分搜索树 中添加新的元素e
    public void add(T t){
        this.root = add(this.root,t);
    }
    //向 以node 为根节点 的 二分查找树中插入 元素
    //返回 插入新节点后 二分搜索树的根
    private Node add(Node node,T t) {
        if (node == null) { //上次的终止条件 太过于庞杂，其实这样就可以了。
            this.size ++;
            return new Node(t);
        }
        if (t.compareTo(node.t) < 0){
            node.left = add(node.left, t);
        }
        else if(t.compareTo(node.t) >0 ){
            node.right = add(node.right, t);
        }
        return node;
    }


    //看 二分搜索树 中是否存在某个元素 t
    public boolean contains(T t){

        return contains(this.root,t);
    }

    //看 以node 为根的二分搜索树 中是否存在某个元素 t
    private boolean contains(Node node,T t){
        if(node == null){
            return false;
        }
        if(t.compareTo(node.t) == 0)
            return true;
        else if(t.compareTo(node.t) < 0) //此时只可能出现在左子树。
            return contains(node.left,t);
        else                            //此时只可能出现在右子树。
            return contains(node.right,t);
    }

    // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(this.root);

    }
    //遍历  以 node 为根节点的二分搜索树
    private void preOrder(Node node){
        if(node == null)
            return;
        else
            System.out.println(node.t); //t一定是可以比较的。上面接口已经限制了。

        preOrder(node.left); //先递归完 左子树之后，再递归右子树。
        preOrder(node.right);
    }

    // 二分搜索树的前序遍历 （使用非递归 NR 实现，利用 栈 来实现！！！）
    public void preOrderNR(){
        Stack<Node> stk = new Stack<>();
        stk.push(this.root); //将根节点的值压入栈中。

        while (!stk.isEmpty()){
            Node temp = stk.pop();
            System.out.println(temp.t); //访问

            if(temp.right != null)
                stk.push(temp.right);
            if(temp.left != null)
                stk.push(temp.left);
        }
    }


    //二分搜索树的中序遍历  先左 中 然后再右
    public void midOrder(){
        midOrder(this.root);
    }
    //中序遍历 遍历以node 为根节点的树
    private void midOrder(Node node){
        if(node == null)
            return;

        //先遍历该节点的左子树
        midOrder(node.left);
        System.out.println(node.t);
        midOrder(node.right);
    }

    //二分搜索树后序遍历  先左 右 然后 当前节点
    public void lastOrder(){
        lastOrder(this.root);
    }
    //后序遍历 遍历 以node 为根节点的二叉搜索树
    private void lastOrder(Node node){
        if(node == null)
            return;

        //先遍历 左子树
        lastOrder(node.left);
        lastOrder(node.right);
        System.out.println(node.t);
    }

    //二分搜索树的 层序遍历
    public void levelOrder(){
        Queue<Node> queue = new LinkedList<>(); //因为 Queue本质是个接口，我们要选择它的一个实现类

        queue.add(this.root);

        while (!queue.isEmpty()){
            Node temp = queue.remove();
            System.out.println(temp.t); //访问

            if(temp.left != null)
                queue.add(temp.left);
            if(temp.right != null)
                queue.add(temp.right);
        }
    }

    //寻找二分搜索树中的最小值
    public T getMinimum(){
        if(this.size == 0)
            throw new IllegalArgumentException("此时，树中为空！");

        return getMinimum(this.root).t;
    }
    //返回以 node为根节点中的 最小值 。
    private Node getMinimum(Node node){
        if(node.left == null)
            return node;
        return getMinimum(node.left);
    }


    //寻找二分搜索树中的最大值
    public T getMaximum(){
        if(this.size == 0)
            throw new IllegalArgumentException("此时，树中为空！");
        return getMaximum(this.root).t;
    }
    //返回以 node为根节点中的 最大值 。
    private Node getMaximum(Node node){
        if(node.right == null)
            return node;
        return getMaximum(node.right);
    }

    //从二分搜索树中 删除最小值所在的节点。返回最小值
    public T removeMin(){
        T ret = getMinimum();  //获取最小值

        //删除最小值所在的节点。
        this.root = removeMin(this.root);
        return ret;
    }
    //删除掉 以 node为根节点的树中的最小节点，
    //并将删除节点后的  新的二分搜索树的根节点 返回出来
    private Node removeMin(Node node){
        if(node.left == null) {
            Node temp = node.right; //此时node.right 可能为null ，也可能不为空，
            node.right = null;
            this.size --;
            return temp;
        }

        node.left = removeMin(node.left);
        return node;
    }

    //从二分搜索树中 删除最大值所在的节点。返回最大值
    public T removeMax(){
        T ret = getMaximum();

        this.root = removeMax(this.root);
        return ret;
    }

    //删除 以 node 为根节点 的二叉树，
    //返回 删除最小值节点 之后的新的 二叉树的 根节点
    private Node removeMax(Node node){
        if(node.right == null){
            Node temp = node.left; //此时node.left 可能为null ，也可能不为空，
            node.left = null;
            this.size --;
            return temp;
        }
        node.right = removeMax(node.right);
        return node;
    }

    //从二分搜索树上 删除任意元素 t
    public void remove(T t){
        this.root = remove(this.root,t);
    }
    // 删除 以 Node 为根节点的二分搜索树中的任意值
    // 返回删除之后 新的二分搜索树的 根节点
    private Node remove(Node node,T t){
        if(node == null)
            return null; //没找到要删除的t ,此时什么都不干！
        if(t.compareTo(node.t) < 0) {
            node.left = remove(node.left, t);
            return node;
        }
        else if(t.compareTo(node.t) >0) {
            node.right = remove(node.right, t);
            return node;
        }else{
            //此时就找到了要删除的元素！
            if(node.left == null){  //此时，是只有右子树的情况 右子树也可能为null
                Node temp = node.right;
                node.right = null;
                this.size --;
                return temp;
            }
            if(node.right == null){  //此时，是只有左子树的情况  左子树也可能为null
                Node temp = node.left;
                node.left = null;
                this.size --;
                return temp;
            }
            //此时 是该节点既有左子树，又有右子树，而且左右子树都不为null
            Node temp = getMinimum(node.right); // 找到当前节点 的右子树中的 最小节点。
            temp.right = removeMin(node.right);  //删除 右子树的最小节点，并将右子树的根节点 连在temp。right上。
            temp.left = node.left;
            //此时的node 就可以被删除了。
            node.left = node.right = null;     //或者用 node =null;  直接删除
//            this.size --;  它是不需要的，因为我们在 removeMin 中已经进行了 this.size-- ;
            return temp;
        }
    }


    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        generateBinarySearchTreeString(this.root,0,builder); //builder是传出参数
        return builder.toString();
    }

    //生成以 node 为根节点，深度为depth 的 描述二叉树的 字符串
    private void generateBinarySearchTreeString(Node node,int depth,StringBuilder builder){
        if(node == null){
            builder.append(generateDepthInfo(depth)+"|null 
");
            return;
        }
        builder.append(generateDepthInfo(depth)+node.t+"
"); //不要忘了！！！

        generateBinarySearchTreeString(node.left,depth+1,builder);
        generateBinarySearchTreeString(node.right,depth+1,builder);
    }
    //生成 关于深度的字符串。
    private String generateDepthInfo(int depth){
        StringBuilder res = new StringBuilder();
        for (int i =0;i<depth;i++ ){
            res.append("=");  //一个= 对应一个深度。
        }
        return res.toString();
    }

}

package cn.zcb.demo02;


public class Test{
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        int [] arr = {1,23,4,34,43,87,45,554,43,56};
        for (int i = 0;i<arr.length;i++){
            bst.add(arr[i]);
        }
        System.out.println(bst); //打印二叉树！

        //删除 45 的节点
        bst.remove(45);
        System.out.println("======分界线=====");
        System.out.println(bst);

    }
}
/* 输出
1
=|null 
=23
==4
===|null 
===|null 
==34
===|null 
===43
====|null 
====87
=====45
======|null 
======56
=======|null 
=======|null 
=====554
======|null 
======|null 

======分界线=====
1
=|null 
=23
==4
===|null 
===|null 
==34
===|null 
===43
====|null 
====87
=====56
======|null 
======|null 
=====554
======|null 
======|null 
* */

最后，补充：
在找节点替代的时候，其实不一定要找右子树中的最小的。
也可以找左子树中的最大的。如下图：

更多二分搜索树相关话题：

二分搜索树具有顺序性：

而且此时就不需要整个二分搜索树的size 了。如果想看的话，直接this.root.size 即可了！

二分搜索树的时间复杂度分析暂时不说，后面说。
下一章也将会看到二分搜索树的应用---集合和映射，
与此同时，下一章不仅使用二分搜索树实现集合和映射，也会用数组和链表来实现！