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]
]

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}".

 

思路一：两个Queue相互交换访问Level和Level+1层节点

对于每一层level 的 Node ，我们用一个queue<TreeNode *>存储起来，这样可以满足遍历顺序。

在访问level层时，每pop出一个TreeNode节点，先访问value域，然后将其左右儿子节点 存入 一个新的队列中，作为 level+1 的层节点。

最简单的是用一个 vector<queue<TreeNode *> > mylevel; 来存储，每生成一层，就push_back 进mylevel 中。但是这样会出现内存空间不足。

而且这样的代码将会是一团糟。所以千万不要考虑这样的数据结构来存储。

Holy shit！代码就不贴出来了。

因为在 vector<queue<TreeNode *> > mylevel; 这块浪费了很多的内存，其实我们用两个queue互相交换， 就可以满足level要求。

其中 while(!nextqueue.empty()) nextqueue.pop();   表示对queue进行clear操作。

 

class Solution {
public:
    vector<vector<int> > levelOrder(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        vector<vector<int> >  result;  
        if(!root) 
            return result; 
        
        queue<TreeNode *> curqueue, nextqueue;
        TreeNode * ptr;                 
        vector<int> tmpvector;    
             
        nextqueue.push(root);           
        while(true)
        {   
            tmpvector.clear();
            curqueue = nextqueue;
            while(!nextqueue.empty()) nextqueue.pop();  
            while(!curqueue.empty())            
            {
                ptr = curqueue.front();
                curqueue.pop();                
                tmpvector.push_back(ptr->val);
                if(ptr->left!=NULL)
                    nextqueue.push(ptr->left);
                if(ptr->right!=NULL)
                    nextqueue.push(ptr->right);
            }
            if(tmpvector.size()>0)
                result.push_back(tmpvector);   
            else 
                break; 
        }      
    }
};

Judg Large：

Run Status: Accepted!
Program Runtime: 32 milli secs

思路二：使用单个Queue来访问Level和Level+1层

可知我们可用一个queuel来储存。

这里我们要对存储在同一个queue中的 level 和 level+1 的节点进行区分，可以考虑设置一个flag节点进行区分（比如空节点，如果当前节点是空节点，而且当前queue为非空，表示进行到level+1层或level层，换层）。

 

/**
 * 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   
          
        vector<vector<int> >  result;    
        if(!root)   
            return result;   
          
        queue<TreeNode *> curqueue;  
        TreeNode * ptr;                   
        vector<int> tmpvector;      
               
        curqueue.push(root);
        curqueue.push((TreeNode *)NULL);             
        while(true)  
        {     
            tmpvector.clear();  
            while(curqueue.front()!=NULL)              
            {  
                ptr = curqueue.front();  
                curqueue.pop();                  
                tmpvector.push_back(ptr->val);  
                if(ptr->left!=NULL)  
                    curqueue.push(ptr->left);  
                if(ptr->right!=NULL)  
                    curqueue.push(ptr->right);  
            }
            if(tmpvector.size()>0 && curqueue.front()==NULL)
            {
                result.push_back(tmpvector);  
                curqueue.pop();  
                curqueue.push((TreeNode *)NULL);  
            }  
            else   
                break;   
        }        
    }  
};  

Judg Large:

Run Status: Accepted!
Program Runtime: 28 milli secs

运行效果更好。
千万不要忘了在每生成一层时，要加上 curqueue.push((TreeNode *)NULL); 作为层之间的间隔。

我们也可将其用一个 while 循环来实现该代码

class Solution {    
public:    
    vector<vector<int> > levelOrder(TreeNode *root) {    
        // Start typing your C/C++ solution below      
        // DO NOT write int main() function      
            
        vector<vector<int> >  result;      
        if(!root)     
            return result;     
            
        queue<TreeNode *> curqueue;    
        TreeNode * ptr;                     
        vector<int> tmpvector;        
                 
        curqueue.push(root);  
        curqueue.push((TreeNode *)NULL);               
        while(!curqueue.empty())    
        {
            ptr = curqueue.front();
            curqueue.pop();  
            if( ptr==NULL )
            {   
                if(tmpvector.size()>0)
                {
                    result.push_back(tmpvector); 
                    tmpvector.clear();
                    curqueue.push((TreeNode *)NULL);
                 } 
                continue;   
            }                            
            tmpvector.push_back(ptr->val);    
            if(ptr->left!=NULL)    
                curqueue.push(ptr->left);    
            if(ptr->right!=NULL)    
                curqueue.push(ptr->right); 
        }                     
    }    
};    

其中，如果将其中的判断部分代码，改成如下：

            if( ptr==NULL && tmpvector.size()>0)
            {
                result.push_back(tmpvector);
                tmpvector.clear();
                curqueue.push((TreeNode *)NULL);
                continue;  
            }

将会形成死循环，无法退出程序。因为在最后一个 NULL指针时，无法进入该循环。

 

思路三：用一个Queue<pair<TreeNode*, int>> 同时存储节点和层信息

对于每一个节点，我们都附带一个level信息，即用pair来存储，以此来区分不同的层节点。

class Solution {  
public:  
    vector<vector<int> > levelOrder(TreeNode *root) {  
        // Start typing your C/C++ solution below   
        // DO NOT write int main() function   
          
        vector<vector<int> >  result;    
        if(!root)   
            return result;   
          
        queue<pair<TreeNode *,int > > curqueue;  
        TreeNode * ptr;                   
        vector<int> tmpvector;      
        int level=0;
        curqueue.push(make_pair(root,level));        
        while(!curqueue.empty())  
        {   
            ptr = curqueue.front().first; 
            int lev = curqueue.front().second;
            if(lev!=level && tmpvector.size()>0)
            {
                result.push_back(tmpvector);  
                level = level+1;
                tmpvector.clear();   
            }   
            curqueue.pop();   
            tmpvector.push_back(ptr->val);  
            if(ptr->left!=NULL)  
                curqueue.push(make_pair(ptr->left,level+1));  
            if(ptr->right!=NULL)  
                curqueue.push(make_pair(ptr->right,level+1));  
        }      
        result.push_back(tmpvector);  
    }  
};  

Judg Large:

Run Status: Accepted!
Program Runtime: 28 milli secs

此时我们只需要一层循环即可，但是要注意在最后一层是要加上 result.push_back(tmpvector); 因为我们在遍历queue中的最后一层时，无法进入

if(lev!=level && tmpvector.size()>0)

{ result.push_back(tmpvector);

 level = level+1;

tmpvector.clear();

 }

此语句中，因为 lev!=level 不满足，无法执行 push_back，故要在最后一行加上。

 

Binary Tree Level Order Traversal II

加上语句：

        vector<vector<int> >  myres;
        for(int i=result.size()-1;i>=0;i--)
            myres.push_back(result[i]);
        return myres;

即可实现 Binary Tree Level Order Traversal II 里面的从底向上输出。

 或者 reverse(result.begin(), result.end());  也可