[LeetCode] Binary Tree Level Order Traversal II

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.

Hide Tags

 Tree Breadth-first Search

---

    这题其实就是一个二叉树的广度搜索，然后就是reverse。

    写了两个，一个整个树用vector 记录，然后行之间用NULL 标记，然后再填回去，不过这样很耗空间，本来这样写是为了不想使用reverse，后面发现还是使用比较好。

class Solution {
public:
    vector<vector<int> > levelOrderBottom(TreeNode *root) {
        vector<vector<int> >ret;
        if(root==NULL)  return ret;
        vector<int> line;
        vector<TreeNode *> que;
        TreeNode * curNode;
        int idx= 0;
        que.push_back(root);
        que.push_back(NULL);
        while(idx+1<que.size()){
            curNode=que[idx];
            if(curNode!=NULL){
                if(curNode->left!=NULL) que.push_back(curNode->left);
                if(curNode->right!=NULL)    que.push_back(curNode->right);
            }
            else{
                if(idx+1<que.size())
                    que.push_back(NULL);
            }
            idx++;
        }
        for(idx--,line.clear();idx>=0;idx--){
            curNode = que[idx];
            if(curNode==NULL){
                reverse(line.begin(),line.end());
                ret.push_back(line);
                line.clear();
            }
            else{
                line.push_back(curNode->val);
            }
        }
        ret.push_back(line);
        return ret;
    }
};

     另外一个就是，标准的queue 广度搜索，queque 中存一行的全部node ，然后利用当前行的node 数，边写var 边填入queque ，不过不是外部循环，利用node 处理方便很多，下面代码就是用了外部循环，没有那么简洁：

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <iterator>
using namespace std;


///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> > levelOrderBottom(TreeNode *root) {
        vector<vector<int> >ret;
        if(root==NULL)  return ret;
        vector<int> line;
        vector<TreeNode *> que;
        TreeNode * curNode;
        int idx= 0;
        que.push_back(root);
        que.push_back(NULL);
        while(idx+1<que.size()){
            curNode=que[idx];
            if(curNode!=NULL){
                if(curNode->left!=NULL) que.push_back(curNode->left);
                if(curNode->right!=NULL)    que.push_back(curNode->right);
            }
            else{
                if(idx+1<que.size())
                    que.push_back(NULL);
            }
            idx++;
        }
        for(idx--,line.clear();idx>=0;idx--){
            curNode = que[idx];
            if(curNode==NULL){
                reverse(line.begin(),line.end());
                ret.push_back(line);
                line.clear();
            }
            else{
                line.push_back(curNode->val);
            }
        }
        ret.push_back(line);
        return ret;
    }
};
*/
class Solution {
public:
    vector<vector<int> > levelOrderBottom(TreeNode *root) {
        vector<vector<int> >ret;
        if(root==NULL)  return ret;
        vector<int> line;
        queue<TreeNode *> que;
        TreeNode * curNode;
        que.push(root);
        que.push(NULL);
        while(que.size()>1){
            curNode=que.front();
            que.pop();
            if(curNode==NULL){
                ret.push_back(line);
                line.clear();
                que.push(NULL);
                continue;
            }
            line.push_back(curNode->val);
            if(curNode->left!=NULL) que.push(curNode->left);
            if(curNode->right!=NULL)    que.push(curNode->right);

        }
        ret.push_back(line);
        reverse(ret.begin(),ret.end());
        return ret;
    }
};




int main()
{
    Solution sol;
    TreeNode node1(1);
    TreeNode node2(2);
    TreeNode node3(3);
    TreeNode node4(4);
    node1.right=&node2;
    node2.left =&node3;
    node2.right =&node4;

    vector<vector<int> >ret =sol.levelOrderBottom(&node1);
    for(int i=0;i<ret.size();i++){
        copy(ret[i].begin(),ret[i].end(),ostream_iterator<int>(cout," "));
        cout<<endl;
    }


    return 0;
}

 

     discuss 中有另外一个历史dfs 实现的，思路其实差不多，dfs 中每次遍历的值先填写到vector<vector<int> >  ret正确位置，即一列一列地填，而bfs 则是一行一行地填ret，最后反向一下，仍然是不能避免反向。

下面是代码，直接copy一下了：

https://oj.leetcode.com/discuss/5353/there-better-regular-level-order-traversal-reverse-result

 

vector<vector<int> > res;

void DFS(TreeNode* root, int level)
{
    if (root == NULL) return;
    if (level == res.size()) // The level does not exist in output
    {
        res.push_back(vector<int>()); // Create a new level
    }

    res[level].push_back(root->val); // Add the current value to its level
    DFS(root->left, level+1); // Go to the next level
    DFS(root->right,level+1);
}

vector<vector<int> > levelOrderBottom(TreeNode *root) {
    DFS(root, 0);
    return vector<vector<int> > (res.rbegin(), res.rend());
}