二分搜索树的完整实现，含BST所有常用操作（Java实现）

前言

二分搜索树（Binary Search Tree），不仅可以高效的查找、插入、删除数据，动态的维护数据，还可以方便的回答很多数据之间关系的问题。本文主要讲述二分搜索树的基础知识，并重点介绍二分搜索树的遍历（深度优先遍历 / 广度优先遍历）以及删除操作。并在文章的最后，给出了二分搜索树的完整代码，包括二分搜索树的结构、构建、查找、遍历（前序 / 中序 / 后续 / 层序）、最大节点、最小节点、删除（删除最小节点 / 最大节点 / 任意节点）等操作。

1. 二分搜索树基础

1.1 二分搜索树的优势

• 高效

  不仅可以高效的查找数据，还可以高效的插入删除数据，动态的维护数据

  	查找元素	插入元素	删除元素
  普通数组	O(n)	O(n)	O(n)
  顺序数组	O(logn)	O(n)	O(n)
  二分搜索树	O(logn)	O(logn)	O(logn)

• 可以方便的回答很多数据之间关系的问题

  • min、max
  • floor、ceil
  • rank（比如看这个数据是当前数据的第几名）、select（比如找到这个数据第1000名的数据是什么）

1.2 二分搜索树的特点

• 二叉树
• 每个节点的键值 > 左孩子；每个节点的键值 < 右孩子。
• 以左右节点为根节点的树仍然是二分搜索树。
• 根节点的值大于他所有左子树中的值，小于它所有右子树的值。
• 二分搜索树不一定是完全二叉树。因为堆是完全二叉树，所以可以用数组表示。而二分搜索树不是完全二叉树，所以不方便用数组表示。所以通常使用Node节点来表示key，value这样的数据对，这些节点之间的关系，使用指针或者引用的方式来表示。

2. 二分搜索树的遍历 - O(n)

2.1 深度优先遍历 - 前中后序遍历

• 前序遍历
  • 先访问当前节点，再依次递归访问左右子树。
• 中序遍历
  • 先递归访问左子树，再访问自身，再递归访问右子树。
  • 应用：如果要想从小到大排序的话，只要进行一次中序遍历即可。
• 后序遍历
  • 先递归访问左右子树，再访问自身节点。
  • 应用：释放二叉树的时候，先释放完左右子树，再释放自身。

下面是简单实现，详细代码见文章最后一个章节的“完整代码”。

public class BST<Key extends Comparable<Key>, Value> {
    
    

    private class Node {
    
    
        private Key key;
        private Value value;
        private Node left, right;

        public Node(Key key, Value value) {
    
    
            this.key = key;
            this.value = value;
            left = right = null;
        }
    }

    /**
     * 根节点
     */
    private Node root;

    /**
     * 树中的节点个数
     */
    private int count;

    /**
     * 构造函数, 默认构造一棵空二分搜索树
     */
    public BST() {
    
    
        root = null;
        count = 0;
    }
	
	/**
     * 二分搜索树的前序遍历
     */
    public void preOrder() {
    
    
        preOrder(root);
    }

    /**
     * 二分搜索树的中序遍历
     */
    public void inOrder() {
    
    
        inOrder(root);
    }

    /**
     * 二分搜索树的后序遍历
     */
    public void postOrder() {
    
    
        postOrder(root);
    }

	/**
     * 对以node为根的二叉搜索树进行前序遍历, 递归算法
     *
     * @param node
     */
    private void preOrder(Node node) {
    
    

        if (node != null) {
    
    
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    /**
     * 对以node为根的二叉搜索树进行中序遍历, 递归算法
     *
     * @param node
     */
    private void inOrder(Node node) {
    
    

        if (node != null) {
    
    
            inOrder(node.left);
            System.out.println(node.key);
            inOrder(node.right);
        }
    }

    /**
     * 对以node为根的二叉搜索树进行后序遍历, 递归算法
     *
     * @param node
     */
    private void postOrder(Node node) {
    
    

        if (node != null) {
    
    
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.key);
        }
    }
 }

思考：归并排序，快速排序，其本质其实是二叉树深度优先遍历的过程。

2.2 广度优先遍历 - 层序遍历

队列 - 先进先出

1、58进队列

2、58出队列，58的左右孩子46、60进队列

3、46出队列，46的左右孩子31、56进队列

4、60出队列，60的左右孩子59、61进队列

5、31出队列，31的左右孩子进队列（无）

6、56出队列，56的左右孩子进队列（无）

7、59出队列，59的左右孩子进队列（无）

8、61出队列，61的左右孩子进队列（无）

下面是简单实现，详细代码见文章最后一个章节的“完整代码”。

public class BST<Key extends Comparable<Key>, Value> {
    
    

