引

​ 树形结构是一种常见的数据结构, 也是非常重要的数据结构~ 而我们今天要介绍的就是树型结构中最简单的一种树 ---- 二叉树, 这也是我们学习其他树的基础~

其他树有:

• 二叉树搜索树（BST）
• AVL树（平衡二叉搜索树）
• 红黑树
• B - 树
• B + 树
• B * 树（B+ 树是对 B- 树的一种优化, B* 树是对B+树的一种优化 ）
• 图
• 并查集
• 位图
• 布隆过滤器

树

什么是树？

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

树的特点:

• 树有且仅有一个根节点, 根节点就是没有前驱的节点
• 类似于链表, 树也是由一个个的节点组成的. 在链表中的节点信息只包含 value 和 next 但在树中的 next 可以是有多个的, 你想分成几叉的你就有多少个 next 域
• 树天生是递归定义的
• 数的子树之间是不能相交的, 否则就构成不了树形结构了

如下图就是一颗树:

树的相关概念

• 结点的度：一个结点含有子树的个数称为该结点的度. 如上图：A的度为4
• 树的度：一棵树中，所有结点度的最大值称为树的度. 如上图：树的度为6
• 叶子结点(也叫终端结点)：度为0的结点称为叶结点. 如上图: F, H, G 都是叶子节点
• 双亲结点(也称父亲节点): 若一个节点含有子节点, 则称该节点是子节点的双亲结点. 如上图: B, C, D, E 的双亲结点都是 A
• 孩子节点(也称子节点): 一个含有父亲节点的节点称为父亲节点的孩子节点. 如上图: B, C, D, E 都是 A 节点的孩子节点
• 根结点：一棵树中，没有双亲结点的结点；如上图：A
• 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推. 如上图的层数就为 3
• 树的高度(最大深度)：树中结点的最大层次； 如上图：树的高度为 3
• 非终端结点(分支结点)：度不为0的结点就叫分支节点. 如上图: A, B, C, D, E 都是分支节点
• 兄弟结点：具有相同父结点的结点互称为兄弟结点. 如上图: B, C, D, E 都是兄弟节点
• 堂兄弟结点：双亲在同一层的结点互为堂兄弟
• 结点的祖先：从根到该结点所经分支上的所有结点. 如上图：A是所有结点的祖先
• 子孙：以某结点为根的子树中任一结点都称为该结点的子孙. 如上图：所有结点都是A的子孙
• 森林：由 m (m>=0) 棵互不相交的树组成的集合称为森林

什么是二叉树？

二叉树的概念

​ 类似于链表, 二叉树树也是由一个个的节点组成的. 在链表中的节点信息只包含 value 和 next 但在二叉树中的就的 next 域就换成了 left 域和 right 域了, left 指向的节点及其它的子节点就称为左子树, right 指向的子节点及其它的子节点就称为右子树. 相比于多叉树的区别, 就是二叉树的每个节点最多分两叉~

二叉树的特点:

• 有且只有一个根节点
• 每个节点的子节点个数不超过两个, 因此二叉树不存在度大于2的结点
• 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树（指顺序有序）

简单来说, 二叉树的每个节点，要么有0个孩子，要么有1个孩子要么有2个孩子

二叉树节点的构成:

// 孩子表示法
static class TreeNode {
    // 数值域
    int val;
    // 左子树
    TreeNode left;
    // 右子树
    TreeNode right;
}

下图就是一个普通的二叉树:

两种特殊的二叉树

满二叉树

​ 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵二叉树的层数为K，且结点总数是 ，则它就是满二叉树。

下图就是一颗满二叉树:

完全二叉树

完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。完全二叉树就是依次存放

下图就是一颗完全二叉树:

二叉树的性质

• 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 (i>0)个结点
• 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 (k>=0)
• 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
• 具有n个结点的完全二叉树的深度k为 向上取整
• 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为 i 的结点有：
  • 若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
  • 若2i+1<n，左孩子序号：2i+1，否则无左孩子
  • 若2i+2<n，右孩子序号：2i+2，否则无右孩子

二叉树的基本操作

下面是二叉树的相关方法的代码实现~

代码

import java.util.*;


public class MyBinaryTree {


    static class TreeNode {
        // 数值域
        int val;
        // 左子树
        TreeNode left;
        // 右子树
        TreeNode right;
    }


    public TreeNode root;

    public MyBinaryTree() {

    }

    public TreeNode createBinaryTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        E.right = H;
        C.left = F;
        C.right = G;

