Leetcode题目102.二叉树的层次遍历（队列-中等）

题目描述：

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

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

    3
   / 
  9  20
    /  
   15   7
返回其层次遍历结果：

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

思路分析：

1.LinkedList作为队列迭代实现

2.递归

代码实现：

一、迭代（LinkedList）,队列作为辅助数据结构实现二叉树的层次遍历

【注意】：Java LinkedList add 是加在list尾部.LinkedList push 施加在list头部.等同于addFirst.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public static List<List<Integer>> levelOrder(TreeNode root) {

        //迭代
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        while (!deque.isEmpty()) {

            List<Integer> tmp = new ArrayList<>();
            int count = deque.size();
            for (int i = 0; i < count; i++) {
                TreeNode pNode = deque.poll();
                tmp.add(pNode.val);
                if (pNode.left != null) {
                    deque.add(pNode.left);
                }
                if (pNode.right != null) {
                    deque.add(pNode.right);
                }
            }
            res.add(tmp);
        }
        return res;
    }
}

二、递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
     public static List<List<Integer>> levelOrder(TreeNode root) {

        /**
         * 递归：
         * 1.递归出口：root==null
         * 2.递归方程:traverse(res,node,index)
         */
        List<List<Integer>> res = new ArrayList<>();
        //表示：从第一层开始遍历，index不断递增进行递归遍历
        traverse(res, root, 0);
        return res;
    }

    private static void traverse(List<List<Integer>> res, TreeNode root, int depth) {

        if (root == null) {
            return;
        }

        //当上一层遍历完成，转至下一层时，新增一个空的List集合，因为在下面的res.get(depth)可以拿到
        //这个空的list，将下一层的节点加入集合中（非常巧妙的一点）
        if (depth == res.size()) {
            res.add(new ArrayList<>());
        }

        //比较巧妙的一点，res中的List集合的索引代表某节点属于哪一层
        res.get(depth).add(root.val);
        //递归遍历左子树
        traverse(res, root.left, depth + 1);
        //递归遍历右子树
        traverse(res, root.right, depth + 1);
    }
}

• 时间复杂度：O(N)，因为每个节点恰好会被运算一次。
• 空间复杂度：O(N)，保存输出结果的数组包含 N 个节点的值。