    private class Node {
    
    
        private Key key;
        private Value value;
        private Node left, right;

        public Node(Key key, Value value) {
    
    
            this.key = key;
            this.value = value;
            left = right = null;
        }
    }

    /**
     * 根节点
     */
    private Node root;

    /**
     * 树中的节点个数
     */
    private int count;

    /**
     * 构造函数, 默认构造一棵空二分搜索树
     */
    public BST() {
    
    
        root = null;
        count = 0;
    }
	
	/**
     * 二分搜索树的层序遍历
     */
    public void levelOrder() {
    
    

        // 我们使用LinkedList来作为我们的队列
        Queue<Node> q = new LinkedList<Node>();
        q.add(root);
        while (!q.isEmpty()) {
    
    

            Node node = q.remove();

            System.out.println(node.key);

            if (node.left != null) {
    
    
                q.add(node.left);
            }
            if (node.right != null) {
    
    
                q.add(node.right);
            }
        }
    }
 }

3. 二分搜索树的删除

代码见文章最后一个章节的“完整代码”。

3.1 删除最小值和最大值

• 最小值
  • 一直沿着左子树去找，直到找到没有左孩子的节点，就是值最小的节点。
  • 如果最小节点没有左右孩子，直接删除就好。
  • 如果最小节点有右孩子，那么就需要将其右孩子代替删除节点，使其右孩子成为已经删除的节点的父亲节点的左孩子即可，这样整个二分搜索树的性质依然是不变的。
• 最大值
  • 一直沿着右子树去找，直到找到没有右孩子的节点，就是值最大的节点。
  • 如果最大节点没有左右孩子，直接删除就好。
  • 如果最大节点有左孩子，那么就需要将其左孩子代替删除节点，使其左孩子成为已经删除的节点的父亲节点的右孩子即可，这样整个二分搜索树的性质依然是不变的。

3.2 二分搜索树删除任意节点 Hubbard Deletion

• 如果删除的节点只有一个孩子

  比如只有左孩子或者只有右孩子，那么这种情况是简单的，按照删除最大键值节点和最小键值节点的方式删除就好，即将它的左孩子或者右孩子代替删除的节点，使其左孩子或者右孩子成为已删除节点的父亲节点的孩子即可。

• 如果删除的节点左右孩子都有

  那么同样是需要找一个节点来代替删除的节点，但是这个代替节点既不是删除节点的左孩子，又不是删除节点的右孩子，那么它是谁呢？答案就是删除节点的右子树中的最小值。为什么呢？因为被删除节点的替代节点，要满足大于它的左子树中的所有节点，所以要在被删除节点的右子树中去查找；又因为这个替代节点，要小于它右子树中的所有节点，所以要在被删除节点的右子树中找到最小键值的节点。

  总结一下删除的节点左右孩子都有的情况：

  假设删除的节点为d，替代节点为s

  第一步：找到删除节点的替代节点，即 s = min(d->right)

  第二步：将s代替d

  i）删除d的右子树中的最小节点，同时将s的右边指向删除节点的原来的右子树，即 s->right = delMin(d->right)

  ii）s的左边指向d的左子树，即s->left = d->left

  iii）删除d

  思考：

  这里是找到被删除节点的右子树中的最大值作为替代节点，那么是不是也有其他的替代节点呢？答案是肯定的。那就是被删除节点左子树中的最大值，也可以选为替代节点。

• 时间复杂度

