二叉树

树型结构（了解）

树的概念

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

• 有一个特殊的结点，称为根结点，根结点没有前驱结点
• 除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 （一棵树是由若干个不相交的子树组成的）
• 树是递归定义的

注意：树形结构中，子树之间不能有交集，否则就不是树形结构

相关概念（重要）

结点的度：一个结点含有子树的个数称为该结点的度； 如上图：A的度为6

树的度：一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为6

叶子结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I…等节点为叶结点

双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点

孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点

根结点：一棵树中，没有双亲结点的结点；如上图：A

结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推

树的高度或深度：树中结点的最大层次； 如上图：树的高度为4

树的以下概念只需了解，在看书时只要知道是什么意思即可：

非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G…等节点为分支结点

兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点

堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点

结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先

子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙

森林：由m（m>=0）棵互不相交的树组成的集合称为森林

树的表示形式（了解）

树结构相对线性表比较复杂，要存储表示起来比较麻烦，实际中树有很多种表示方式，如：双亲表示法， 孩子表示法、孩子双亲表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

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

树的应用

文件系统管理（目录和文件）

二叉树（重点）

概念

一棵二叉树是结点的一个有限集合，该集合：

1. 或者为空

2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成

   

从上图可以看出：

1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
3. 一棵树如果是二叉树，那么它每棵树都是二叉树

注意：对于任意的二叉树都是由以下几种情况复合而成的：

两种特殊的二叉树

1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵 二叉树的层数为K，且结点总数是 (2^k - 1)，则它就是满二叉树
2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n 个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树

完全二叉树是一种特殊类型的二叉树，其特点是除了最后一层外，其他层的节点都被完全填满，而且最后一层的节点都集中在左边。换句话说，对于深度为 d 的完全二叉树，其前 d-1 层都是满的，第 d 层的节点都尽可能地靠左排列。

具体特点包括：

1. 第 i 层上的节点数目为 $2^{i-1}$（i ≥ 1）。
2. 深度为 d 的完全二叉树的节点数目为 $2^d-1$。
3. 若以从上至下、从左至右的顺序对完全二叉树的所有节点编号，则对于任意节点 i（1 ≤ i ≤ n），有：

• 如果 i = 1，则为根节点；
• 如果 i > 1，则其父节点为 i/2（向下取整）。

二叉树的性质

1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 $2^{i-1}$个结点(i>0)

2. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 $2^k$ -1(k>=0)

3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1 （任何一棵二叉树，叶子节点的个数永远比度为2的节点个数多1个）

   推导：

   • 等式1：假设这棵二叉树有N的节点，度为0的有n0，度为1的有n1，度为2的有n2

     N = n0 + n1 + n2

   • 等式2：一棵N个结点的树有N-1条边
     在一棵树当中，度为0的节点是不会产生边的。 那意味着只有度为1的节点和度为2的节点会产生边
     n1个节点能够产生n1条边，n2个节点能够产生（2*n2）条边

   N-1 = n1 + 2*n2 = (n2+1) + n1 + n2

   综上：N = n0 + n1 + n2 = (n2+1) + n1 + n2

   推得：n0＝n2＋1

4. 对于完全二叉树，节点个数为n时高度h为

h = log(n+1)向上取整 即3.x 取4
h = log(n)+1向下取整 即3.x 取 3

推导：2^k - 1 = n

5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i 的结点有：

   • 若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
   • 若2i+1 < n，左孩子序号：2i+1，否则无左孩子
   • 若2i+2 < n，右孩子序号：2i+2，否则无右孩子

举例：

• 已知父亲节点下标为 i ，则左孩子下标：2 * i + 1，右孩子：2 * i + 2

• 已知孩子节点下标为 i ，则父亲节点下标：( i-1 ) / 2

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
A 不存在这样的二叉树
B 200
C 198
D 199
 
2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2
 
3.一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386
 
4.一棵完全二叉树的节点数为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12

答案：
1.B
2.A
3.B
4.B

二叉树的存储

二叉树的存储结构分为：顺序存储和类似于链表的链式存储

二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式，具体如下：

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

二叉树的基本操作

创建一颗二叉树

创建一颗二叉树 创建成功后 返回根节点

public TreeNode createTree() {
    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;
    C.left = F;
    C.right = G;
    E.right = H;

    return A;
}

