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

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