  二分搜索树删除任意节点的时间复杂度为O(logn)，不管是删除最大最小节点还是删除任意节点，主要的时间都是在找到我们想删除的这个节点上，一旦找到了，删除的过程虽然很复杂，但都是指针间的交换，都是常数级的，和整棵树有多少节点是没有关系的。所以二分搜索树的删除效率也是很高的。

4. 二分搜索树的顺序性

• 最大值、最小值
• 前驱、后继
  • 和floor和ceil的区别：查30的前驱或者后继，如果没有30的话，那就没有前驱和后继，但却可能有floor和ceil。
• floor、ceil
  • 查30的floor或者ceil，如果没有30的话，也有floor和ceil，floor就是最接近30且小于30的值，ceil就是最接近30且大于30的值，30的floor和ceil就是它本身。
  • 如果BST的最小值是10，那么8就没有floor；如果BST的最大值是20，那么25就没有ceil。
• rank、select
  • rank
    • 解决例如：58是排名第几的元素
    • 需要对每个节点再添加一个属性，即以这个节点为根的二分搜索树一共有几个节点，如叶子节点都是1
  • select
    • 解决例如：排名第10的元素是谁
• 支持重复元素的二分搜索树
  • 思路1：左孩子定义为<=根节点，右孩子定义为>根节点（弊端：当有大量重复元素的时候，空间不够节省）
  • 思路2：对每个节点再添加一个属性count，比如在整个BST中有5个55的元素，那么55这个节点的count属性就是5

5. 二分搜索树的局限性

• 二分搜索树可能退化为链表
  • 二分搜索树的查找是和高度相关的，所以退化为链表的二分搜索树它相应的算法的时间复杂度都退化为了O(n)
  • 解决
    • 打乱顺序。这种做法需要一上来就拿到所有数据，但有些情况是数据慢慢流入系统的。
    • 红黑树（平衡二叉树的一种实现）。即改造二叉树，使二叉树无法退化为链表。
      • 平衡二叉树，有两棵子树，并且左右两棵子树的高度差不会超过1。
      • 平衡二叉树的其他实现：2-3 tree、AVL tree、Splay tree伸展树
      • 平衡二叉树和堆的结合：Treap
      • trie - 和要查找的单词的长度有关，而和在字典中有多少个单词无关。

6. 完整代码

6.1 二分搜索树 - BST类

package basic.bst;

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

/**
 * @Description：二分搜索树 由于Key需要能够进行比较，所以需要extends Comparable<Key>
 * @Author: during
 * @Date: 2020/4/18
 */

public class BST<Key extends Comparable<Key>, Value> {
    
    

    /**
     * 树中的节点为私有的类, 外界不需要了解二分搜索树节点的具体实现
     */
    private class Node {
    
    
        private Key key;
        private Value value;
        private Node left, right;

        public Node(Key key, Value value) {
    
    
            this.key = key;
            this.value = value;
            left = right = null;
        }

        public Node(Node node) {
    
    
            this.key = node.key;
            this.value = node.value;
            this.left = node.left;
            this.right = node.right;
        }
    }

    /**
     * 根节点
     */
    private Node root;

    /**
     * 树中的节点个数
     */
    private int count;

    /**
     * 构造函数, 默认构造一棵空二分搜索树
     */
    public BST() {
    
    
        root = null;
        count = 0;
    }

    /**
     * 返回二分搜索树的节点个数
     *
     * @return
     */
    public int size() {
    
    
        return count;
    }

    /**
     * 返回二分搜索树是否为空
     *
     * @return
     */
    public boolean isEmpty() {
    
    
        return count == 0;
    }

    /**
     * 向二分搜索树中插入一个新的(key, value)数据对
     *
     * @param key
     * @param value
     */
    public void insert(Key key, Value value) {
    
    
        root = insert(root, key, value);
    }

    /**
     * 查看二分搜索树中是否存在键key
     *
     * @param key
     * @return
     */
    public boolean contain(Key key) {
    
    
        return contain(root, key);
    }

    /**
     * 在二分搜索树中搜索键key所对应的值。如果这个值不存在, 则返回null
     *
     * @param key
     * @return
     */
    public Value search(Key key) {
    
    
        return search(root, key);
    }

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

    /**
     * 二分搜索树的中序遍历
     */
    public void inOrder() {
    
    
        inOrder(root);
    }

    /**
     * 二分搜索树的后序遍历
     */
    public void postOrder() {
    
    
        postOrder(root);
    }

    /**
     * 二分搜索树的层序遍历
     */
    public void levelOrder() {
    
    

        // 我们使用LinkedList来作为我们的队列
        Queue<Node> q = new LinkedList<Node>();
        q.add(root);
        while (!q.isEmpty()) {
    
    

            Node node = q.remove();

            System.out.println(node.key);

            if (node.left != null) {
    
    
                q.add(node.left);
            }
            if (node.right != null) {
    
    
                q.add(node.right);
            }
        }
    }

