leetcode：从上到下打印二叉树 II（层次遍历DFS与BFS版）

剑指 Offer 32 - II. 从上到下打印二叉树 II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

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

看题就知道是层序遍历，模板题，BFS进行遍历即可，注意点是root为null时不是返回null,而是返回[],所以需要先new出来一个List<List<Integer>>;

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<>();
        if(root == null){
             return lists;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            for(int i=0;i<size;++i){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
            lists.add(list);
        }
        return lists;
    }
}

看了用时和内存消耗感觉还可以。平时的层次遍历一般都是使用BFS，那使用DFS有没有办法实现呢。DFS如果来模拟BFS的话，我觉得最主要的就是深度与层次的关系，如果在DFS中将同一深度的下结点从左到右保存在数组里，那么效果应该能得到和BFS一样的效果。

根据这些先写出大致的模板。

    private List<List<Integer>> level = new ArrayList<>();
    public void dfs(int depth,TreeNode root){
        if(root == null){
            return;
        }

        dfs(depth+1,root.left);
        dfs(depth+1,root.right);
        
    }

写完模板后，这时候需要考虑两个问题，一个是什么情况下new 一个 List<Integer>,第二个是什么情况下某一层的List<Integer>会增加元素。

看图能看出来的是，如果depth > level.size 的时候，也就是depth更深一层的时候，这时候需要先new List<Integer>，再进行增加元素，其他情况下可以直接add val

注意点：depth与下标相差了1.

在上面分析的基础上完善代码

public void dfs(int depth,TreeNode root){
    if(root == null){
        return;
    }
    if( depth > level.size()){
        level.add(new ArrayList<>());
    }
    level.get(depth-1).add(root.val);
    
    dfs(depth+1,root.left);
    dfs(depth+1,root.right);
}

完整代码为

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

        dfs(depth+1,root.left);
        dfs(depth+1,root.right);
    }
}

good！