LeetCode

Binary Tree Level Order Traversal II

2014.1.8 01:45

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.

Solution:

　　This is a variation from: LeetCode - Binary Tree Level Order Traversal.

　　Level-order traversal of a binary tree can be done with stl-queue. But in this problem it can be done with preorder traversal, too.

　　When the traversal is done, reverse the result by row and you get what you need.

　　Time and space complexities are both O(n), where n is the number of nodes in the tree. Space complexity comes from the local parameters passed in function calls.

Accepted code:

// 1CE, 1AC, when copying the code, make sure you don't mix up the name of function and variables!!
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //1CE here, levelOrder, levelOrderBottom, check the names before you copy the codes!!!!
    // That was stupid, man~
    vector<vector<int> > levelOrderBottom(TreeNode *root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        // I could use pre-order traversal to do this.
        // Level-order traversal makes sense too.
        
        // 1CE here, declaration of int i is MISSSING
        for(int i = 0; i < result.size(); ++i){
            result[i].clear();
        }
        result.clear();
        
        if(root == nullptr){
            return result;
        }
        
        preOrder(root, 0);

        vector<int> tmp;
        int i = 0;
        while(i < result.size() - 1 - i){
            tmp = result[i];
            result[i] = result[result.size() - 1 - i];
            result[result.size() - 1 - i] = tmp;
            ++i;
        }
        return result;
    }
private:
    vector<vector<int>> result;
    
    void preOrder(TreeNode *root, int height) {
        if(root == nullptr){
            return;
        }
        // 1CE here,  ) MISSING!!!
        while(result.size() <= height){
            result.push_back(vector<int>());
        }
        result[height].push_back(root->val);
        
        if(root->left != nullptr){
            preOrder(root->left, height + 1);
        }
        if(root->right != nullptr){
            // 1CE here, spelling error, pre-order preOrder
            // Don't rely on auto-complete, you're spoiled!!!
            preOrder(root->right, height + 1);
        }
    }
};