    /**
     * 寻找二分搜索树的最小的键值
     *
     * @return
     */
    public Key minimum() {
    
    
        assert count != 0;
        Node minNode = minimum(root);
        return minNode.key;
    }

    /**
     * 寻找二分搜索树的最大的键值
     *
     * @return
     */
    public Key maximum() {
    
    
        assert count != 0;
        Node maxNode = maximum(root);
        return maxNode.key;
    }

    /**
     * 从二分搜索树中删除最小值所在节点
     */
    public void removeMin() {
    
    
        if (root != null) {
    
    
            // 根节点不为空的情况下再去删除
            root = removeMin(root);
        }
    }

    /**
     * 从二分搜索树中删除最大值所在节点
     */
    public void removeMax() {
    
    
        if (root != null) {
    
    
            // 根节点不为空的情况下再去删除
            root = removeMax(root);
        }
    }

    /**
     * 从二分搜索树中删除键值为key的节点
     *
     * @param key
     */
    public void remove(Key key) {
    
    
        root = remove(root, key);
    }


    /**
     * ********************
     * 二分搜索树的辅助函数
     * ********************
     */

    /**
     * 向以node为根的二分搜索树中, 插入节点(key, value), 使用递归算法，返回插入新节点后的二分搜索树的根
     *
     * @param node
     * @param key
     * @param value
     * @return
     */
    private Node insert(Node node, Key key, Value value) {
    
    

        if (node == null) {
    
    
            count++;
            return new Node(key, value);
        }

        if (key.compareTo(node.key) == 0) {
    
    
            node.value = value;
        } else if (key.compareTo(node.key) < 0) {
    
    
            // key < node->key
            node.left = insert(node.left, key, value);
        } else {
    
    
            // key > node->key
            node.right = insert(node.right, key, value);
        }

        return node;
    }

    /**
     * 查看以node为根的二分搜索树中是否包含键值为key的节点, 使用递归算法
     *
     * @param node
     * @param key
     * @return
     */
    private boolean contain(Node node, Key key) {
    
    

        if (node == null) {
    
    
            return false;
        }

        if (key.compareTo(node.key) == 0) {
    
    
            return true;
        } else if (key.compareTo(node.key) < 0) {
    
    
            // key < node->key，在node的左子树中进行查找
            return contain(node.left, key);
        } else {
    
    
            // key > node->key，在node的右子树中进行查找
            return contain(node.right, key);
        }
    }

    /**
     * 在以node为根的二分搜索树中查找key所对应的value, 递归算法。若value不存在, 则返回NULL
     *
     * @param node
     * @param key
     * @return
     */
    private Value search(Node node, Key key) {
    
    

        if (node == null) {
    
    
            return null;
        }

        if (key.compareTo(node.key) == 0) {
    
    
            return node.value;
        } else if (key.compareTo(node.key) < 0) {
    
    
            // key < node->key，在node的左子树中进行查找
            return search(node.left, key);
        } else {
    
    
            // key > node->key，在node的右子树中进行查找
            return search(node.right, key);
        }
    }