回顾二叉树的概念

二叉树是：

1. 空树
2. 非空：根节点，根节点的左子树、根节点的右子树组成的

从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的

二叉树的遍历

遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容、节点内容加1)。 遍历是二叉树上最重要的操作之一，是二叉树上进行其它运算之基础。

前中后序遍历

如果N代表根节点，L代表根节点的左子树，R代表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式：

• NLR：前序遍历(Preorder Traversal 亦称先序遍历) —— 访问根结点 —> 根的左子树 —> 根的右子树
• LNR：中序遍历(Inorder Traversal) —— 根的左子树 —> 根节点 —> 根的右子树
• LRN：后序遍历(Postorder Traversal) —— 根的左子树 —> 根的右子树 —> 根节点

// 前序遍历（根-左-右）
void preOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    System.out.print(root.val + " ");
    preOrder(root.left);
    preOrder(root.right);
}

// 中序遍历（左-根-右）
    void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }

// 后序遍历（左-右-根）
    void postOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }

前序递归遍历示意图：

前序遍历结果：1 2 3 4 5 6

中序遍历结果：3 2 1 5 4 6

后序遍历结果：3 1 5 6 4 1

练习：

前序：A B D E H C F G

中序：D B E H A F C G

后序：D H E B F G C A

层序遍历

层序遍历：设二叉树的根节点所在层数为1，从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层 上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

练习

1. 某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为( )

A: A B D H E C F G

B: A B C D E F G H

C: H D B E A F C G

D: H D E B F G C A

[答案] A

2. 二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK ; 中序遍历：HFIEJKG. 则二叉树根结点为( )

   A: E

   B: F

   C: G

   D: H

先序遍历第一个是根，后序遍历最后一个是根

[答案] A

3. 设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为( )

   A: a d b c e

   B: d e c a b

   C: d e b a c

   D: a b c d e

[答案] D

4. 某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出(同一层从左到右)的序列为( )

   A: F E D C B A

   B: C B A F E D

   C: D E F C B A

   D: A B C D E F

[答案] A

问题:

给你一个前序 和 一个后序遍历，能否创建个二叉树?
不可以，因为前序和后序确定的都是根!!

二叉树的基本操作

获取树中节点的个数

遍历思路解决:

只需要按照某种遍历方式，遍历到某个节点

判断是不是叶子，是则计数器++

( 前序遍历 还是 中序遍历 , 只要遍历到节点 就让计数器++ )

• 子问题思路: 整棵树的叶子 = 左子树的叶子 + 右子树的叶子

public int nodeSize;

// 获取树中节点的个数
int size1(TreeNode root) {
    if (root == null) {
        return 0;
    }
    nodeSize++;
    size1(root.left);
    size1(root.right);
    return nodeSize;
}

//子问题的思路解决：整棵树的节点个数
int size2(TreeNode root) {
    if (root == null) {
        return 0;
    }
    return size2(root.left) + size2(root.right) + 1;
}

获取叶子节点的个数

public int leafSize;

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

//子问题的思路解决：整棵树的叶子节点个数
int getLeafNodeCount2(TreeNode root) {
    if (root == null) {
        return 0;
    }
    if (root.left == null && root.right == null) {
        return 1;
    }
    return getLeafNodeCount2(root.left)
            + getLeafNodeCount2(root.right);
}

获取第K层节点的个数

整棵树的第K层多少个节点 = 左子树的第k-1层节点 + 右子树的第K-1层节点

eg. A的第3层 = A的左树的第2层 + A的右树的第2层

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

获取二叉树的高度

1. 沿着某条路线遍历完所有的节点
2. 在遍历这个节点的时候，判断一下是不是你要的条件!

• 整棵树的高度 = (左子树的高度 和 右子树的高度) 的最大值 +1

// 获取二叉树的高度 时间复杂度O(N)
int getHeight(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftHeight = getHeight(root.left);
    int rightHeight = getHeight(root.right);

    return leftHeight > rightHeight ? leftHeight + 1 :
            rightHeight + 1;
}