        this.root = A;
        return A;
    }

    //前序遍历
    public void preOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val +" ");
        preOrder(root.left);
        preOrder(root.right);
    }

    //中序遍历
    public void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val +" ");
        inOrder(root.right);
    }

    //后序遍历
    public void postOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val +" ");
    }

    public List<Character> preorderTraversal(TreeNode root) {
        List<Character> retList = new ArrayList<>();

        if (root == null) {
            return retList;
        }

        retList.add(root.val);

        List<Character> leftTree = preorderTraversal(root.left);
        retList.addAll(leftTree);

        List<Character> rightTree = preorderTraversal(root.right);
        retList.addAll(rightTree);

        return retList;
    }

    // 获取树中节点的个数
    // 方法一:
    int size(TreeNode root) {
        if (root == null) return 0;
        return size(root.left) + size(root.right) + 1;
    }

	// 方法二:
    int size1(TreeNode root) {
        int count = 0;
        if (root == null) {
            return count;
        }
        count++;
        int leftSize = size1(root.left);
        count += leftSize;

        int rightSize = size1(root.right);
        count += rightSize;

        return count;
    }

	// 方法三:
    int count = 0;
    int size2(TreeNode root) {
        if (root == null) {
            return 0;
        }
        count++;
        size2(root.left);
        size2(root.right);
        return count;
    }

    // 获取叶子节点的个数
    // 方法一:
    int leafCount = 0;
    int getLeafNodeCount1(TreeNode root){
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            leafCount++;
        }
        getLeafNodeCount1(root.left);
        getLeafNodeCount1(root.right);
        return leafCount;
    }

	// 方法二:
    // 子问题思路
    int getLeafNodeCount(TreeNode root){
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            //当前的root是叶子节点，则返回1
            return 1;
        }
        //这个表达式可以让递归走下去，也就是说搜索了这棵树
        return getLeafNodeCount(root.left) + getLeafNodeCount(root.right);
    }

    // 获取第K层节点的个数
    int getKLevelNodeCount(TreeNode root, int k) {
        if (root == null || k <= 0) {
            return 0;
        }
        if (k == 1) {
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1) + getKLevelNodeCount(root.right,k-1);
    }

    // 获取二叉树的高度
    int getHeight1(TreeNode root) {
        if (root == null) {
            return 0;
        }

        return getHeight(root.left) > getHeight(root.right)
                ? getHeight(root.left) + 1 : getHeight(root.right) + 1;
    }

    /**
     * 最大深度
     * @param root
     * @return
     */
    int getHeight(TreeNode root) {
        return root == null ? 0 : Math.max(getHeight(root.left), getHeight(root.right) + 1);
    }

    // 检测值为value的元素是否存在
    TreeNode find(TreeNode root, int val) {
        if(root == null) return null;
        if(root.val == val) return root;
        TreeNode left = find(root.left,val);
        if (left != null) return left;
        return find(root.right,val);
    }

    // 层序遍历
    // 方法一: 使用递归
    void levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) return;
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            System.out.print(cur.val +" ");
            if (cur.left != null)
                queue.offer(cur.left);
            if (cur.right != null)
                queue.offer(cur.right);
        }
    }

    // 方法二: 迭代
    // 借助队列来完成
    void levelOrder1(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) return;
        queue.offer(root);
        while (queue.peek() != null) {
            TreeNode cur = queue.poll();
            System.out.print(cur.val +" ");
            queue.offer(cur.left);
            queue.offer(cur.right);
        }
    }
}

二叉树的前中后序遍历

​ 其实二叉树的前中后序遍历都是一个套路 --- 递归套路. 前中后序遍历的路径是一模一样的, 只是它们访问根节点的时机不同罢了. 总共有三次访问节点的机会, 如果是第一次访问那么就是前序遍历, 如果是第二次访问就是中序遍历, 如果是第三次访问就是后序遍历. 为什么可以有三次机会访问节点呢? 这就是因为是递归所以能访问节点三次, 这种访问的顺序我们也可以称为递归序.

二叉树的访问路径如下图:

• 从 A 出发，橙色的线条代表 递 的过程
• 绿色的线条代表 归 的过程，从 A 出去，完成递归

前序遍历

使用递归实现:

// 递归实现
public void preorder(TreeNode root) {
    if (root == null) {
        return;
    }
    System.out.print(root.val + " ");
    preorder(root.left);
    preorder(root.right);
}

使用栈实现:

public void preorder1(TreeNode root) {
    if (root == null) {
        return;
    }
    Stack<Node> stack = new Stack<>();
    // 先将根节点入栈
    stack.push(root);
    while (!stack.isEmpty()) {
        root = stack.pop();
        System.out.print(root.val);
        // 先将右节点压入栈中, 再将左节点压入栈中
        // 这样出栈的顺序就是先左后右
        if (root.right != null) {
            stack.push(root.right);
        }
        if (root.left != null) {
            stack.push(root.left);
        }
    }
}

中序遍历

使用递归实现:

// 递归实现
public void inorder(TreeNode root) {
    if (root == null) {
        return;
    }
    inorder(root.left);
    System.out.print(root.val + " ");
    inorder(root.right);
}

使用栈实现:

public void inorder(TreeNode root) {
    if (root == null) return;
    Stack<TreeNode> stack = new Stack<>();
    while (!stack.isEmpty() || root != null) {
        if (root != null) {
            //先将左子树全部压入栈
            stack.push(root);
            root = root.left;
        } else {
            //左子树处理完了，处理右树
            root = stack.pop();
            System.out.print(root.val + " ");
            root = root.right;
        }
    }
}

后序遍历

使用递归实现:

// 递归实现
public void postorder(TreeNode root) {
    if (root == null) {
        return;
    }
    postorder(root.left);
    postorder(root.right);
    System.out.print(root.val + " ");
}

这里需要使用两个栈:

public void postorder(TreeNode root) {
    if (root == null) return;
    //先将所有节点push进stack1，再把stack1里的节点push进stack2
    // 然后弹出打印stack2的节点则完成逆序，即后序打印
    Stack<TreeNode> stack1 = new Stack<>();
    Stack<TreeNode> stack2 = new Stack<>();
    stack1.push(root);
    while (!stack1.isEmpty()) {
        TreeNode temp = stack1.pop();
        stack2.push(temp);
        //先压左子树，后压右子树
        if (temp.left != null) {
            stack1.push(temp.left);
        }
        if (temp.right != null) {
            stack1.push(temp.right);
        }
    }
    while (!stack2.isEmpty()) {
        System.out.print(stack2.pop().val + " ");
    }
}

结