    /**
     * 对以node为根的二叉搜索树进行前序遍历, 递归算法
     *
     * @param node
     */
    private void preOrder(Node node) {
    
    

        if (node != null) {
    
    
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    /**
     * 对以node为根的二叉搜索树进行中序遍历, 递归算法
     *
     * @param node
     */
    private void inOrder(Node node) {
    
    

        if (node != null) {
    
    
            inOrder(node.left);
            System.out.println(node.key);
            inOrder(node.right);
        }
    }

    /**
     * 对以node为根的二叉搜索树进行后序遍历, 递归算法
     *
     * @param node
     */
    private void postOrder(Node node) {
    
    

        if (node != null) {
    
    
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.key);
        }
    }

    /**
     * 返回以node为根的二分搜索树的最小键值所在的节点
     *
     * @param node
     * @return
     */
    private Node minimum(Node node) {
    
    
        if (node.left == null) {
    
    
            // 如果没有左孩子，那么它就是最小键值所在节点
            return node;
        }

        // 否则再去它的左子树中查找
        return minimum(node.left);
    }

    /**
     * 返回以node为根的二分搜索树的最大键值所在的节点
     *
     * @param node
     * @return
     */
    private Node maximum(Node node) {
    
    
        if (node.right == null) {
    
    
            // 如果没有右孩子，那么它就是最大键值所在节点
            return node;
        }

        // 否则再去它的右子树中查找
        return maximum(node.right);
    }

    /**
     * 删除掉以node为根的二分搜索树中的最小节点，返回删除节点后新的二分搜索树的根
     *
     * @param node
     * @return
     */
    private Node removeMin(Node node) {
    
    

        if (node.left == null) {
    
    
            // 如果当前节点为最小键值的节点
            Node rightNode = node.right;
            node.right = null;
            count--;
            return rightNode;
        }

        // 如果当前node不是最小键值的节点，那么再在它左子树中进行查找删除
        node.left = removeMin(node.left);
        return node;
    }

    /**
     * 删除掉以node为根的二分搜索树中的最大节点，返回删除节点后新的二分搜索树的根
     *
     * @param node
     * @return
     */
    private Node removeMax(Node node) {
    
    

        if (node.right == null) {
    
    
            // 如果当前节点为最大键值的节点
            Node leftNode = node.left;
            node.left = null;
            count--;
            return leftNode;
        }

        // 如果当前node不是最大键值的节点，那么再在它右子树中进行查找删除
        node.right = removeMax(node.right);
        return node;
    }

    /**
     * 删除掉以node为根的二分搜索树中键值为key的节点, 递归算法，返回删除节点后新的二分搜索树的根
     *
     * @param node
     * @param key
     * @return
     */
    Node remove(Node node, Key key) {
    
    

        if (node == null) {
    
    
            return null;
        }

        if (key.compareTo(node.key) < 0) {
    
    
            // 要删除的节点的键值 < node节点的键值，在node的左子树中查找删除
            node.left = remove(node.left, key);
            return node;
        } else if (key.compareTo(node.key) > 0) {
    
    
            // 要删除的节点的键值 > node节点的键值，在node的右子树中查找删除
            node.right = remove(node.right, key);
            return node;
        } else {
    
    
            // 要删除的节点的键值 = node节点的键值

            // 待删除节点左子树为空的情况
            if (node.left == null) {
    
    
                Node rightNode = node.right;
                node.right = null;
                count--;
                return rightNode;
            }

            // 待删除节点右子树为空的情况
            if (node.right == null) {
    
    
                Node leftNode = node.left;
                node.left = null;
                count--;
                return leftNode;
            }

            // 待删除节点左右子树均不为空的情况

            // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点，用这个节点顶替待删除节点的位置
            Node successor = new Node(minimum(node.right));
            count++;

            successor.right = removeMin(node.right);
            successor.left = node.left;

            node.left = node.right = null;
            count--;

            return successor;
        }
    }
}

6.2 顺序查找表 - SST类

package basic.bst;

/**
 * @Description：顺序查找表
 * @Author: during
 * @Date: 2020/4/18
 */
public class SST<Key extends Comparable<Key>, Value> {
    
    

    /**
     * 顺序查找表中的节点为私有的类, 外界不需要了解顺序查找法节点的具体实现
     * 顺序查找表, 内部本质是一个链表
     */
    private class Node {
    
    
        private Key key;
        private Value value;
        private Node next;

        public Node(Key key, Value value) {
    
    
            this.key = key;
            this.value = value;
            next = null;
        }
    }

    /**
     * 表头
     */
    private Node head;

    /**
     * 顺序查找表中的节点个数
     */
    private int count;

    /**
     * 构造函数
     */
    public SST() {
    
    
        head = null;
        count = 0;
    }

    /**
     * 返回顺序查找表中的节点个数
     *
     * @return
     */
    public int size() {
    
    
        return count;
    }

    /**
     * 返回顺序查找表是否为空
     *
     * @return
     */
    public boolean isEmpty() {
    
    
        return count == 0;
    }

