二叉树

树

什么是树？

　　这就是树：

　　我们现实生活中经常有这样的结构，比如企业层级关系：

　　系统目录结构：

　　还比如家族族谱、书籍目录章节、后台系统页面上的菜单都是树形结构。

　　特别要注意的是，树是不包含回路的，如下图：

节点与树叶

　　一棵树中的所有组成部分叫做节点，由根节点伸展扩散，上下节点连接的关系称作父子关系。

　　如下面这棵树：

　　其中A节点就是根节点（root）。

　　B和F的关系就是父子关系，B是父（parent），F是子（child）。

　　B和C有共同的父节点，所以B和C的关系为兄弟节点（sibling）。

　　一棵树由N个节点组成，由于每个节点都有一条线连上父节点，唯独根节点没有父节点，所以一棵树总共有N-1条边。

　　每个节点可以有任意多个子节点，没有子节点的节点被称作这棵树的树叶（leaf）。

高度,深度与层数

　　还是这个示例：

　　每个节点的高度是自身节点到当前分支的树叶的长度，比如B节点的高度为1，C节点的高度为2。

　　所有树叶的高度都是0，如F节点高度为0。

　　一棵树的高度等于它的根节点的高度。

　　每个节点的深度为根节点到自身的路径长度，比如C节点的深度为1，F的深度为2。

　　根节点的深度固定为0。

　　一棵树的深度等于它最深的那个树叶的深度。

　　层数和深度的计算差不多，不同之处是层数的计数起点是1，也就是说根节点位于整棵树的第1层。

二叉树基础

什么是二叉树？

　　顾名思义，二叉树的意思就是有两个叉的树，也就是每个节点最多只有两个子节点（最多的意思就是小于等于），分别叫做左子节点和右子节点。

　　如下图：

　　当然，也有四叉树、八叉树，之所以二叉树这么火，是因为二叉树的应用非常广泛。

　　二叉树还有两种特殊的表现形式，叫做满二叉树和完全二叉树。

满二叉树

　　如果一颗二叉树所有的叶子节点都有相同的深度，也就是整棵树除了叶子节点之外的所有节点都有两个子节点，那么这棵二叉树叫做满二叉树。

　　如下图：

完全二叉树

　　如果一棵二叉树所有的叶子节点都在最底下两层，最后一层的叶子节点靠左排列，这种二叉树叫做完全二叉树。

　　也就是说，这棵二叉树快成满二叉树了，但是最后一层的叶子节点还没铺满，并且叶子节点是从左到右排列的叫做完全二叉树。

　　如图：

二叉树的存储

　　树这种结构并非物理存储结构，它需要使用数组或链表实现。

链式存储法

　　存储结构如图：

　　每个节点包含三部分：存储的数据、指向左子节点的指针，指向右子节点的指针。

　　节点属性：

class Node{
    Object data;
    Node left;
    Node right;
}

顺序存储法

　　用数组来存储，就应该将每个节点严格对应到数组下标上，鉴于二叉树最多只能两个叉，所以我们按照层级一层一层的排号。

　　如图：

　　正常情况下，为了方便计算子节点，把整棵树串起来，我们将根节点存储在数组下标为1的位置，每一个节点的位置映射成数组下标。

　　假设每个节点的下标为i，那么我们可以得知每个节点的左子节点为 i*2，每个节点的右子节点为 i*2+1。

　　反之，每个节点的父节点的下标为 i / 2。

　　对于一棵满二叉树来说，用数组存储仅仅只空余了一个下标为0的数组空间。

　　那对于一棵稀疏的二叉树来说，用数组存储是比较浪费空间的，比如下面这棵非常牛逼的二叉树：

　　

二叉查找树

什么是二叉查找树？

　　二叉查找树，也叫做二叉排序树，又叫二叉搜索树，这三个概念指的都是同一个东西，由名字可以得知，二叉查找树的特性是快速的增删改查。

