题目链接：点击这里

递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void postorder(TreeNode* r, vector<int> &v)
    {
        if(r!=NULL)
        {
            postorder(r->left, v);
            postorder(r->right, v);
            v.push_back(r->val);
        }
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> post;   //存储后序序列
        postorder(root, post);
        return post;
    }
};

非递归：

结点会出现在栈顶 $2$ 次

1. 第一次出现 转向处理右儿子
2. 第二次出现 访问结点自己

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

struct StackNode {    //栈结点
    TreeNode* r;
    bool isFirst;
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<StackNode> st;    //辅助栈
        vector<int> post;       //存储后序序列
        TreeNode* r = root;
        StackNode snode;
        while(!st.empty()||r!=NULL)
        {
            while(r!=NULL)
            {
                snode.r = r;
                snode.isFirst = true;
                st.push(snode);
                r = r->left;
            }
            if(!st.empty())
            {
                snode = st.top();
                st.pop();
                
                if(snode.isFirst)
                {
                    snode.isFirst = false;
                    st.push(snode);
                    r = snode.r->right;
                }
                else
                {
                    post.push_back(snode.r->val);
                    r = NULL;
                }
            }
        }
        return post;
    }
};

这里给出一个中序、后序遍历的非递归模板，按照遍历规则，更改case的访问次序即可。

中序

• 0 visit(left)
• 1 print
• 2 visit(right)

后序：

• 0 visit(left)
• 1 visit(right)
• 2 print

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

struct StackNode {  //栈结点
	TreeNode* r;
	int state; 
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<StackNode> st;    //辅助栈
        StackNode snode;
        snode.r = root;
        snode.state = 0;
        while(snode.r!=NULL || !st.empty())
        {
            while(!st.empty() && (snode.r==NULL||snode.state>=3))
            {
                snode = st.top();
                st.pop();
                snode.state++;
            }

            if(snode.r==NULL || snode.state>=3)
                break;
            
            switch(snode.state)
            {
                case 0:
                    //visit(left)
                    st.push(snode);
                    snode.r = snode.r->left;
                    break;
                case 2:
                    //print
                    ans.push_back(snode.r->val);
                    snode.state++;
                    break;
                case 1:
                    //visit(right)
                    st.push(snode);
                    snode.r = snode.r->right;
                    snode.state = 0;
                    break;
                default:
                    break; 
            }
        }
        return ans;
    }
};