<LeetCode OJ> 102. / 107. Binary Tree Level Order Traversal(I / II)

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.

分析：

题目的意思是每一层均按照从左到右的顺序遍历节点，并记录节点到vector中。

显然广度优先搜索，用队列。利用两个队列保存当层的节点与下一层的节点，下一层的元素处理完后，下一层成为当层（继续获取下一层的节点），具体看代码便知！本代码一次性AC，看来我还是有所成长！

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //从curque中获取他下一层的节点，放到nextque中，并且清空curque
    bool nextLevelNode(queue<TreeNode*> &curQue,queue<TreeNode*> &nextQue)
    {
        if(curQue.empty())
            return false;
        TreeNode* curNode=NULL;    
        while(!curQue.empty())
        {
            curNode=curQue.front();
            if(curNode->left!=NULL)
               nextQue.push(curNode->left);  
            if(curNode->right!=NULL)
               nextQue.push(curNode->right);   
            curQue.pop();//删除队首元素  
        }
        return !nextQue.empty();
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector< vector<int> > result;
        if(root==NULL)
            return result;
        queue<TreeNode*> que1,que2;
        //一，获取最顶层的根
        vector<int> firstlevel;
        firstlevel.push_back(root->val);
        result.push_back(firstlevel);
        
        que1.push(root);
        //二，获取每一层的节点
        TreeNode* curNode=NULL; 
        while(nextLevelNode(que1,que2))
        {
            vector<int> curlevel;
            que1=que2;
            while(!que2.empty())//获取当层的节点
            {
                curNode=que2.front();
                curlevel.push_back(curNode->val);
                que2.pop();
            }
            result.push_back(curlevel);
        }
        return result;
    }
};

学习别人的解法：

class Solution {
public:
    
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector< vector<int> > result;
        if(root==NULL)
            return result;
        queue<TreeNode*> que;//用来总是保存当层的节点
        que.push(root);
        
        //获取每一层的节点
        while(!que.empty())
        {
            int levelNum = que.size();//通过size来判断当层的结束
            vector<int> curlevel;
            for(int i=0; i<levelNum; i++) 
            {
                if(que.front()->left != NULL) //先获取该节点下一层的左右子，再获取该节点的元素，因为一旦压入必弹出，所以先处理左右子
                    que.push(que.front()->left);
                if(que.front()->right != NULL) 
                    que.push(que.front()->right);
                    
                curlevel.push_back(que.front()->val);
                que.pop();
            }
            result.push_back(curlevel);
        }
        return result;
    }
};

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree {3,9,20,#,#,15,7},

    3
   / \
  9  20
    /  \
   15   7

return its bottom-up level order traversal as:

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

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

分析：

道理是一样的，不过就是插入vector的顺序逆着来而已，不过这样做似乎没有达到考察的目的！

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector< vector<int> > result;  
        if(root==NULL)  
            return result;  
        queue<TreeNode*> que;//用来总是保存当层的节点  
        que.push(root);  
          
        //获取每一层的节点  
        while(!que.empty())  
        {  
            int levelNum = que.size();//通过size来判断当层的结束  
            vector<int> curlevel;  
            for(int i=0; i<levelNum; i++)   
            {  
                if(que.front()->left != NULL) //先获取该节点下一层的左右子，再获取该节点的元素，因为一旦压入必弹出，所以先处理左右子  
                    que.push(que.front()->left);  
                if(que.front()->right != NULL)   
                    que.push(que.front()->right);  
                      
                curlevel.push_back(que.front()->val);  
                que.pop();  
            }  
            result.insert(result.begin(),curlevel);  //与上面问题的区别就在这里，仅此而已。
        }  
        return result; 
    }
};

注：本博文为EbowTang原创，后续可能继续更新本文。如果转载，请务必复制本条信息！

原文地址：http://blog.csdn.net/ebowtang/article/details/50719417

原作者博客：http://blog.csdn.net/ebowtang