102. Binary Tree Level Order Traversal

题目：

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree {3,9,20,#,#,15,7},

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

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

思路：

看到题目之后的第一思路是采用广度优先遍历逐层来遍历这棵树，使用广度优先遍历需要添加一个辅助的队列，将每层的节点依次加入到队列中。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        List<TreeNode> queue = new ArrayList<>();
        
        //在根节点非空的时候将其加入队列中
        if(root != null){queue.add(root);}
        while(!queue.isEmpty()){
            List<TreeNode> next = new ArrayList<>();
            List<Integer> numList = new ArrayList<>();
            //通过遍历队列，将每层非空节点依次加入到队列中，并将其整理到数字队列中
            for(TreeNode node : queue){
                numList.add(node.val);
                if(node.left != null){next.add(node.left);}
                if(node.right != null){next.add(node.right);}
            }
            result.add(numList);
            queue = next;
        }
        return result;
    }
}

【另一种思路】

上述思路实际上是循环的方法，树结构应该还有一种递归的方法，在看了discuss之后也写出的递归的解法：

若二叉树有n层，那么result有n个List<Integer>，因此首先先创建n个List，在递归时依次取出相应层的List，将数字插入到List中。

代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        //处理空节点的情况
        if(root == null){return result;}
        //递归处理每层的节点，若二叉树有n层，那么result有n个List<Integer>
        levelOrder(root,0,result);
        return result;
    }
    
    public void levelOrder(TreeNode root, int level, List<List<Integer>> result){
        //因为递归调用的时候没有考虑null的情况，因此需要在函数开始时判断节点是否为空
        if(root == null){return;}
        List<Integer> numList = null;
        
        /* 当result节点数和level相等时，result中的List数目还不够，则需要新创建一个空的List
         * 当result节点数超过level时，则从result从取出相应的List，将val值添加进去
        */
        if(result.size() == level){
            numList = new ArrayList<Integer>();
            result.add(numList);
        }else if(result.size() > level){
            numList = (ArrayList<Integer>)result.get(level);
        }
        numList.add(root.val);
        //递归调用左子树和右子树
        levelOrder(root.left, level+1,result);
        levelOrder(root.right, level+1,result);
    }
}