树的初步

一.二叉树的入门

1.1 树的基本定义(一对多)

树具有以下特点：
1.每个结点有零个或多个子结点；
2.没有父结点的结点为根结点；
3.每一个非根结点只有一个父结点；
4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树；

1.2 树的相关术语

结点的度：
一个结点含有的子树的个数称为该结点的度；
叶结点：
度为0的结点称为叶结点，也可以叫做终端结点
分支结点：
度不为0的结点称为分支结点，也可以叫做非终端结点
结点的层次：
从根结点开始，根结点的层次为1，根的直接后继层次为2，以此类推
结点的层序编号
将树中的结点，按照从上层到下层，同层从左到右的次序排成一个线性序列，把他们编成连续的自然数。
树的度：
树中所有结点的度的最大值
树的高度(深度)：
树中结点的最大层次
森林：
m（m>=0）个互不相交的树的集合，将一颗非空树的根结点删去，树就变成一个森林；给森林增加一个统一的根结点，森林就变成一棵树

孩子结点：
一个结点的直接后继结点称为该结点的孩子结点
双亲结点(父结点)：
一个结点的直接前驱称为该结点的双亲结点
兄弟结点：
同一双亲结点的孩子结点间互称兄弟结点

1.3 二叉树的基本定义

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

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

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

1.4 二叉树

1.4.1 二叉树的节点类

二叉树其实就是由一个一个的结点及其之间的关系组成的

1.4.2 二叉树的API设计

1.5 二叉查找树

1.5.1 二叉查找树的API

1.5.2 二叉查找树的实现

package com.caopeng.ZTestpackage.tree;

public class BinaryTree<Key extends Comparable<Key>,Value> {
    // 内部结点类
    private class Node{
        // 存储键
        public Key key;
        // 存储值
        public 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;
        }
    }

    // 属性
    // 记录根节点
    private Node root;
    // 记录树中元素个数
    private int N;

    /**
     * 获取树中元素个数
     * @return
     */
    public int size(){
        return this.N;
    }

    /**
     * 向树中插入一个键值对
     * @param key
     * @param value
     */
    public void put(Key key,Value value){
        root = put(root,key,value);
    }

    /**
     * 给指定的树x上,添加一个键值对,并返回添加后的新树
     * @param x
     * @param key
     * @param value
     * @return
     */
    public Node put(Node x,Key key,Value value){
        if (x == null){
            //个数加一
            this.N++;
            return new Node(key,value,null,null);
        }

        int cmp = key.compareTo(x.key);

        // key 大于 x的值
        if (cmp > 0){
            // 继续寻找当前节点的右子节点
            x.right = put(x.right,key,value);
        // key 小于 x的值
        }else if (cmp < 0){
            // 继续寻找当前节点左子节点
            x.left = put(x.left,key,value);
        // key等于x的值
        }else {
            // 直接让x的值替代成新的值
            x.value = value;
        }
        return x;
    }

    /**
     * 根据key,找到key所对应的值
     * @param key
     * @return
     */
    public Value get(Key key){
        return  get(root,key);
    }

    /**
     * 从指定的树x中,找到key所对应的值
     * @param x
     * @param key
     * @return
     */
    public Value get(Node x,Key key){
        // 如果子树为空
        if (x == null){
            return null;
        }
        // 如果子树不为空
        int compare = key.compareTo(x.key);
        if (compare > 0){
            // 如果key大于x节点的键,则继续寻找x节点的右子树
            return get(x.right, key);// 接下来是查找x的右子书,一直调用get方法直到return出来
        }else if (compare < 0){
            // 如果key小于x节点的键,则继续寻找x节点的左子树
            return get(x.left,key);
        }else{
            // 如果key等于x节点的键,就找到了键为key的节点,只需要返回x节点的值即可
            return x.value;
        }
    }

    /**
     * 根据key,删除树中对应的键值对
     * @param key
     */
    public void delete(Key key){
        root = delete(root,key);
    }
    /**
     * 删除指定树x上的键为key的键值对,并返回删除后的新树
     * @param x
     * @param key
     */
    public Node delete(Node x,Key key){
        // 如果子树为空
        if (x== null){
            return null;
        }
        // 比较删除节点和当前节点key的大小
        int cmp = key.compareTo(x.key);
        if (cmp > 0){
            // 删除节点比当前节点大,继续寻找当前节点的右子节点
            x.right = delete(x.right,key);
        }else if (cmp < 0){
            // 删除节点比当前节点小,继续寻找当前节点的左子节点
            x.left = delete(x.left,key);
        }else {
            // 当前节点的key等于删除节点的key,表示这就是要删除的节点
            // 如果删除节点的左子树为空,直接返回右子树
            if (x.left == null){
                return x.right;
            }
            // 如果删除节点的右子树为空,直接返回左子树
            if (x.right == null){
                return x.left;
            }
            // 如果左右子树都在,那么就寻找右子树的最小节点
            Node minNode = x.right;
            if (minNode.left != null){
                minNode = minNode.left;
            }
            // 删除最小节点
            Node node = x.right;
            if (node.left != null){
                if (node.left.left == null){
                    node.left = null;
                }else{
                    node = node.left;
                }
            }
            // 让删除节点的左子树成为最小节点的左子树
            minNode.left = x.left;
            // 让删除节点的右子树成为最小节点的右子树
            minNode.right = x.right;
            // 让删除节点的父节点指向删除节点
            x = minNode;
        }
        // 个数减一
        this.N --;
        return x;
    }
}

