Binary Tree Level Order Traversal 分层遍历二叉树@LeetCode

package Level3;

/**
 * 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]
]
confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.


OJ's Binary Tree Serialization:
The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:
   1
  / \
 2   3
    /
   4
    \
     5
The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}".
 */
import java.util.ArrayList;
import java.util.LinkedList;

import Utility.TreeNode;

public class S102 {

	public static void main(String[] args) {
//		TreeNode root = new TreeNode(1);
//		TreeNode n1 = new TreeNode(2);
//		TreeNode n2 = new TreeNode(3);
//		TreeNode n3 = new TreeNode(4);
//		TreeNode n4 = new TreeNode(5);
//		root.left = n1;
//		root.right = n2;
//		n1.left = n3;
//		n1.right = n4;
		
		// {1,2,3,4,#,#,5}
		TreeNode root = new TreeNode(1);
		TreeNode n1 = new TreeNode(2);
		TreeNode n2 = new TreeNode(3);
		TreeNode n3 = new TreeNode(4);
		TreeNode n4 = new TreeNode(5);
		root.left = n1;
		root.right = n2;
		n1.left = n3;
		n2.right = n4;
		System.out.println(levelOrder(root));
//		System.out.println(levelOrder(null));
	}
	
	public static ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
		
		ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
		if(root == null){
			return ret;
		}
		
		// 用一个queue来保存节点
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        
        
        int oldCnt = 1;		// 本层的节点数
        int newCnt = 1;		// 下一层的节点数
        ArrayList<Integer> level = new ArrayList<Integer>();
        
        while( !queue.isEmpty() ){
        	oldCnt = newCnt;		// 保存本层的节点数
        	newCnt = 0;			// 重新计算新层的节点数
        	for(int i=0; i<oldCnt; i++){	// 把本层节点数加入到一个新的level ArrayList中
        		TreeNode n = queue.removeFirst();		// 移除队列头元素
        		if(n.left != null){		// 添加队列头元素的左子root
            		queue.add(n.left);// 加入到队尾
            		newCnt++;			// 增加新层节点数
            	}
            	if(n.right != null){	// 添加队列头元素的右子root
            		queue.add(n.right);// 加入到队尾
            		newCnt++;			// 增加新层节点数
            	}
        		level.add(n.val);		// 添加当前被移除的队列头元素到level ArrayList中
        	}
        	
        	ret.add(new ArrayList<Integer>(level));	// 复制添加当前层到ret
    		level = new ArrayList<Integer>();			// 重建level
        }
        return ret;
    }

}

Second try：

public static ArrayList<ArrayList<Integer>> levelOrder(TreeNode root){
		ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
		if(root == null){
			return ret;
		}
		
		LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
		queue.add(root);
		
		int currentLevelNodes = 1;
		int nextLevelNodes = 0;
		ArrayList<Integer> level = new ArrayList<Integer>();
		
		while(!queue.isEmpty()){
			TreeNode cur = queue.remove();
			currentLevelNodes--;
			
//			System.out.print(cur.val + " ");
			level.add(cur.val);
			if(cur.left != null){
				queue.add(cur.left);
				nextLevelNodes++;
			}
			if(cur.right != null){
				queue.add(cur.right);
				nextLevelNodes++;
			}
			
			if(currentLevelNodes == 0){
				currentLevelNodes = nextLevelNodes;
				nextLevelNodes = 0;
//				System.out.println();
				ret.add(new ArrayList<Integer>(level));
				level = new ArrayList<Integer>();
			}
		}
		
		return ret;
	}

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
        if(root == null){
            return ret;
        }
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        int curLevCnt = 1;
        int nextLevCnt = 0;
        ArrayList<Integer> al = new ArrayList<Integer>();
        while(!queue.isEmpty()){
            TreeNode cur = queue.remove();
            curLevCnt--;
            al.add(cur.val);
            if(cur.left != null){
                queue.add(cur.left);
                nextLevCnt++;
            }
            if(cur.right != null){
                queue.add(cur.right);
                nextLevCnt++;
            }
            
            if(curLevCnt == 0){
                curLevCnt = nextLevCnt;
                nextLevCnt = 0;
                ret.add(al);
                al = new ArrayList<Integer>();
            }
        }
        return ret;
    }
}