Binary Tree Level Order Traversal I II(102、107)

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

思路

层次遍历+简单动归
关键是需要记录当前层有多少个结点。所以需要两个计数器 curcount当前结点数、nextcount下一层结点数。
在遍历当前层的同时统计一下层的结点数。

代码

/**
 * 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>> levelOrder(TreeNode* root) {
        vector<vector<int>> vvi;
        if(root==NULL) return vvi;
        queue<TreeNode*> que;
        TreeNode* p=root;
        que.push(p);
        int curcount=1;//当前层结点数
        int nextcount=0;//下一层结点数
        vector<int> vi;
        while(!que.empty()){
            p=que.front();
            que.pop();
            vi.push_back(p->val);
            --curcount;
            if(p->left){
                ++nextcount;
                que.push(p->left);
            }
            if(p->right){
                ++nextcount;
                que.push(p->right);
            }
            if(curcount==0){//当前层最后一个结点，下次循环进入下一层
                vvi.push_back(vi);
                vi.clear();
                curcount=nextcount;
                nextcount=0;
            } 
        }
        return vvi;
    }
};

Binary Tree Level Order Traversal 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:

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

与上题没有本质区别，只是把输出结果的顺序逆转一下就可以了。

代码

/**
 * 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) {
        if(root==NULL) return vector<vector<int>>();
        vector<vector<int>> vvi;
        queue<TreeNode*> que;
        TreeNode* p = root;
        que.push(p);
        int curcount = 1;
        int nextcount = 0;
        vector<int> vi;
        while (!que.empty()){
            p = que.front();
            que.pop();
            vi.push_back(p->val);
            --curcount;
            if (p->left){
                ++nextcount;
                que.push(p->left);
            }
            if (p->right){
                ++nextcount;
                que.push(p->right);
            }
            if (curcount == 0){
                vvi.push_back(vi);
                vi.clear();
                curcount = nextcount;
                nextcount = 0;
            }
        }
        reverse(vvi.begin(),vvi.end());//逆序
        return vvi; 
    }
};

递归层次遍历

参考于http://www.cnblogs.com/ganganloveu/p/3843470.html
一直以为先、中、后序遍历可以使用递归（栈）。层次遍历使用队列。原来层次遍历也是可是使用递归的，长见识了~~~~

/**
 * 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> > result;
    void levelTra(TreeNode *root, int level){
        if(root == NULL)
            return;
        if(level == result.size()){
            vector<int> v;
            result.push_back(v);
        }
        result[level].push_back(root->val);
        levelTra(root->left, level+1);
        levelTra(root->right, level+1);
    }

    vector<vector<int> > levelOrderBottom(TreeNode *root){
        levelTra(root, 0);
        return result;// I答案
        return vector<vector<int> >(result.rbegin(), result.rend());// II答案
    }
};