二叉查找树

树的基本定义

树是我们计算机中非常重要的一种数据结构，同时使用树这种数据结构，可以描述现实生活中的很多事物，例如家 谱、单位的组织架构、等等。

树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

树具有以下特点：

• 每个结点有零个或多个子结点；
• 没有父结点的结点为根结点；
• 每一个非根结点只有一个父结点；
• 每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树；

树的相关术语

结点的度： 一个结点含有的子树的个数称为该结点的度；

叶结点： 度为0的结点称为叶结点，也可以叫做终端结点

分支结点： 度不为0的结点称为分支结点，也可以叫做非终端结点

结点的层次： 从根结点开始，根结点的层次为1，根的直接后继层次为2，以此类推

结点的层序编号：将树中的结点，按照从上层到下层，同层从左到右的次序排成一个线性序列，把他们编成连续的自然数。

树的度： 树中所有结点的度的最大值

树的高度(深度)： 树中结点的最大层次

森林： m（m>=0）个互不相交的树的集合，将一颗非空树的根结点删去，树就变成一个森林；给森林增加一个统一的根 结点，森林就变成一棵树

孩子结点： 一个结点的直接后继结点称为该结点的孩子结点

双亲结点(父结点)： 一个结点的直接前驱称为该结点的双亲结点

兄弟结点： 同一双亲结点的孩子结点间互称兄弟结点

二叉树

二叉树就是度不超过2的树(每个结点最多有两个子结点)

满二叉树： 一个二叉树，如果每一个层的结点树都达到最大值，则这个二叉树就是满二叉树。

完全二叉树： 叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树

二叉查找树实现

根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们 设计一个结点类来描述结点这个事物。

节点类如下：

    private class Node {
        //存储键
        public Key key;
        //存储值
        private Value value;
        //记录左子结点
        public Node left;
        //记录右子结点
        public Node right;

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

树的设计：

public class BinaryTree<Key extends Comparable<Key>, Value> {
    //根节点
    private Node root;
    
    private int N;

    public int size(){
        return N;
    }

    private class Node { //.....}
}

插入方法put

插入方法的实现思想：

• 如果当前树中没有任何一个结点，则直接把新结点当做根结点使用

• 如果当前树不为空，则从根结点开始：

  • 如果新结点的key小于当前结点的key，则继续找当前结点的左子结点；

  • 新结点的key大于当前结点的key，则继续找当前结点的右子结点；

  • 如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值即可。

代码实现如下：

    public void put(Key key, Value value) {
        root = put(root, key, value);
    }

    /**
     * 向指定的树x中添加key-value,并返回添加元素后新的树
     * @author wen.jie
     * @date 2021/8/23 10:56
     */
    private Node put(Node x, Key key, Value value) {
        //x子树为空
        if (x == null) {
            N++;
            return new Node(key, value, null , null);
        }

        //x子树不为空
        int cmp = key.compareTo(x.key);

        if (cmp > 0) {
            x.right = put(x.right, key, value);
        }else if(cmp < 0){
            x.left = put(x.left, key, value);
        }else {
            x.value = value;
        }
        return x;
    }

查询方法get

查询方法思路与插入方法类似，下面给出实现：

    /**
     * @author wen.jie
     * @date 2021/8/23 11:02
     * 查找树中指定key对应的value
     */
    public Value get(Key key){
        return get(root, key);
    }

    private Value get(Node x, Key key) {
        //x子树为空
        if (x == null) return null;
        //x子树不为空
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            return get(x.right, key);
        }else if(cmp < 0){
            return get(x.left, key);
        }else {
            return x.value;
        }
    }

删除方法delete

删除方法思路：

1.找到被删除结点；

2.找到被删除结点右子树中的最小结点minNode

3.删除右子树中的最小结点

4.让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子 树

5.让被删除结点的父节点指向最小结点minNode

代码实现：

    /**
     * @author wen.jie
     * @date 2021/8/23 11:28
     * 删除树中key对应的value
     */
    public void delete(Key key){
        root = delete(root, key);
    }

    /**
     * @author wen.jie
     * @date 2021/8/23 11:28
     * 删除指定树x中的key对应的value,并返回删除后的新树
     */
    public Node delete(Node x, Key key){
        if (x == null) return null;

        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            //找x节点的右子树
            x.right = delete(x.right, key);
        }else if(cmp < 0){
            //找x节点的左子树
            x.left = delete(x.left, key);
        }else {
            N--;
            if(x.right == null) return x.left;
            if(x.left == null) return x.right;

            //得找到右子树中最小的节点
            Node minNode = min(x.right);

            //删除右子树最小的节点,返回新的右子树
            Node n = deleteMin(x.right);

            //让x节点的左子树成为minNode的左子树
            minNode.left = x.left;
            //让新的右子树成为minNode的右子树
            minNode.right = n;
            return minNode;
        }

        return x;
    }

    /**
     * @author wen.jie
     * @date 2021/8/23 16:47
     * 删除指定树中最小的节点,并返回新的树
     */
    private Node deleteMin(Node x){
        if(x.left == null) return x.right;
        x.left = deleteMin(x.left);
        return x;
    }

    /**
     * @author wen.jie
     * @date 2021/8/23 16:43
     * 返回指定树中最小的节点
     */
    private Node min(Node x){
        if(x.left == null) return x;
        return min(x.left);
    }