1.5.3 二叉查找树其他便捷方法

1.5.3.1 查找最小键

/**
     * 找出树最小的键
     * @return
     */
    public Key min(){
        return min(root).key;
    }

    /**
     * 找出指定树x中,最小键所在节点
     * @param x
     * @return
     */
    private Node min(Node x){
        Node minNode = x;
        while (x.left != null){
            x = x.left;
        }
        return x;
    }

1.5.3.2 查找最大键

/**
     * 找出树中最大的键
     * @return
     */
    public Key max(){
        return max(root).key;
    }

    /**
     * 找出指定树x中,最大键所在的节点
     * @param x
     * @return
     */
    public Node max(Node x){
        Node maxNode = x;
        while(maxNode.right != null){
            maxNode = maxNode.rightl
        }
        return maxNode;
    }

1.6 二叉树的基础遍历

1.6.1 前序遍历

先访问根结点，然后再访问左子树，最后访问右子树

/**
     * 使用前序遍历,获取整个树中所有的键
     * @return
     */
    public Queue<Key> preErgodic(){
        Queue<Key> keys = new Queue<>();
        preErgodic(root,keys);
        return keys;
    }

    /**
     * 使用前序遍历,获取指定树x中所有的键放到keys中
     * @param x
     * @param keys
     */
    private void preErgodic(Node x,Queue<Key> keys){
        if (x == null){
            return;
        }
        // 1. 把当前结点放入keys中
        keys.enqueue(x.key);
        // 2.递归遍历x的左子树
        if (x.left != null){
            preErgodic(x.left,keys);
        }
        // 3.递归遍历x的右子树
        if (x.right != null){
            preErgodic(x.right,keys);
        }
    }

1.6.2 中序遍历

先访问左子树，中间访问根节点，最后访问右子树

/**
     * 使用中序遍历,获取整个树中的所有键
     * @return
     */
    public Queue<Key> midErgodic(){
        Queue<Key> keys = new Queue<>();
        midErgodic(root,keys);
        return keys;
    }

    /**
     * 使用中序遍历,把指定树x中所有键放入到keys队列中
     * @param x
     * @param keys
     */
    private void midErgodic(Node x,Queue<Key> keys){
        if (x == null){
            return;
        }
        // 1.递归遍历x的左子树
        if (x.left != null){
            midErgodic(x.left,keys);
        }
        // 2.将x放入到队列中
        keys.enqueue(x.key);
        // 3.递归遍历x的右子树
        if (x.right != null){
            midErgodic(x.right,keys);
        }
    }

1.6.3 后序遍历

先访问左子树，再访问右子树，最后访问根节点

/**
     * 使用后序遍历,获取整个树中的所有键
     * @return
     */
    public Queue<Key> afterErgodic(){
        Queue<Key> keys = new Queue<>();
        afterErgodic(root,keys);
        return keys;
    }

    /**
     * 使用后序遍历,将指定树x中的所有键放入到keys中
     * @param x
     * @param keys
     */
    private void afterErgodic(Node x,Queue<Key> keys){
        if (x == null){
            return;
        }
        // 1.递归遍历x的左子树
        if (x.left != null){
            afterErgodic(x.left,keys);
        }
        // 2.递归遍历x的右子树
        if (x.right != null){
            afterErgodic(x.right,keys);
        }
        // 3.把x放入到队列中
        keys.enqueue(x.key);
    }

测试遍历

 BinaryTree<String, String> bt = new BinaryTree<>();
        bt.put("E","5");
        bt.put("B","2");
        bt.put("G","7");
        bt.put("A","1");
        bt.put("D","4");
        bt.put("F","6");
        bt.put("H","8");
        bt.put("C","3");
        System.out.println("测试遍历");
        System.out.println("测试前序遍历");
        Queue<String> queue1 = bt.preErgodic();
        for (String key : queue1){
            System.out.println(key + " = " + bt.get(key));
        }
        System.out.println("==================");
        System.out.println("测试中序遍历");
        Queue<String> queue2 = bt.midErgodic();
        for (String key : queue2){
            System.out.println(key + " = " + bt.get(key));
        }
        System.out.println("==================");
        System.out.println("测试后序遍历");
        Queue<String> queue3 = bt.afterErgodic();
        for (String key : queue3){
            System.out.println(key + " = " + bt.get(key));
        }
    }

1.7 二叉树的层序遍历

/**
     * 使用层序遍历,获取整个树中所有的键
     * @return
     */
    public Queue<Key> layerErgodic(){
        // 创建两个队列,分别存放键和键
        Queue<Node> nodes = new Queue<>();
        Queue<Key> keys = new Queue<>();
        // 默认存放根节点
        nodes.enqueue(root);

        while (!nodes.isEmpty()){
            // 从结点队列中弹出一个节点,把key放入keys中
            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;
    }

1.8 二叉树的最大深度问题

/**
     * 计算指定树x的最大深度
     * @param x
     * @return
     */
    private int maxDepth(Node x){
        // 1.如果根节点为空,则最大深度为零
        if (x == null){
            return 0;
        }
        int max = 0;
        int maxL = 0;
        int maxR = 0;
        // 2.计算左子树最大深度
        maxL = maxDepth(x.left);
        // 3.计算右子树最大深度
        maxR = maxDepth(x.right);
        // 当前树的最大深度 = 左子树的最大深度和右子树的最大深度中的较大者 加 1
        max = maxL > maxR ? maxL + 1 : maxR + 1;
        return max;
    }