    /**
     * 向顺序查找表中插入一个新的(key, value)数据对
     *
     * @param key
     * @param value
     */
    public void insert(Key key, Value value) {
    
    

        // 查找一下整个顺序表，看是否存在同样大小的key
        Node node = head;

        while (node != null) {
    
    
            // 若在顺序表中找到了同样大小key的节点，则当前节点不需要插入，将该key所对应的值更新为value后返回
            if (key.compareTo(node.key) == 0) {
    
    
                node.value = value;
                return;
            }
            node = node.next;
        }

        // 若顺序表中没有同样大小的key，则创建新节点，将新节点直接插在表头
        Node newNode = new Node(key, value);
        newNode.next = head;
        head = newNode;
        count++;
    }

    /**
     * 查看顺序查找表中是否包含键值为key的节点
     *
     * @param key
     * @return
     */
    public boolean contain(Key key) {
    
    

        Node node = head;
        while (node != null) {
    
    
            if (key.compareTo(node.key) == 0) {
    
    
                return true;
            }
            node = node.next;
        }
        return false;
    }

    /**
     * 在顺序查找表中查找key所对应的value, 若value不存在, 则返回NULL
     *
     * @param key
     * @return
     */
    public Value search(Key key) {
    
    

        Node node = head;
        while (node != null) {
    
    
            if (key.compareTo(node.key) == 0) {
    
    
                return node.value;
            }
            node = node.next;
        }
        return null;
    }

    /**
     * 在顺序查找表中删除(key,value)所对应的节点
     *
     * @param key
     */
    public void remove(Key key) {
    
    

        if (head == null) {
    
    
            return;
        }

        // 如果待删除的节点就是头结点, 则需要特殊处理
        // 思考: 对于链表, 可以使用什么技术不去特殊处理头结点的特殊情况?
        if (key.compareTo(head.key) == 0) {
    
    
            Node delNode = head;
            head = head.next;
            delNode.next = null;
            count--;
            return;
        }

        Node node = head;
        while (node.next != null && node.next.key.compareTo(key) != 0) {
    
    
            node = node.next;
        }

        if (node.next != null) {
    
    
            Node delNode = node.next;
            node.next = delNode.next;
            delNode.next = null;
            count--;
            return;
        }
    }
}

6.3 测试类

package basic.bst;

/**
 * @Description：测试
 * @Author: during
 * @Date: 2020/4/18
 */
public class Main {
    
    
    private Main() {
    
    
    }

    public static void main(String[] args) {
    
    

        int n = 10;
        Integer[] arr = new Integer[n];
        for (int i = 0; i < n; i++) {
    
    
            arr[i] = new Integer(i);
        }

        BSTTest(n, arr);
    }

    /**
     * 测试二分搜索树
     */
    private static void BSTTest(int n, Comparable[] arr) {
    
    
        /**
         * 打乱数组顺序
         * 由于我们实现的二分搜索树不是平衡二叉树，所以如果按照顺序插入一组数据，我们的二分搜索树将会退化成为一个链表，所以这里要打乱顺序
         */
        for (int i = 0; i < n; i++) {
    
    
            int pos = (int) (Math.random() * (i + 1));
            Integer t = (Integer) arr[pos];
            arr[pos] = arr[i];
            arr[i] = t;
        }

        for (Comparable i : arr) {
    
    
            System.out.print(i + "-");
        }
        System.out.println();

        // 我们测试用的的二分搜索树的键类型为Integer，值类型为String
        // 键值的对应关系为每个整型对应代表这个整型的字符串
        BST<Integer, String> bst = new BST<Integer, String>();
        for (int i = 0; i < n; i++) {
    
    
            bst.insert((Integer) arr[i], Integer.toString((Integer) arr[i]));
        }

        for (int i = 0; i < n; i++) {
    
    
            String res = bst.search(new Integer(i));
            System.out.println("=======" + "i:" + i + ",res:" + res + "=======");
        }

        System.out.println("====前序遍历====");
        bst.preOrder();
        System.out.println("====中序遍历====");
        bst.inOrder();
        System.out.println("====后序遍历====");
        bst.postOrder();
        System.out.println("====层序遍历====");
        bst.levelOrder();

        bst.remove(3);
        System.out.println("删除后节点数为：" + bst.size());

        System.out.println("最大值为：" + bst.maximum());
        bst.removeMax();
        System.out.println("删除最大值后的最大值为：" + bst.maximum());

        System.out.println("最小值为：" + bst.minimum());
        bst.removeMin();
        System.out.println("删除最小值后的最小值为：" + bst.minimum());
    }
}