　　二叉查找树在普通的树上添加了两个条件：　　

　　在树中的任意一个节点，其左子树中的每个节点的值，都要小于本身节点的值。
　　在树中的任意一个节点，其右子树上的每个节点的值，都要大于本身节点的值。

　　满足了这两个条件，那么这棵树就叫二叉查找树，整棵树中的每个节点的子树也就都是二叉查找树。

　　 下图就是一棵二叉查找树：

查找节点

　　假设我们要查找16这个数据，首先第一步找到根节点10：

　　发现16大于10。

　　找到10的右子节点15：

　　发现16还是大于15。

　　继续找到15的右子节点17：

　　发现16小于17。

　　找到17的左子节点：

　　找到了16。

代码实现：

        public Node find(int data) {
            while (null != node) {
                if(data == node.data){
                    return node;
                }else if(data < node.data){
                    node = node.left;
                }else if(data > node.data){
                    node = node.right;
                }
            }
            return null;
        }

最小节点和最大节点

　　由于小的节点总是在左子节点方向，因此我们可以用递归来实现找到整棵树中的最小节点：

    public Node minNode(){
        return minNode(tree);
    }
    private Node minNode(Node node)
    {
        if(null == node.left){
            return node;
        }
        return minNode(node.left);
    }

　　最大节点也是一样，递归往右找，到底为止。

    public Node maxNode(){
        return maxNode(tree);
    }
    private Node maxNode(Node node)
    {
        if(null == node.right){
            return node;
        }
        return maxNode(node.right);
    }

插入

　　新插入的节点，也要遵循二叉查找树的规则，逐一比较大小，比节点大就往右边，比节点小就往左边。

　　比如我们插入13这个元素，遵循规则的判断后最终位置会确定成14的左子节点。

代码实现：

        public void insert(int data) {
            Node newNode = new Node(data);
            if (null == tree) {
                tree = newNode;//如果整棵树不存在 那么新数据就是根节点
                return;
            }
            while (null != tree) {
                if(data == tree.data){
                    return;//重复值
                }
                //新元素大于当前节点
                if (data > tree.data) {
                    //右子节点有空位，则插入
                    if (null == tree.right) {
                        tree.right = newNode;
                        return;
                    }
                    tree = tree.right;
                } else {
                //新元素小于
                    if (null == node.left) {
                        tree.left = newNode;
                        return;
                    }
                    tree = tree.left;
                }
            }
        }

　　当我们依次插入10、8、15、7、14、17这几个元素后，二叉树的结构是这个样子的：

删除的三种情况

　　二叉查找树最难实现的就是删除，它要分三种情况

　　情况一：如果要删除的节点是叶子节点，比如我们要删除6这个节点

　　由于叶子节点没有子节点，所以只需要将它自身删除即可，也就是将该节点的父节点中指向它的指针置为null。

　　情况二：需要删除的节点含有一个子节点，比如我们要删除14这个节点

　　我们只需要把14拿掉，把14的子节点13连上14的父节点15就可以了

　　情况三：如果要删除的节点含有两个子节点，比如我们要删除15这个节点

　　这种情况也有两种做法。

　　其一是删除15这个元素，然后在15的右子树中查找最小的那个节点，替换到15的位置，结果如图：

　　其二是删除15这个元素，然后在15的左子树中查找最大的那个节点，替换到15的位置，结果如图：

　　两种做法都可以满足二叉树的规则。

