二叉树 广度遍历 深度遍历 前序 中序 后序

1 二叉树

基本概念

深度（高度）

节点深度 = 当前节点的层数

直径

二叉树直径长度=树中任意两节点最短路径的最大值

路径长度

两节点路径长度= 它们之间边的数目

先序

先序 根一次
访问到就输出
一直到左节点为null，中间遇到根节点就输出，并且入栈
左节点为null时，弹出节点，并指向右节点

先序：考察到一个节点后，即刻输出该节点的值，并继续遍历其左右子树。(根左右)

中序

中序 根二次
访问到不输出，一直访问到左节点为null时
才弹出根节点，输出根节点
指向右节点

中序：考察到一个节点后，将其暂存，遍历完左子树后，再输出该节点的值，然后遍历右子树。(左根右)

后序

后序 根三次

后序：考察到一个节点后，将其暂存，遍历完左右子树后，再输出该节点的值。(左右根)

注意

后序和上面不太一样
后序输出节点需要考虑当前节点左右节点都已经输出了，所以需要一个指针lastVisit指向右节点，如果lastVisit 等于当前树到右子树，代表当前节点左右子树都已经输出完毕，可以输出当前节点
否则 node = node.right

1 简单

1 111. 二叉树最小深度
2 144. 二叉树前序遍历
3 94. 二叉树的中序遍历
4 145. 二叉树的后序遍历
5 257. 二叉树的所有路径
6 112. 路径总和
7 637. 二叉树的层平均值
9 226. 翻转二叉树
剑指 Offer 27. 二叉树的镜像
10 617. 合并二叉树
11 404.左叶子之和
12 235. 二叉搜索树的最近公共祖先
13 257. 二叉树的所有路径
15 501. 二叉搜索树中的众数
16 530. 二叉搜索树的最小绝对差
17 543. 二叉树的直径

18 606. 根据二叉树创建字符串
19 110. 平衡二叉树
20 572. 另一棵树的子树

递归

三要素

1. 子问题与原问题做同样的事
2. 需要有一个让递归结束的条件
3. 递归表达式

1 广度优先遍历

比价好的广度深度讲解
解题思路？队列先进先出

层序遍历借助队列实现 
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int ans = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                size--;
            }
            ans++;
        }
        return ans;
    }
}

112 双队列 一个存储当前节点 一个存储到目前节点的计算sum值
637 每一层累加而已
226 翻转？ 层序遍历翻转 层层翻而已
235 注意是二叉搜索树 有序 257 
    1递归？
    递归接发的话注意终止条件，以及通用过程即
    2迭代？队列 
    深度 栈
606  官网解析
        前序遍历迭代版本
572 这也算easy?
    官方题解涵盖KMP
     Rabin-Karp 
     树哈希

2 深度优先遍历

迭代使用 栈通用模式

前序
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                //前序
                res.add(root.val);
                stk.push(root);
                root = root.left;
            }
            root = stk.pop();
            root = root.right;
        }
        return res;
    }
}
中序
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
            root = stk.pop();
            //中序
            res.add(root.val);
            root = root.right;
        }
        return res;
    }
}
后序
// 非递归后序遍历
public static void postorderTraversal(TreeNode root) {
    Stack<TreeNode> treeNodeStack = new Stack<TreeNode>();
    TreeNode node = root;
    TreeNode lastVisit = root;
    while (node != null || !treeNodeStack.isEmpty()) {
        while (node != null) {
            treeNodeStack.push(node);
            node = node.left;
        }
        //查看当前栈顶元素
        node = treeNodeStack.peek();
        //如果其右子树也为空，或者右子树已经访问
        //则可以直接输出当前节点的值
        if (node.right == null || node.right == lastVisit) {
            System.out.print(node.val + " ");
            treeNodeStack.pop();
            lastVisit = node;
            node = null;
        } else {
            //否则，继续遍历右子树
            node = node.right;
        }
    }
}

111 最小深度 解题思路？
    1递归 左右子树最小值
    2 迭代？手动维护一个栈 先进后出

144 前序遍历 解题思路？
    1 递归 没什么意思
    2 迭代 中 左 右 
99  中序遍历 和144 一个套路
145 后序遍历 不太一样 增加了是否访问过右子树
257 所有路径 这也算是简单的类型啊？崩溃呀
15 众数  中序遍历有序+外部存储
543 直径？
    1 深度 当前节点的层数
    2 

235 三种题解方式

深度优先遍历 递归
深度优先遍历 迭代
广度优先遍历

参考
二叉树三种遍历 简书