LeetCode

Binary Tree Postorder Traversal

2014.1.14 21:17

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    
     2
    /
   3

return [3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

Solution1:

　　Recursive solution is trivial, here is the trivial code.

　　Time and space complexities are both O(n) scale.

Accepted code:

// 1AC, the trivial recursive version.
class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        result.clear();
        
        if(root == nullptr){
            return result;
        }
        
        preorderTraversalRecursive(root);
        
        return result;
    }
private:
    void preorderTraversalRecursive(TreeNode *root) {
        if(root == nullptr){
            return;
        }
        preorderTraversalRecursive(root->left);
        preorderTraversalRecursive(root->right);
        result.push_back(root->val);
    }
    vector<int> result;
};

Solution2:

　　Here is the iterative version. Two extra stacks are used to track the traversal. One used to record TreeNode pointer, the other used to record its counting. The counting here has the following meaning:

　　　　0: the node has just been pushed into stack. The node is new.

　　　　1: the left child of the node is in stack.

　　　　2: the right child of the node is in stack. The node will be popped out when it is on top of stack.

　　Time and space complexites are still O(n).

Accepted code:

// 2WA, 1AC, should've think more before starting coding
class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        result.clear();
        
        if(root == nullptr){
            return result;
        }
        
        vstack.clear();
        cstack.clear();
        vstack.push_back(root);
        cstack.push_back(0);
        while(vstack.size() > 0){
            if(cstack[cstack.size() - 1] == 0){
                ++cstack[cstack.size() - 1];
                if(vstack[vstack.size() - 1]->left != nullptr){
                    cstack.push_back(0);
                    vstack.push_back(vstack[vstack.size() - 1]->left);
                }
            }else if(cstack[cstack.size() - 1] == 1){
                ++cstack[cstack.size() - 1];
                if(vstack[vstack.size() - 1]->right != nullptr){
                    cstack.push_back(0);
                    vstack.push_back(vstack[vstack.size() - 1]->right);
                    // 1WA here, cannot push result here
                    // result.push_back(vstack[vstack.size() - 1]->val);
                    // 1WA here, cannot replace node here, this works for preorder, but not postorder
                    // vstack[vstack.size() - 1] = vstack[vstack.size() - 1]->right;
                }
            }else{
                result.push_back(vstack[vstack.size() - 1]->val);
                cstack.pop_back();
                vstack.pop_back();
            }
        }
        
        return result;
    }
private:
    vector<int> result;
    vector<TreeNode *> vstack;
    vector<int> cstack;
};