[LeetCode] 145. Binary Tree Postorder Traversal

Binary Tree Postorder Traversal

Given a binary tree, return the postorder traversal of its nodes’ values.
Example:

Input: [1,null,2,3]
1
\
2
/
3
Output: [3,2,1]

解析

树的后序遍历，方法类似于前序和中序。

解法1：递归

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        postorder(root, res);
        return res;
    }
    void postorder(TreeNode* root, vector<int> &res){
        if(!root) return;
        postorder(root->left, res);
        postorder(root->right, res);
        res.push_back(root->val);
    }
};

解法2：迭代1

求二叉树的后序遍历的非递归方法，跟前序，中序，层序一样都需要用到栈，后续的顺序是左-右-根，所以当一个节点值被取出来时，它的左右子节点要么不存在，要么已经被访问过了。我们先将根结点压入栈，然后定义一个辅助结点pre，while循环的条件是栈不为空，在循环中，首先将栈顶结点p取出来，如果栈顶结点没有左右子结点，或者其左子结点是pre，或者其右子结点是pre的情况下。我们将栈顶结点值加入结果res中，并将栈顶元素移出栈，然后将pre指向栈顶元素；否则的话就看如果右子结点不为空，将其加入栈，再看左子结点不为空的话，就加入栈，注意这里先右后左的顺序是因为栈的后入先出的特点，可以使得左子结点先被处理。
下面来看为什么是这三个条件呢，首先如果栈顶元素如果没有左右子结点的话，说明其是叶结点，而且我们的入栈顺序保证了左子结点先被处理，所以此时的结点值就可以直接加入结果res了，然后移出栈，将pre指向这个叶结点，这样的话pre每次就是指向前一个处理过并且加入结果res的结点，那么如果栈顶结点的左子结点或者右子结点是pre的话，说明其子结点已经加入结果res了，那么就可以处理当前结点了。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode*> s;
        s.push(root);
        TreeNode* pre = root;
        while(!s.empty()){
            TreeNode* p = s.top();
            if((!p->left && !p->right) || p->left == pre || p->right == pre){
                res.push_back(p->val);
                s.pop();
                pre = p;
            }
            else{
                if(p->right) s.push(p->right);
                if(p->left) s.push(p->left);
            }
        }
        return res;
    }
};

解法3：迭代2

由于后序遍历的顺序是左-右-根，而先序遍历的顺序是根-左-右，二者其实还是很相近的，我们可以先在先序遍历的方法上做些小改动，使其遍历顺序变为根-右-左，然后翻转一下，就是左-右-根啦，翻转的方法是反向加入结果res，每次都在结果res的开头加入结点值，而改变先序遍历的顺序就只要该遍历一下入栈顺序，先左后右，这样出栈处理的时候就是先右后左。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()){
            TreeNode* p = s.top();
            s.pop();
            res.insert(res.begin(), p->val);
            if(p->left) s.push(p->left);
            if(p->right) s.push(p->right);
        }
        return res;
    }
};

解法4：迭代模板

将先序遍历的根-左-右顺序变为根-右-左，再翻转变为后序遍历的左-右-根，翻转还是改变结果res的加入顺序，然后把更新辅助结点p的左右顺序换一下即可。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode*> s;
        TreeNode* p = root;
        while(p || !s.empty()){
            if(p){
                s.push(p);
                res.insert(res.begin(), p->val); //改变顺序。
                p = p->right;
            }
            else{
                p = s.top();
                s.pop();
                p = p->left;
            }
        }
        return res;
    }
};

解法5：双栈

利用两个栈，思想和解法3相同，改变先序遍历的顺序，得到后序遍历。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode*> s1,s2;
        s1.push(root);
        while (!s1.empty()) {
            TreeNode *t = s1.top(); s1.pop();
            s2.push(t);
            if (t->left) s1.push(t->left);
            if (t->right) s1.push(t->right);
        }
        while (!s2.empty()) {
            res.push_back(s2.top()->val); 
            s2.pop();
        }
        return res;
    }
};

参考

http://www.cnblogs.com/grandyang/p/4251757.html