//子问题的思路解决：整棵树的高度
int getHeight2(TreeNode root) {
    if (root == null) {
        return 0;
    }

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

检测值为value的元素是否存在

思路:

1. 判断是否为空树
2. 判断根是不是，不是继续执行
3. 左子树
4. 右子树

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

    if (root.val == val) {
        return root;
    }
    TreeNode ret1 = find(root.left, val);
    if (ret1 != null) {
        return ret1; //不去右边了
    }

    TreeNode ret2 = find(root.right, val);
    if (ret2 != null) {
        return ret2;
    }

    return null;
}

层序遍历

//层序遍历 用队列
void levelOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

    while (!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        System.out.println(cur.val + " ");

        if (cur.left != null) {
            queue.offer(cur.left);
        }
        if (cur.right != null) {
            queue.offer(cur.right);
        }
    }
}

判断一棵树是不是完全二叉树

boolean isCompleteTree(TreeNode root) {
        if(root == null) {
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if(cur != null) {
                queue.offer(cur.left);
                queue.offer(cur.right);
            }else {
                break;//结束这个循环
            }
        }
        //需要判断队列当中 是否有非空的元素
        while (!queue.isEmpty()) {
            //一个元素 一个元素 出队来判断 是不是空
            TreeNode tmp = queue.peek();
            if(tmp == null) {
                queue.poll();
            }else {
                return false;
            }
        }
        return true;
    }

二叉树相关oj题

注意在线OJ算法题分为两种类型：

1. 接口类型OJ：此种OJ题目是方法名字已经给好，用户直接写代码即可，也不需要包含什么包

2. IO类型的OJ：此种OJ题目需要用户定义一个public的Main类，然后在Main类中提供一个main方法，在main方法中完成事情，中间如要需要用到其他集合类，必须手动

   导入包
   在线OJ中的循环输入，输入单个值怎么循环接收，整行值怎么循环接收

检查两颗树是否相同

检查两颗树是否相同

解题思路：
1. 如果两棵树都是空，则相同
2. 如果两棵树一个为空，一个不为空，则不相同
3. 如果两棵树都不为空，先检测根是否相同，根如果相同再递归检测两棵树的左子树以及右子树是否都相同

/**
 * 时间复杂度：O min(m,n)
 *
 * @param p m
 * @param q n
 * @return
 */

public boolean isSameTree(TreeNode p, TreeNode q) {
    if ((p == null && q != null) || (p != null && q == null)) {
        return false;
    }
    //上述代码走完之后 要么是两个都为空 要么是两个都不为空
    if (p == null && q == null) {
        return true;
    }
    //代码走到这里 两个都不为空
    if (p.val != q.val) {
        return false;
    }

    //p != null && q != null && p.val == q.val
    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}

另一颗树的子树

另一颗树的子树

解题思路：
1. 题目已经说了：空树是任意一棵树的子树
2. 如果两棵树相同，也可以认为是子树，因此：只要根节点相同，直接检测root和subroot是否为相同的树即可
3. 如果根不相同，检测t是否为root.left的子树 或者 root.right的子树
如果根节点比较完，不是两颗相同的树，则意味着 这个subRoot这棵树 和 root的某一个子树是相同的

会使用到 刚刚的判断两棵树是否是相同的那个代码 isSameTree(）

/**
 * O(M*N)
 *
 * @param root
 * @param subRoot
 * @return
 */
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
    if (root == null || subRoot == null) {
        return false;
    }
    // 1.是不是和根节点相同
    if (isSameTree(root, subRoot)) {
        return true;
    }
    // 2.判断是不是root的左子树
    if (isSubtree(root.left, subRoot)) {
        return true;
    }
    // 3.判断是不是root的右子树
    if (isSubtree(root.right, subRoot)) {
        return true;
    }
    // 4.返回
    return false;
}

//检查两颗树是否相同
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if ((p == null && q != null) || (p != null && q == null)) {
            return false;
        }
        //上述代码走完之后 要么是两个都为空 要么是两个都不为空
        if (p == null && q == null) {
            return true;
        }
        //代码走到这里 两个都不为空
        if (p.val != q.val) {
            return false;
        }
            //p != null && q != null && p.val == q.val
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }

翻转二叉树

翻转二叉树

只要遍历到这个节点

就把这个节点的两个引用换一下就好了

直到所有的节点 遍历完成

