Binary Tree Level Order Traversal

来源：互联网发布：淘宝摄影市场编辑：程序博客网时间：2024/04/30 11:57

题目：

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()); 也可