LeetCode -- 二叉樹的後序遍歷（最詳細的解法！！！）

給定一個二叉樹，返回它的 後序 遍歷。

示例:

輸入: [1,null,2,3]
1

2
/
3

輸出: [3,2,1]
進階: 遞歸算法很簡單，你可以通過迭代算法完成嗎？

解題思路：總體思路分爲遞歸和迭代兩種。兩者都是依賴於後序遍歷的順序：左、右、根。具體細節看下面代碼。

代碼一：

/*遞歸1、最簡單的算法*/
/*class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(root){
            postorderTraversal(root->left);
            postorderTraversal(root->right);
            res.push_back(root->val);
        }
        return res;
    }
private:
    vector<int> res;
};*/

代碼二：

/*遞歸2*/
/*class Solution {
public:
     vector<int> postorderTraversal(TreeNode *root) {
         vector<int> res;
         stack<int> res_;
         postorder(root, res_);
         while(!res_.empty()){
             res.push_back(res_.top());
             res_.pop();
         }
         return res;
     }
     void postorder(TreeNode *root, stack<int> &res) {
         if (!root) 
             return;
         res.push(root->val);
         if (root->right) 
             postorder(root->right, res);
         if (root->left) 
             postorder(root->left, res);
     }
 };*/

代碼三：

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

代碼四：

/*迭代1*/
/*class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        vector<int> res_;
        stack<TreeNode*> s;
        TreeNode *p = root;
        if(p == NULL)
            return res;
        while(p || !s.empty()){
            if(p != NULL){
                res.push_back(p->val);
                s.push(p->left);
                p = p->right;
            }
            else{
                p = s.top();
                s.pop();
            }
        }
        for(int i = res.size()-1;i >= 0;--i)
            res_.push_back(res[i]);
        return res_;
    }
};*/

代碼五：

/*迭代2*/
/*class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        vector<int> res;
        if(root==NULL)
           return res;
        TreeNode* p = root;
        TreeNode* temp = NULL;
        while(p||!s.empty()){
            if(!p){
               p=s.top();//彈出棧內結點
               s.pop();
               if(p->right){//此節點有右子樹，P轉到該右子樹，並把該結點的右子樹置爲NULL，押回
                  temp=p->right;
                  p->right=NULL;
                  s.push(p);
                  p=temp;
               }
               else{
                  res.push_back(p->val);
                  p=NULL;
               }
            }
            else{
                s.push(p);
                p=p->left;
            }
        }
        return res;
    }
};*/

代碼六：

/*迭代3*/
/*class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while (!s.empty() || p) {
            if (p) {
                s.push(p);
                res.insert(res.begin(), p->val);    //反向添加，而前序是正向添加
                p = p->right;
            } 
            else {
                TreeNode *t = s.top(); 
                s.pop();
                p = t->left;
            }
        }
        return res;
    }
};*/

代碼七：

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

代碼八：

/*迭代5*/
//常數時間空間複雜度
/*class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode *tmp = NULL;
        while(root){
            tmp=root->right;
            while(tmp && tmp->left!=NULL && tmp->left!=root){
                tmp = tmp->left;
            }
            if(tmp == NULL){
                res.push_back(root->val);
                root=root->left;
            }
            else if(tmp->left == NULL){
                res.push_back(root->val);
                tmp->left=root;
                root=root->right;
            }
            else{
                tmp->left=NULL;
                root=root->left;
            }
        }
        reverse(res.begin(),res.end());
        return res;
    }
};*/

代碼九：

/*迭代6*/
/*class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;        
        if(!root)            
            return ans;                
        stack<TreeNode *> st;        
        TreeNode *p = root;        
        st.push(p);        
        while(!st.empty()){            
            p = st.top();
            if(!p->left && !p->right){
                st.pop();
                ans.push_back(p->val);
            }
            if(p->right){
                st.push(p->right);
                p->right = NULL;
            }           
            if(p->left){
                st.push(p->left);
                p->left = NULL;
            }          
        }        
        return ans;
    }
};*/