public TreeNode invertTree(TreeNode root) {
    if (root == null) {
        return null;
    }
    if (root.left == null && root.right == null) {
        return root;
    }
    TreeNode tmp = root.left;
    root.left = root.right;
    root.right = tmp;

    invertTree(root.left);
    invertTree(root.right);

    return root;
}

判断一颗二叉树是否是平衡二叉树

判断一颗二叉树是否是平衡二叉树

解题思路：

• 平衡二叉树的概念：二叉树中每个节点左右子树高度差的绝对值不能超过1

• 根据概念来检测：

1. 如果是空树，直接返回，注意：空树也是平衡二叉树
2. 求根的左右子树高度，然后做差检测其高度差的绝对值是否超过1 如果超过则不是
3. 递归检测根的左右子树是否为平衡二叉树

//最坏情况下 每个节点 都要求高度
//时间复杂度：O(N^2)
public boolean isBalanced(TreeNode root) {
	// 空树是平衡二叉树
    if (root == null) {
        return true;
    }
    // 获取root左右子树的高度
    int leftHeight = maxDepth(root.left);
    int rightHeight = maxDepth(root.right);

    return Math.abs(leftHeight - rightHeight) <= 1 &&
            isBalanced(root.left) && isBalanced(root.right);

}

public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftHeight = maxDepth(root.left);
    int rightHeight = maxDepth(root.right);
    return leftHeight > rightHeight
            ? leftHeight + 1
            : rightHeight + 1;
}

面试题的难度：O(n)的时间复杂度进行计算，一边求高度 一边判端平衡的问题

//O(n)的时间复杂度
//一边求高度 一边判断平衡的问题
public boolean isBalanced2(TreeNode root) {
    if (root == null) {
        return true;
    }
    return maxDepth2(root) >= 0;
}

public int maxDepth2(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftHeight = maxDepth2(root.left);
    if (leftHeight < 0) {
        return -1;
    }
    int rightHeight = maxDepth2(root.right);
    if (leftHeight >= 0 && rightHeight >= 0
            && Math.abs(leftHeight - rightHeight) <= 1) {
        //在这种情况下 才会返回 真实的高度
        return Math.max(leftHeight, rightHeight) + 1;
    } else {
        return -1;
    }
}

对称二叉树

对称二叉树

解题思路：直接递归检测root的左右是否对称即可

1. 如果两棵树都是空树，则对称
2. 如果两棵树一棵为空树，一棵不为空树，则一定不是对称树
3. 如果两棵树都不为空，先检测两棵树的root是否相同，如果相同，再检测一个的left是否为另一个的right 并且一个的right是否为另一个的left

public boolean isSymmetric(TreeNode root) {
    if (root == null) {
        return true;
    }
    return isSymmetricChild(root.left, root.right);

}

private boolean isSymmetricChild(TreeNode leftTree, TreeNode rightTree) {
    //一边为空 一边不为空
    if ((leftTree != null && rightTree == null) || (leftTree == null && rightTree != null)) {
        return false;
    }

    //两边都为空
    if (leftTree == null && rightTree == null) {
        return true;
    }

    //两边都不为空
    //值不相等
    if (leftTree.val != rightTree.val) {
        return false;
    }
    //值相等
    return isSymmetricChild(leftTree.left, rightTree.right) &&
            isSymmetricChild(leftTree.right, rightTree.left);
}

二叉树的构建及遍历

二叉树的构建及遍历

解题思路：

遍历这个字符串，根据前序遍历的方式创建二叉树即可

import java.util.Scanner;

class TreeNode {
    public char val;

    public TreeNode left;
    public TreeNode right;

    public TreeNode(char val) {
        this.val = val;
    }
}

public class Main {
    public static int i = 0;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String str = in.nextLine();
            TreeNode root = createTree(str);
            inorder(root);
        }
    }

    public static TreeNode createTree(String str) {
        //1. 遍历字符串str
        // for(int i = 0;i < str.length();i++) {
        //     char ch = str.charAt(i);
        // }
        TreeNode root = null;
        if(str.charAt(i) != '#') {
            //2. 根据前序遍历创建二叉树
            root = new TreeNode(str.charAt(i));
            i++;
            root.left = createTree(str);
            root.right = createTree(str);
        }else {
            i++;
        }
        //3.返回根节点
        return root;
    }

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

二叉树的分层遍历

