Leetcode題目102.二叉樹的層次遍歷（隊列-中等）

題目描述：

給定一個二叉樹，返回其按層次遍歷的節點值。 （即逐層地，從左到右訪問全部節點）。

例如:
給定二叉樹: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其層次遍歷結果：

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

思路分析：

1.LinkedList做爲隊列迭代實現

2.遞歸

代碼實現：

1、迭代（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;
    }
}

2、遞歸

/**
 * 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 個節點的值。