标签：

在此之前回顾前序遍历和中序遍历：

1，前序遍历：

基本规则，总是先访问根节点在左节点，在右节点

递归解法：

class Solution {
public:
    vector<int> result;
    vector<int> preorderTraversal(TreeNode* root) {
        if(root){
            result.push_back(root->val);
            preorderTraversal(root->left);
            preorderTraversal(root->right);
        }
        return result;
    }
};

迭代解法：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (root==NULL) 
            return result;  
        stack<TreeNode*> stk;  
        TreeNode* pCurNode=root;  
        stk.push(pCurNode);  
        while (!stk.empty())
        {  
            pCurNode = stk.top();  
            stk.pop();  
            result.push_back(pCurNode->val);  
  
            if (pCurNode->right)  
                stk.push(pCurNode->right); //后压进来的后访问 
            if (pCurNode->left)  
                stk.push(pCurNode->left);  
        }  
        return result;  
    }
private:
  vector<int> result;  
};

2，中序遍历：

总是遍历树的左子，再当前节点，再右子

递归解法：

class Solution {  
public:  
    vector<int> inorderTraversal(TreeNode* root) {  
         if(root){    
            inorderTraversal(root->left);    
            result.push_back(root->val);    
            inorderTraversal(root->right);    
        }    
        return result;    
    }    
private:    
    vector<int> result;   
};  

迭代解法：

class Solution {  
public:  
    vector<int> inorderTraversal(TreeNode* root) {  
        if (root==NULL)     
            return result;      
        stack<TreeNode*> stk;      
        TreeNode* pCurNode=root;      
        while (!stk.empty() ||pCurNode)    
        {      
            while(pCurNode)//先把当前节点的所有左子压进去，  
            {  
                stk.push(pCurNode);  
                pCurNode=pCurNode->left;  
            }  
  
            pCurNode=stk.top();  
            stk.pop();//访问当前节点  
            result.push_back(pCurNode->val);  
              
            pCurNode=pCurNode->right;//再访问当前节点的右子树  
        }      
        return result;      
    }    
private:    
    vector<int> result;      
}; 

综上述：都可以采用栈来实现。将当前节点，左子，右子压进栈的顺序以及访问后的弹出栈形成的访问顺序，目的就是在维护要求的遍历顺序。

3，后序遍历：

递归解法：

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

迭代解法

然而发现回顾了一下也没用，尼玛，尽然要用两个栈或者用到了前后节点来维护。
别人的算法设计：

输出栈：获取最终的输出结果

辅助栈：

1，利用辅助栈总是先将当前节点压进栈，接着弹给输出栈（此时他的顺序已确定，所以最先进输出栈，因为最后访问），

2，再左子进辅助栈，在右子进辅助栈（此时在栈顶，下次循环他已被确定顺序）

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (root==NULL) 
            return result;  
        stack<TreeNode*> outStk;//辅助栈将维护此栈的顺序就是后序遍历的顺序
        stack<TreeNode*> assistStk;//辅助栈
        TreeNode *pCurNode = root;
        assistStk.push(pCurNode);
        
        while (!assistStk.empty())
        {
            pCurNode = assistStk.top();
            assistStk.pop();
            outStk.push(pCurNode);
            
            if (pCurNode->left!=NULL)
                assistStk.push(pCurNode->left);
            if (pCurNode->right!=NULL)
                assistStk.push(pCurNode->right);
        }
        while (!outStk.empty())
        {
            result.push_back(outStk.top()->val);
            outStk.pop();
        }
        return result;
    }
private:
  vector<int> result;  
};

注：本博文为EbowTang原创，后续可能继续更新本文。如果转载，请务必复制本条信息！

原文地址：http://blog.csdn.net/ebowtang/article/details/50572826

原作者博客：http://blog.csdn.net/ebowtang

<LeetCode OJ> 145. Binary Tree Postorder Traversal

标签：

原文地址：http://blog.csdn.net/ebowtang/article/details/50572826