leetcode3: 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 binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > levelOrder(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        queue<TreeNode*> * cur_queue, * next_queue;
        cur_queue = new queue<TreeNode* >();
        next_queue = new queue<TreeNode* >();
        
        cur_queue->push(root);
        
        vector< vector<int> > rel;
        if(!root) return rel;
        
        vector<int> temp;
        
        while(! cur_queue->empty() ) {
            TreeNode * tmp = cur_queue->front();
            
            if( tmp->left ) {
                next_queue->push( tmp->left);
            }
            
            if(tmp->right) {
                next_queue->push( tmp->right);
            }
            
            temp.push_back( tmp->val );
            cur_queue->pop();
            
            if( cur_queue->empty()) {
                rel.push_back( temp );
                temp.clear();
                swap(cur_queue, next_queue);
            }
            
        }
        delete cur_queue, next_queue;
        
        return rel;
    }
};

/**
 * 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) {
        // Start typing your Java solution below
        // DO NOT write main() function
        ArrayList<ArrayList<Integer> > rel = new ArrayList<ArrayList<Integer>>();
        if( root==null) return rel;
        
        Queue<TreeNode> q1 = new LinkedList<TreeNode>();
        Queue<TreeNode> q2 = new LinkedList<TreeNode>();
        q1.add(root);
        
        TreeNode tn;
        ArrayList<Integer> ta = new ArrayList<Integer>();
        while(q1.peek()!=null) {
                tn = q1.remove();             
                ta.add(tn.val);
                if(tn.left!=null) q2.add(tn.left);
                if(tn.right!=null) q2.add(tn.right);
            
            if(q1.peek()==null) {
                rel.add(ta);
                ta = new ArrayList<Integer>(); //wrong ta.clear(). it actually clear the content in heap. so element in container is also cleaned up.
                  Queue<TreeNode> qTemp = q1;
                q1 = q2;
                q2 = qTemp;
            }
        }
        return rel;       
    }
}

with only one queue. we use 2 integer to track the number of nodes in every level.

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    
// null, {1}, {1,2,3}, {1, #, 3, 4}    
    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        
        //input check;
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if(root==null) return res;
        
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer( root );
        int first = 1;
        int second = 0;
        
        ArrayList<Integer> level = new ArrayList<Integer>();
        while(!queue.isEmpty() ) {
            TreeNode x = queue.poll();
            --first;
            level.add(x.val);
            if(x.left!=null) {
                queue.offer(x.left);
                ++second;
            }
            if(x.right!=null){
                queue.offer(x.right);
                ++second;
            }
            
            if(first==0) {
                res.add( level);
                level = new ArrayList<Integer>();
                first = second;
                second = 0;
            }
        }
        
        return res;
    }
}