leetcode+二叉树+二叉树的层次遍历

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

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

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

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

方法一：递归

思路：

1. 比较访问节点所在层次level和当前最高层次len(levels)判定是否需要添加一个空列表
2. 当前节点插入对应层的列表levels[level]
3. 递归非空的孩子节点helper(node.left/node.right,level+1)

时间复杂度：O(N)，每个节点会被访问一次

空间复杂度：O(N)，输出结果包含N个节点的值

	List<List<Integer>> levels=new ArrayList<List<Integer>>();
	public void helper(TreeNode node,int level) {
		// start the current level
		if(levels.size()==level)
			levels.add(new ArrayList<Integer>());
				
		// fulfill the current level
		levels.get(level).add(node.val);
		
		// process child nodes for the next level
		if(node.left!=null)
			helper(node.left,level+1);
		if(node.right!=null)
			helper(node.right,level+1);
	}
	public List<List<Integer>> levelOrder(TreeNode root){
		if(root==null) return levels;
		helper(root,0);
		return levels;
	}

leetcode的结果：

方法二：迭代，广度优先遍历

1. 初始化队列只包含一个节点root和层次编号0(level=0)
2. 队列非空，进入循环

• levels中插入一个空列表，对当前层进行处理
• 当前层的元素数：队列长度
• 将元素一次弹出，加入levels当前层的空列表
• 孩子节点作为下一层入队
• 进入下一层level++

时间复杂度：O(N)，每个节点会被访问一次

空间复杂度：O(N)，输出结果包含N个节点的值，且多了一个队列的空间

	public List<List<Integer>> levelOrder1(TreeNode root){
		List<List<Integer>> levels =new ArrayList<List<Integer>>();
		if(root==null) return levels;
		
		Queue<TreeNode> queue=new LinkedList<TreeNode>();
		queue.add(root);
		int level=0;
		while(!queue.isEmpty()) {
			// start the current level
			levels.add(new ArrayList<Integer>());
			
			// number of elements in the current level
			int level_length=queue.size();
			for (int i=0;i<level_length;++i) {
				TreeNode cur=queue.remove();
			
				// fulfill the current level
				levels.get(level).add(cur.val);
			
				// add child nodes of the current level
				// in the queue for the next level
				if (cur.left!=null)  queue.add(cur.left);
				if (cur.right!=null)  queue.add(cur.right);
				
			}
			
			// go to next level
			level+=1;
		}
		return levels;
	}
	

方法二用时3ms，方法一2ms，递归优于迭代