二叉树基础

一、 树相关概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。

1. 重要概念

以下是树中比较重要的一些概念，需要重点掌握，但无需死记硬背，照着下面的图理解即可；

• 节点的度：一个节点含有的子树的个数；
• 树的度：树中最大的节点的度；
• 叶子节点或终端节点：度数为0的节点，即该节点没有子树；
• 双亲节点或父节点：若一个节点含有子节点，则称其为子节点的双亲结点；
• 孩子节点或子节点：若一个节点含有的子树的根节点称为该节点的孩子节点；
• 根结点：没有双亲结点的节点；
• 节点的层次：从根节点开始定义，根节点为第一层，根节点的子树为第二层，以此类推；
• 树的高度：树中节点的最大层次；
  

2. 了解概念

下面的几个概念只需了解即可，知道这个概念是什么意思就行；

• 非终端节点或分支节点：非叶子节点；
• 兄弟节点：一个节点的子树不止一个，那么这几个子树互为兄弟节点；
• 堂兄弟节点：双亲在同一层的节点互为堂兄弟；
• 节点的祖先：从根到该节点所经分支上的所有节点；
• 子孙：以某节点为根的子树中任一节点都称为该节点的子孙；
• 森林：m**( m>=0 )**颗互不相交的树的集合;
  

3. 树的表示形式

最常用的表示形式是孩子兄弟表示法，每个节点有三个域，分别存放当前节点的数值，当前节点的左孩子，即第一个孩子引用以及当前节点的兄弟引用，存储结构入下图所示；

class Node {
 int value; // 树中存储的数据
 Node firstChild; // 第一个孩子引用
 Node nextBrother; // 下一个兄弟引用
}

二、 二叉树

1. 概念

二叉树是指树中节点的度不大于2的有序树。 这里两处加粗的词就是二叉树的两个特点：

1. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点；
2. 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。

下图是几种特殊的二叉树形态，我们不难发现，有两棵树含有相同的节点A,B，且根节点都是A，但由于节点B分别作为左右子树，所以他们实际上是两颗不同的树。

2. 二叉树的性质

• 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2^（i-1）(i>0)个结点;
• 若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 (k>=0);
• 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1;
• 对任何一棵二叉树, 节点总数N = n0 + n1 + n2 = 2n2 + n1;
• 具有n个结点的完全二叉树的深度k为 log2(n+1) 向上取整；

这里会针对二叉树的性质出一些小计算题，只要掌握了性质都不是太难，就是要画图稍微绕一些，多做几个题练习一下应该问题不大；

3. 满二叉树与完全二叉树

满二叉树：如果一棵二叉树的层数为k，且他的节点总数为2^k -1,则称为满二叉树；

下图就是一颗满二叉树，它的层数为3，总结点数为7，符合定义，每一个节点的度都为2；

完全二叉树：树中所含的n个节点和满二叉树中编号为1~n的节点一一对应；

完全二叉树的这个概念略显晦涩，我们不妨看下下面两张图理解一下；

图a是完全二叉树，而图b是非完全二叉树，再对比定义，也就是说节点必须是按照从上到下，从左到右的顺序排列，像图b节点3的左孩子为null，但是右孩子存在，那么对应上图的满二叉树，它的编号并不是一一对应的。

4. 二叉树的存储

二叉树的存储分为两种：顺序存储和链式存储；

顺序存储

一般用于存储完全二叉树，此种方式效率更高。利用数组存储二叉树结构，将二叉树用层序遍历方式存入数组中，这种存储方式的主要用法就是堆；

链式存储

二叉树的链式存储类似于链表结构，常见的表示方式有二叉和三叉表示方式；

• 二叉表示法中节点含有三个域，除去数据域外，其他两个引用域分别是左右孩子引用；

// 孩子表示法 
class Node {
 int val; // 数据域
 Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
 Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}

• 三叉表示法中节点含有四个域，除去数据域外，其他三个引用域分别是左右孩子引用以及当前节点的父亲节点；

// 孩子双亲表示法
class Node {
 int val; // 数据域
 Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
 Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
 Node parent; // 当前节点的根节点
}

5. 二叉树的遍历

5.1 递归遍历

前序遍历：根节点 --> 左子树–> 右子树

void preOrderTraversal(TreeNode root){
        if(root == null) {
            return;
        }
        System.out.print(root.val+" ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
    }

中序遍历：左子树 --> 根节点 --> 右子树

void inOrderTraversal(TreeNode root){
        if(root == null) {
            return;
        }
        inOrderTraversal(root.left);
        System.out.print(root.val+" ");
        inOrderTraversal(root.right);
    }

后序遍历： 左子树–> 右子树 --> 根节点

void postOrderTraversal(TreeNode root){
        if(root == null) {
            return;
        }
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.val+" ");
    }

5.2 非递归遍历

前序遍历

void preOrderTraversalNor(TreeNode root){
        if(root == null)  return;
        Stack<TreeNode>stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                System.out.print(cur.val + " ");
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            cur = top.right;
        }//while
        //System.out.println();
    }

中序遍历

void inOrderTraversalNor(TreeNode root){
        if(root == null)  return;
        Stack<TreeNode>stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            System.out.print(top.val + " ");
            cur = top.right;
        }//while
        //System.out.println();
    }

后序遍历

void postOrderTraversalNor(TreeNode root) {
        if(root == null) return;
        TreeNode cur = root;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;//用来指定 上一个被打印的元素

        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
           //当cur一直往左走时会遇到空，此时不能出栈顶元素，因为栈顶元素右子树还没有执行
            cur = stack.peek();
            if (cur.right == null || cur.right == pre) {
                TreeNode popNode = stack.pop();
                System.out.print(popNode.val + " ");
                pre = cur;
                cur = null;
            } else {
                cur = cur.right;
            }
        }
        //System.out.println();
    }

层序遍历：利用队列，当队列不空就弹出当前节点，同时将当前节点的左右节点入队，直至队列为空；

void levelOrderTraversal(TreeNode root){
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null){
            return;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode top = queue.poll();
            System.out.print(top.val + "");
            if(top.left != null){
                queue.offer(top.left);
            }
            if(top.right != null){
                queue.offer(top.right);
            }
        }
    }

6. 二叉树的基本操作

需要我们掌握的是以下列举的一些基本操作，这些操作都是复杂问题的基础，需要我们了熟于心。

• 前中后序遍历
• 求节点的个数
• 求叶子节点的个数
• 求第k层节点的个数
• 获取二叉树的高度
• 按值查找节点

关于本文的所有代码，以及上述所列的一些基本操作，下方都列出Github的详细代码仅供参考。
二叉树相关代码练习