　　代码实现：

    public void delete(int data) {
        Node deleteNode = tree; //目标删除节点 首先默认根节点
        boolean is_find = false;//是否找到节点标记
        Node deleteNodeParent = null; //目标删除节点的父节点
        while (null != deleteNode) {
            if(deleteNode.data == data){
                //找到了要删除的节点
                is_find = true;
                break;
            }
            deleteNodeParent = deleteNode;
            if (data > deleteNode.data) {
                deleteNode = deleteNode.right;//如果要删除的数据比当前节点大，则往后边走。
            } else {
                deleteNode = deleteNode.left;//如果要删除的数据比当前节点大，则往后边走。
            }
        }

        //没有该节点
        if (!is_find) {
            return;
        }

        // 要删除的节点有两个子节点
        if (null != deleteNode.left && null != deleteNode.right) {
            // 查找右子树中最小节点
            Node nodeMin = deleteNode.right;//右子树中最小节点
            Node nodeMinParent = deleteNode; // 右子树中最小节点的父节点
            while (null != nodeMin.left) {
                //只往左边找，最小的数据永远都在最左边
                nodeMinParent = nodeMin;
                nodeMin = nodeMin.left;
            }
            deleteNode.data = nodeMin.data; // 将目标删除节点中的数据替换成右子树最小节点的数据，由于是引用传递，所以树（tree）中要删除的节点内容已经替换成了右子树中最小节点内容
            deleteNode = nodeMin; //更新要删除的节点 转移删除目标 现在需要删除右子树中的最小节点 （程序走到这里 此时deleteNode是一定没有子节点的 因为它本身就是一个叶子节点）
            deleteNodeParent = nodeMinParent;//更新删除目标的父节点
        }

        // 删除节点是叶子节点或者仅有一个子节点
        Node childNode = null; // 接管被删除节点下面的子节点

        //如果你有子节点 那么将子树拿出来
        if(null != deleteNode.left){
            childNode = deleteNode.left;
        }else if(null != deleteNode.right){
            childNode = deleteNode.right;
        }

        //如果你要删的是根节点
        if(null == deleteNodeParent){
            tree = childNode;
        }else{
            //处理被删除节点的父节点 将父节点的的指针指向下面的子节点
            if(deleteNodeParent.left == deleteNode){
                deleteNodeParent.left = childNode;//如果是在父节点的左子节点 则把子节点对接给父节点的left
            }else{
                deleteNodeParent.right = childNode;//如果是在父节点的右子节点 则把子节点对接给父节点的right
            }
        }
    }

　　虽然我们没有真实的去做删除节点这个操作，但是更改了引用之后，它很快就会被垃圾收集器清理掉。

懒惰删除

　　由于删除工作要沿着整棵树进行两趟搜索，所以它的效率是有提升空间的，因此在二叉查找树的删除方面还有一个方案，叫做懒惰删除。

　　懒惰删除的做法是删除一个元素时候，只是将它标记为已删除，并不是真正的把这个节点删掉，它仍然存留在树中，只是属性里多了一个标记。

　　懒惰删除使删除操作变的简单，但缺点是比较浪费空间，只有确定删除的次数很少的时候几乎才会考虑，并且遍历时却需要对整棵树重新排序，因此个人认为这种删除方式更加麻烦，绝大部分实现二叉树的开发者都不会采用懒惰删除这种方法。

二叉树的遍历

深度优先遍历

　　深度优先遍历的思想很简单，就是一条线先走到尽头，再回头走另一条线。

　　以如下这棵树为例，首先遍历出 10->8->7->5->1

　　然后再遍历出 6

　　然后是 15->14->13

　　然后是17->16  

　　最后是19

代码：

    public void preTraversal(Node node){
        if(node == null){
            return;
        }
        System.out.println(node.data);
        preTraversal(node.left);
        preTraversal(node.right);
    }

广度优先遍历

　　广度优先遍历还有另一种称呼叫层序遍历，像洋葱一样一层一层的剥，如下图：

　　这种遍历需要借助队列来完成：

    public static void levelTraversal(Node root){
        if(null == root){
            return;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);//初始化
        while(!queue.isEmpty()){
            Node node = queue.poll();//弹出节点
            System.out.println(node.data);//打印
            if(node.left != null){
                queue.offer(node.left);//左子节点入队
            }
            if(node.right != null){
                queue.offer(node.right);//右子节点入队
            }
        }
    }

最后：感谢阅读。