算法总结 - 树 - 遍历 - 常见算法题类型

Traversal(遍历)

1. 基本层级遍历

102. Binary Tree Level Order Traversal
Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

非常朴实的层级遍历，之后的题型都由此演化而来。
直观的想法是利用queue做BFS。

public List<List<Integer>> levelOrder(TreeNode root) {
   
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) return res;
    
    Deque<TreeNode> que = new ArrayDeque<>();
    que.offer(root);
    
    while(!que.isEmpty()){
   
        int size = que.size();
        List<Integer> list = new ArrayList<>();
        for (int i= 0; i < size; i++){
   
            TreeNode cur = que.poll();
            list.add(cur.val);
            if (cur.left != null) que.offer(cur.left);
            if (cur.right != null) que.offer(cur.right);
        }
        res.add(list);
    }
    return res;
}

当然，如果要使用DFS也可以，但是得引入一个变量来存当前节点该塞到哪一层。
题外话，如果一个题可以既用BFS和DFS解，最好把两种算法都吃透。我遇到过面试的时候，口头表述的是DFS解法，但是面试官故意让用BFS实现的情况。

class Solution {
   
    public List<List<Integer>> levelOrder(TreeNode root) {
   
        List<List<Integer>> res = new ArrayList<>();
        dfs(root, res, 0);
        return res;
    }
    
    public void dfs(TreeNode root, List<List<Integer>> res, int depth){
   
        if(root == null) return;
        if(res.size() == depth){
   
            res.add(new ArrayList<Integer>());
        }
        res.get(depth).add(root.val);
        dfs(root.left, res, depth+1);
        dfs(root.right, res, depth+1);
    }
}

相似题型
429. N-ary Tree Level Order Traversal

---

2.改变层级遍历顺序

107. Binary Tree Level Order Traversal II
Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its bottom-up level order traversal as:

[
  [15,7],
  [9,20],
  [3]
]

也就是倒序输出每层，可以用stack或者list的add（0,元素）实现。
TC: O(n), SC: O(n)

//BFS
public List<List<Integer>> levelOrderBottom(TreeNode root) {
   
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    List<List<Integer>> wrapList = new LinkedList<List<Integer>>();
    
    if(root == null) return wrapList;
    
    queue.offer(root<