Binary Tree Postorder Traversal

方法一，递归遍历。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        
        vector<int> result;
        if(root == NULL)
            return result;
        
        vector<int> left = postorderTraversal(root->left);
        vector<int> right= postorderTraversal(root->right);
        
        result.insert(result.end(), left.begin(), left.end());
        result.insert(result.end(), right.begin(), right.end());
        result.push_back(root->val);
        
        return result;
    }
};

方法二，使用栈。左子树进栈一直到空为止，然后判断栈顶元素的右子树是否为空或者已经被访问过，如果是，则弹出并访问栈顶元素；否则先访问栈顶元素的右子树（回到循环初始），然后再访问当前节点。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        
        vector<int> result;
        if(root == NULL)
            return result;
        stack<const TreeNode *> s;        
        const TreeNode *p = root;
        const TreeNode *prev = NULL;
        
        while(p != NULL || !s.empty()) 
        {
            if (p != NULL) /* 往左下走 */
            {
                s.push(p);
                p = p->left;
            }
            else
            {
                p = s.top();
                if (p->right == NULL || p->right == prev) { // 右孩子不存在或已被访问，访问之
                    s.pop();
                    result.push_back(p->val);
                    prev = p; // 保存刚访问过的结点
                    p = NULL; //保证上面的while(左子树进栈)不会执行
                } else {
                    //当前结点不能访问，先处理右子树
                    p = p->right;
                }               
            }
        }
        
        return result;
    }
};

<pre code_snippet_id="230033" snippet_file_name="blog_20140311_2_6499703">

方法三：Morris遍历。

参考：http://biaobiaoqi.me/blog/2013/04/27/travsal-binary-tree/

方法四：from postorderIterator

http://n00tc0d3r.blogspot.hk/2013/08/implement-iterator-for-binarytree-iii.html?view=sidebar

/**
 * 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<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        
        findNextLeaf(root);
        
        while(!s.empty())
        {
            TreeNode *cur = s.top();
            s.pop();
            
            if(!s.empty())
            {
                TreeNode *top = s.top();
                if(cur == top->left)
                    findNextLeaf(top->right);
            }
            res.push_back(cur->val);
        }
        return res;
    }
    
    void findNextLeaf(TreeNode *root)
    {
        while(root != NULL)
        {
            s.push(root);
            if(root->left)
                root = root->left;
            else
                root = root->right;
        }
    }
    
private:
    stack<TreeNode*> s;
};