二叉树的层序遍历
解题思路：二叉树层序遍历的变形

1. 如果是空树直接返回
2. 层序遍历需要用到队列，定义一个队列，里面放置节点的地址，将根节点如队列
3. 队列非空时，循环进行一下操作：

a. 队列中当前元素都是在同一层的，依次取出遍历，保存到同一个vector中

   取到一个节点时候：
      - 保存该节点
       - 如果该节点左子树存在，将该左子树入队列
       -  如果该节点右子树存在，将该节点右子树入队列
       - 将当前已遍历节点从队列中拿出来

b. 本层节点遍历结束后，保存到返回的vector中，此时下一层节点已经全部入队列

//层序遍历 用队列
void levelOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

    while (!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        System.out.println(cur.val + " ");

        if (cur.left != null) {
            queue.offer(cur.left);
        }
        if (cur.right != null) {
            queue.offer(cur.right);
        }
    }
}

//返回二维数组
public List<List<Integer>> levelOrder2(TreeNode root) {
	// 每层节点保存到一个list中
    List<List<Integer>> ret = new ArrayList<>();
    if (root == null) {
        return ret;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

    while (!queue.isEmpty()) {
    	// 遍历当前层中的所有节点，讲下一层的节点入栈
        int size = queue.size();//队列里元素的个数
        List<Integer> tmp = new ArrayList<>();
        while (size != 0) {
            TreeNode cur = queue.poll();
            //System.out.print(cur.val + " ");
            tmp.add(cur.val);
            size--;
            // 如果cur的左子树不为空，将左子树入队列
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            // 如果cur的右子树不为空，将右子树入队列
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
         // 本层节点已经遍历完毕，并且下一层的节点已经保存到队列中
        ret.add(tmp);
    }
    return ret;
}

找到给定树中两个指定节点的最近公共祖先

二叉树的最近公共祖先

思路：
对二叉树分情况：

1. 如果二叉树采用孩子双亲表示法链接，求两个节点的最近公共祖先，实际就转化为两个链表相交求交点
2. 如果二叉树是二叉搜索树：
   a. 如果树是空，直接返回null，没有最近公共祖先节点
   b. 如果两个节点中有一个是根节点，最近公共祖先一定是根节点
   c. 如果两个节点一个比根节点大，一个比根节点小，最近公共祖先一定是根节点
   d. 如果两个节点都比根节点小，递归到根的左子树中查找
   e. 如果两个节点都比根节点大，递归到根的右子树中查找
3. 如果是普通的二叉树

• 方法一：写一个判断节点是否在二叉树中的方法，可以参考类似二叉搜索树的方法解觉
  如果树是空，直接返回null，没有最近公共祖先节点
  如果两个节点中有一个是根节点，最近公共祖先一定是根节点
  如果两个节点一个在根节点的左子树，一个在根节点的右子树，最近公共祖先一定是根节点
  如果两个节点都在左子树中，递归到左子树中找
  如果两个节点都在右子树中，递归到右子树中找
• 方法二：受孩子双亲表示法启发，如果能够知道节点到根的路径，问题就解决了
  获取节点pNode的路径，因为公共祖先从下往上找，因此将路径中的节点保存在栈中

1. 如果是空树，直接返回
2. 将根节点入栈，如果根节点和pNode是同一个节点，该节点到根的路径找到，否则：
3. 递归在根节点的左子树中查找，如果找到，返回
4. 如果在根节点的左子树中未找到，递归到根节点的右子树中找
5. 如果右子树中没有找到，说明root一定不再路径中

    获取最近公共祖先：
     1. 在二叉树中获取两个节点的路径
     2. 如果两个路径中节点个数不一样，节点多的出栈，直到两个栈中元素相等
         相等时：再比较两个栈顶是不是同一个节点，如果是，最近公共祖先找到，
                 如果不是，两个栈同时进行出栈，继续比较，直到找到为止

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if (root == null) {
        return null;
    }
    if (root == p || root == q) {
        return root;
    }
    TreeNode leftTree = lowestCommonAncestor(root.left,p,q);
    TreeNode rightTree = lowestCommonAncestor(root.right,p,q);

    if (leftTree != null && rightTree != null) {
        return root;
    }else if (leftTree != null) {
        return leftTree;
    }else {
        return rightTree;
    }
}

用栈解决：

public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
    if(root == null) return null;

    Stack<TreeNode> stackP = new Stack<>();
    Stack<TreeNode> stackQ = new Stack<>();

    getPath(root,p,stackP);
    getPath(root,q,stackQ);

    int sizeP = stackP.size();
    int sizeQ = stackQ.size();

    if(sizeP > sizeQ) {
        int size = sizeP - sizeQ;
        while(size != 0) {
            stackP.pop();
            size--;
        }

    }else {
        int size = sizeQ - sizeP;
        while(size != 0) {
            stackQ.pop();
            size--;
        }
    }
    //两个栈当中的元素是一样多
    while(!stackP.isEmpty() && !stackQ.isEmpty()) {
        if(stackP.peek() == stackQ.peek()) {
            return stackP.peek();
        }else{
            stackP.pop();
            stackQ.pop();
        }
    }

    return null;
}

