剑指offer32-II：从上到下打印二叉树

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

当看到这个题目，我的第一反应是递归。

第二反应就是BFS。

也就是DFS和BFS。

DFS需要保存树的深度信息，BFS使用队列来完成。

// 二叉树信息
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

DFS：

​ 每一层都查看该层是否已经创建过数组，创建过则加入到数组中，否则创建数组并且将当前节点的值加入到数组中。

void Print2(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();

        if (pRoot != null) {
            putInList2(pRoot, res, 1);
        }

        return res;
}

void putInList2(TreeNode node, ArrayList<ArrayList<Integer>> res, int depth) {
        if (node == null) {
            return ;
        }

        if (depth > res.size()) {
            res.add(new ArrayList<>());
        }

        res.get(depth - 1).add(node.val);

        putInList2(node.left, res, depth + 1);
        putInList2(node.right, res, depth + 1);
}

BFS：

​ 将每一层的元素都放入队列，每次统计队列元素，将当前队列上一层遍历完毕，再遍历下一层。

void Print3(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();

        ArrayDeque<TreeNode> deque = new ArrayDeque<>();

        if (pRoot != null) {
            deque.add(pRoot);

            putInList3(deque, res);
        }

        return res;
    }

void putInList3(ArrayDeque<TreeNode> deque, ArrayList<ArrayList<Integer>> res) {
        while (!deque.isEmpty()) {
            int size = deque.size();
            ArrayList<Integer> arrayList = new ArrayList<>(size);

            while (size-- > 0) {
                TreeNode node = deque.removeFirst();

                arrayList.add(node.val);

                if (Objects.nonNull(node.left)) {
                    deque.add(node.left);
                }

                if (Objects.nonNull(node.right)) {
                    deque.add(node.right);
                }
            }

            res.add(arrayList);
        }
    }