Binary Tree Level Order Traversal，层序遍历二叉树，每层作为list，最后返回List<list>

问题描述：

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,null,null,15,7],

    3
   / 
  9  20
    /  
   15   7

return its level order traversal as:

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

 算法分析：三种方法。这道题和普通的层序遍历不一样的地方就是，需要每层单独输出。因此可以考虑用来两个队列，每个队列存放不同层的节点。我自己写的代码有重复的结构，并不友好。参考网上，其实将第二个队列赋值给第一个队列就行，就不会有重复代码了。也无需考虑队列空的情况了。第三种方法其实就是按层遍历的一种思想，是第二种方法的优化。

public class BinaryTreeLevelOrderTraversal 
{
	public List<List<Integer>> levelOrder(TreeNode root)
	{
		List<List<Integer>> res = new ArrayList<>();
		if(root == null)
		{
			return res;
		}
		Deque<TreeNode> queue1 = new ArrayDeque<>();
		Deque<TreeNode> queue2 = new ArrayDeque<>();
		queue1.offer(root);
		while(!queue1.isEmpty() || !queue2.isEmpty())
		{
			List<Integer> list1 = new ArrayList<>();
			while(!queue1.isEmpty())
			{
				TreeNode temp = queue1.poll();
				if(temp.left != null)
				{
					queue2.offer(temp.left);
				}
				if(temp.right != null)
				{
					queue2.offer(temp.right);
				}
				list1.add(temp.val);
			}
			if(list1.size() != 0)//队列空的时候，list1的大小为0
			res.add(list1);
			List<Integer> list2 = new ArrayList<>();
			while(!queue2.isEmpty())
			{
				TreeNode temp = queue2.poll();
				if(temp.left != null)
				{
					queue1.offer(temp.left);
				}
				if(temp.right != null)
				{
					queue1.offer(temp.right);
				}
				list2.add(temp.val);
			}
			if(list2.size() != 0)
			res.add(list2);
		}
		
		return res;
	}
	
	public List<List<Integer>> levelOrder2(TreeNode root)
	{
		List<List<Integer>> res = new ArrayList<>();
		List<Integer> list = new ArrayList<>();
		if(root == null)
		{
			return res;
		}
		
		ArrayDeque<TreeNode> curr = new ArrayDeque<>();
		ArrayDeque<TreeNode> next = new ArrayDeque<>();
		
		curr.offer(root);
		
		while(!curr.isEmpty())
		{
			TreeNode temp = curr.poll();
			if(temp.left != null)
			{
				next.offer(temp.left);
			}
			if(temp.right != null)
			{
				next.offer(temp.right);
			}
			
			list.add(temp.val);
			
			if(curr.isEmpty())
			{
				res.add(list);
				list = new ArrayList<Integer>();
				curr = next;
				next = new ArrayDeque<>();
			}
		}
		
		return res;
	}
	
	
	public List<List<Integer>> levelOrder3(TreeNode root)
	{
		List<List<Integer>> res = new ArrayList<>();
		
		if(root == null)
		{
			return res;
		}
		ArrayList<TreeNode> arr = new ArrayList<>();
		arr.add(root);
		while(!arr.isEmpty())
		{
			List<Integer> list = new ArrayList<>();
			ArrayList<TreeNode> temp = new ArrayList<>();
			for (TreeNode node : arr) 
			{
				list.add(node.val);
				if(node.left != null)
				{
					temp.add(node.left);
				}
				if(node.right != null)
				{
					temp.add(node.right);
				}
			}
			res.add(list);
			arr = temp;
		}
		
		return res;
	}
	
	
	public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        
        Deque<TreeNode> curr = new ArrayDeque<>();
        Deque<TreeNode> next = new ArrayDeque<>();
        
        if(root == null)
        {
            return res;
        }
        
        curr.offer(root);
        while(! curr.isEmpty())
        {
            TreeNode temp = curr.poll();
            
            if(temp.left != null)
            {
                next.offer(temp.left);
            }
            if(temp.right != null)
            {
                next.offer(temp.right);
            }
            
            list.add(temp.val);
            
            if(curr.isEmpty())
            {
                res.add(list);
                list = new ArrayList<>();
                curr = next;
                next = new ArrayDeque<>();
            }
        }
        
        List<List<Integer>> reverseRes = new ArrayList<>();
        for(int i = res.size()-1; i >= 0; i --)
        {
            reverseRes.add(res.get(i));
        }
        return reverseRes;
    }
}