//如何存储 从根节点到 p 或者 q 的路径上的所有节点
private boolean getPath(TreeNode root, TreeNode node, Stack<TreeNode> stack) {
    if(root == null || node == null) {
        return false;
    }
    stack.push(root);
    if(root == node) {
        return true;
    }
    boolean flg = getPath(root.left,node,stack);
    if(flg) {
        return true;
    }
    boolean flg2 = getPath(root.right,node,stack);
    if(flg2) {
        return true;
    }
    stack.pop();
    return false;
}

根据一棵树的前序遍历与中序遍历构造二叉树

从前序遍历与中序遍历构造二叉树

解题思路：

1. 从前序遍历结果中获取到树的根节点
2. 在中序遍历结果中确定根节点的位置，按照该位置将中序遍历结果分为两部分
   左半部分是根节点的左子树，递归创建根节点的左子树
   右半部分是根节点的右子树，递归创建根节点的右子树
   

// 根据一棵树的前序遍历与中序遍历构造二叉树
class SolutionCreateTree {

    static class TreeNode {
        public int val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    public int preIndex; // 用于记录当前处理的前序遍历数组的索引位置

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTreeChilde(preorder, inorder, 0, inorder.length - 1);
    }

    // 构建子树的方法，参数包括前序遍历数组、中序遍历数组、当前子树在中序遍历数组中的起始位置和结束位置
    private TreeNode buildTreeChilde(int[] preorder, int[] inorder, int inbegin, int inend) {
        // 如果开始位置大于结束位置，表示当前子树为空，返回 null
        if (inbegin > inend) {
            return null;
        }

        // 创建根节点，节点值为前序遍历数组中当前 preIndex 索引位置的值
        TreeNode root = new TreeNode(preorder[preIndex]);

        // 在中序遍历数组中找到根节点的位置
        int rootIndex = findIndexRoot(inorder, inbegin, inend, preorder[preIndex]);
        if (rootIndex == -1) {
            return null;
        }

        // 更新 preIndex，指向下一个需要处理的前序遍历数组的值
        preIndex++;

        // 递归构建左子树，更新当前子树在中序遍历数组中的结束位置
        root.left = buildTreeChilde(preorder, inorder, inbegin, rootIndex - 1);

        // 递归构建右子树，更新当前子树在中序遍历数组中的起始位置
        root.right = buildTreeChilde(preorder, inorder, rootIndex + 1, inend);

        // 返回构建好的根节点
        return root;
    }

    // 在中序遍历数组中查找指定值的索引位置
    private int findIndexRoot(int[] inorder, int inbegin, int inend, int key) {
        for (int i = inbegin; i <= inend; i++) {
            if (inorder[i] == key) {
                return i;
            }
        }
        return -1; // 没有找到，返回 -1
    }
}

根据一棵树的中序遍历与后序遍历构造二叉树

从中序遍历与后序遍历构造二叉树

解题思路：

1. 从后序遍历结果中获取到树的根节点，注意：后序遍历规则：左子树、右子树、根节点，因此应该从后往前获 取根节点
2. 在中序遍历结果中确定根节点的位置，按照该位置将中序遍历结果分为两部分
   右半部分是根节点的右子树，递归创建根节点的右子树---->注意先要还原根的右子树
   左半部分是根节点的左子树，递归创建根节点的左子树
   