二叉树的基础遍历

很多情况下，我们可能需要像遍历数组数组一样，遍历树，从而拿出树中存储的每一个元素，由于树状结构和线性结构不一样，它没有办法从头开始依次向后遍历，所以存在如何遍历，也就是按照什么样的搜索路径进行遍历的问题。

我们把树简单的画作上图中的样子，由一个根节点、一个左子树、一个右子树组成，那么按照根节点什么时候被访问，我们可以把二叉树的遍历分为以下三种方式：

• 前序遍历； 先访问根结点，然后再访问左子树，最后访问右子树

• 中序遍历； 先访问左子树，中间访问根节点，最后访问右子树

• 后序遍历； 先访问左子树，再访问右子树，最后访问根节点

如果我们分别对下面的树使用三种遍历方式进行遍历，得到的结果如下：

代码实现：Queue队列的代码见：https://www.cnblogs.com/wwjj4811/p/15174628.html

    /**
     * @author wen.jie
     * @date 2021/8/23 17:26
     * 前序遍历获取整个树中所有的键
     */
    public Queue<Key> preErgodic() {
        Queue<Key> keys = new Queue<>();
        preErgodic(root, keys);
        return keys;
    }

    private void preErgodic(Node x, Queue<Key> keys){
        if(x == null) return;
        keys.enqueue(x.key);
        if(x.left != null) preErgodic(x.left, keys);
        if(x.right != null) preErgodic(x.right, keys);
    }

    /**
     * @author wen.jie
     * @date 2021/8/23 17:26
     * 中序遍历获取整个树中所有的键
     */
    public Queue<Key> midErgodic() {
        Queue<Key> keys = new Queue<>();
        midErgodic(root, keys);
        return keys;
    }

    private void midErgodic(Node x, Queue<Key> keys){
        if(x == null) return;
        if(x.left != null) midErgodic(x.left, keys);
        keys.enqueue(x.key);
        if(x.right != null) midErgodic(x.right, keys);
    }

    /**
     * @author wen.jie
     * @date 2021/8/23 17:26
     * 后序遍历获取整个树中所有的键
     */
    public Queue<Key> afterErgodic() {
        Queue<Key> keys = new Queue<>();
        afterErgodic(root, keys);
        return keys;
    }

    private void afterErgodic(Node x, Queue<Key> keys){
        if(x == null) return;
        if(x.left != null) afterErgodic(x.left, keys);
        if(x.right != null) afterErgodic(x.right, keys);
        keys.enqueue(x.key);
    }

二叉树的层序遍历

所谓的层序遍历，就是从根节点（第一层）开始，依次向下，获取每一层所有结点的值，有二叉树如下：

那么层序遍历的结果是：EBGADFHC

实现思路：

• 创建队列，存储每一层的结点；

• 使用循环从队列中弹出一个结点：

  • 获取当前结点的key；
  • 如果当前结点的左子结点不为空，则把左子结点放入到队列中
  • 如果当前结点的右子结点不为空，则把右子结点放入到队列中

代码实现：

    public Queue<Key> layerErgodic(){
        Queue<Key> keys = new Queue<>();
        Queue<Node> nodes = new Queue<>();
        nodes.enqueue(root);

        while (!nodes.isEmpty()){
            Node node = nodes.dequeue();
            keys.enqueue(node.key);
            if(node.left != null) nodes.enqueue(node.left);
            if(node.right != null) nodes.enqueue(node.right);
        }
        return keys;
    }

二叉树的最大深度问题

需求：给一个树，求出树的最大深度

实现步骤：

• 如果根结点为空，则最大深度为0；
• 计算左子树的最大深度；
• 计算右子树的最大深度；
• 当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1

代码实现：

    /**
     * @author wen.jie
     * @date 2021/8/23 17:56
     * 求整个树的最大深度
     */
    public Integer maxDepth(){
        return maxDepth(root);
    }

    private Integer maxDepth(Node x){
        if (x == null)  return 0;
        int max = 0;
        int maxL = 0;
        int maxR = 0;
        //2.计算左子树的最大深度；
        if (x.left != null) {
            maxL = maxDepth(x.left);
        }
        //3.计算右子树的最大深度；
        if (x.right != null) {
            maxR = maxDepth(x.right);
        }
        //4.当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1
        max = maxL > maxR ? maxL + 1 : maxR + 1;
        return max;
    }