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

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

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

例如:

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

    3
   / \
  9   20
     / \
    15  7

返回其层次遍历结果：

[

[3],

[9,20],

[15,7]

]

提示：

节点总数 <= 1000

一、遍历（BFS）

本题首先要设置一个队列queue，一个list，一个临时列表。

算法流程大概如下：

首先把头结点放入queue，然后再把头结点放入tmp，最后放入list。

然后把左/右节点依次放入队列，再放入tmp，最后再放入list。

大概的思路，就是tmp作为辅助列表，作为队列queue和list的桥梁。

然后什么叫BFS，得解释一下，是二叉数的广度优先搜索的意思。

class Solution {
        public List<List<Integer>> levelOrder(TreeNode root) {
            Deque<TreeNode> queue = new LinkedList<>();
            List<List<Integer>> res = new ArrayList<>();
            //如果头节点不为空，则放入队列queue
            if (root != null) queue.add(root);
            while (!queue.isEmpty()) {
            	//设置一个辅助数组，专门装队列queue的值
                List<Integer> tmp = new ArrayList<>();
                for (int i = queue.size(); i > 0; i--) {
                    TreeNode node = queue.poll();
                    tmp.add(node.val);
                    if (node.left != null) queue.add(node.left);
                    if (node.right != null) queue.add(node.right);
                }
                res.add(tmp);
            }
            return res;
        }
    }

二、递归

class Solution {
        List<List<Integer>> res;
        public List<List<Integer>> levelOrder(TreeNode root) {
            res = new ArrayList<>();
            dfs(0, root);
            return res;
        }

        void dfs(int depth,TreeNode root) {
            if (root == null) return;
            if (depth == res.size()) {//如果数组list的size等于数组里面depth的话，则创建新的一层节点
                res.add(new ArrayList<>());
            }
            //因为dfs(0,root) 所以这个时候是res.get(0).add(root.val)，是放入这个数组中第一个数组的头节点
            res.get(depth).add(root.val);
            //递归遍历左右节点
            dfs(depth + 1, root.left);
            dfs(depth + 1, root.right);
        }
    }