1. 根节点直接拼接
2. 左边为空 && 右边为空 什么都不做
3. 左边为空 && 右边不为空 直接加一对括号
4. 左边不为空 && 右边为空

class SolutionCreateTree2 {
    public int postIndex; // 用于记录当前处理的后序遍历数组的索引位置

    public TreeNode buildTree(int[] inorder, int[] postorder) {
        postIndex = postorder.length - 1; // 初始化 postIndex 为后序遍历数组的最后一个元素的索引
        return buildTreeChilde(postorder, inorder, 0, inorder.length - 1);
    }

    private TreeNode buildTreeChilde(int[] postorder, int[] inorder, int inbegin, int inend) {
        if (inbegin > inend) {
            return null; // 如果开始位置大于结束位置，表示当前子树为空，返回 null
        }

        TreeNode root = new TreeNode(postorder[postIndex]); // 创建根节点，节点值为后序遍历数组中当前 postIndex 索引位置的值

        int rootIndex = findIndexRoot(inorder, inbegin, inend, postorder[postIndex]); // 在中序遍历数组中找到根节点的位置
        if (rootIndex == -1) {
            return null;
        }

        postIndex--; // 更新 postIndex，指向下一个需要处理的后序遍历数组的值

        // 递归构建右子树，更新当前子树在中序遍历数组中的起始位置
        root.right = buildTreeChilde(postorder, inorder, rootIndex + 1, inend);

        // 递归构建左子树，更新当前子树在中序遍历数组中的结束位置
        root.left = buildTreeChilde(postorder, inorder, inbegin, rootIndex - 1);

        return root; // 返回构建好的根节点
    }

    private int findIndexRoot(int[] inorder, int inbegin, int inend, int key) {
        for (int i = inbegin; i <= inend; i++) {
            if (inorder[i] == key) {
                return i; // 在中序遍历数组中查找指定值的索引位置
            }
        }
        return -1; // 没有找到，返回 -1
    }
}

二叉树创建字符串

根据二叉树创建字符串

public String tree2str(TreeNode root) {
    StringBuilder stringBuilder = new StringBuilder();
    tree2strChild(root,stringBuilder);
    return stringBuilder.toString();
}

private void tree2strChild(TreeNode t,StringBuilder stringBuilder) {
    if (t == null) {
        return;
    }
    stringBuilder.append(t.val);

    //判断左树
    if (t.left != null) {
        stringBuilder.append("(");
        tree2strChild(t.left,stringBuilder);
        stringBuilder.append(")");
    } else {
        if (t.right == null) {
            return;
        } else {
            stringBuilder.append("()");
        }
    }
    //判断右树
    if (t.right != null) {
        stringBuilder.append("(");
        tree2strChild(t.right,stringBuilder);
        stringBuilder.append(")");
    } else {
        return;
    }
}

二叉树前序非递归遍历实现

二叉树前序的前序遍历

解题思路：

1. 一直往左走 遇到空停止，左树走完了，弹出栈顶元素、并且打印
2. 遍历弹出节点的右子树

void preOrderNor(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;
    }

}


/**
 * 把 前序遍历的结果 存储到 ans 当中
 *
 * @param root
 * @return
 */
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                ans.add(cur.val);
                cur = cur.left;
            }
            if (!stack.isEmpty()) {
                TreeNode top = stack.pop();
                cur = top.right;
            }
        }
        return ans;
   }

二叉树中序非递归遍历实现

二叉树的中序遍历

public List<Integer> inOrderTraversal(TreeNode root){
    List<Integer> result = new ArrayList<>();
    if(root == null) {
        return result;
    }
    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();
        result.add(top.val);
        cur = top.right;
    }
    return result;
}

二叉树后序非递归遍历实现

二叉树的后序遍历

public List<Integer> postorderTraversal(TreeNode root){
    List<Integer> result = new ArrayList<>();
    if(root == null) {
        return result;
    }
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    TreeNode prev = null;
    
    while (cur != null || !stack.isEmpty()) {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
        TreeNode top = stack.peek(); //不一定打印top

        //打印top两种情况：1)右边为null 2)右边已经打印完了
        if(top.right == null || top.right == prev) {
            result.add(top.val);
            stack.pop();
            prev = top; //记录下最新被打印的那个节点
        }else {
            cur = top.right;
        }
    }
    return result;
}