二叉树的前序，中序，后序遍历的非递归实现

注：本文内容参考左老师课程

二叉树的遍历分为前、中、后序，对于递归的实现方法，这里不再赘述，本文主要介绍实现非递归的方法，其核心思想均是用栈来实现，其中着重说明后序遍历。

前序遍历：相对容易

//方法1
void preOrderTraversal(TreeNode *root,vector<int> &pre){
        stack<TreeNode *> s;
        TreeNode *p = root;
        while(!s.empty() || p != NULL){
            while(p != NULL){
                pre.push_back(p->val);
                s.push(p);
                p = p->left;
            }
            if(!s.empty()){
                p = s.top();
                s.pop();
                p = p->right;
                
            } 
        }        
    }
    //方法2
20 void preOrderTraversal(TreeNode *root,vector<int> &pre){
        stack<TreeNode *> s;
        TreeNode *p = root;
        s.push(p);
        while(!s.empty()){
            p = s.top();
            s.pop();
            pre.push_back(p->val);
            if(p->right)
                s.push(p->right);
            if(p->left)
                s.push(p->left);
        }        
    }

中序遍历：

    void inOrderTraversal(TreeNode *root,vector<int> &in){
        stack<TreeNode *> s;
        TreeNode *p = root;
        while(!s.empty() || p != NULL){
            while(p != NULL){
                s.push(p);
                p = p->left;
            }            
            p = s.top();
            in.push_back(p->val);
            s.pop();
            p = p->right;            
        }
    }

后序遍历：

方法1:使用两个栈实现（把先序访问的顺序用第二个栈存起来，然后再出栈就成了）

具体过程如下：

1.申请两个栈，记为s1，s2，然后将头节点压入s1中

2.从s1中弹出栈顶节点，记为cur，然后先把cur的左孩子压入s1中，然后把cur的右孩子压入s1中

3.在整个过程中，每一个从s1中弹出的节点都放入第二个栈s2中。

4.不断重复步骤2和步骤3，直到s1为空，过程停止。

5.从s2中依次弹出节点并打印，打印的顺序就是后序遍历的顺序了。

代码如下：

    void postOrderTraversal(TreeNode *root,vector<int> &post){
        stack<TreeNode *> s1;
        stack<TreeNode *> s2;
        TreeNode *p = root;
        s1.push(p);
        while(!s1.empty()){
            p = s1.top();
            s1.pop();
            s2.push(p);
            if(p->left)
                s1.push(p->left);
            if(p->right)
                s1.push(p->right);
        }
        while(!s2.empty()){
            post.push_back(s2.top()->val);
            s2.pop();
        }
    }

方法二：用一个栈来实现

具体过程如下：

1. 申请一个栈，记为s，将头节点压入s，同时设置两个变量cur和pre，在整个遍历过程中，cur代表当前s的栈顶节点，pre代表上一次访问的结点，初始时cur为NULL，pre为头节点
2. 每次令cur等于当前s的栈顶节点，但不从栈中弹出节点，此时分以下三种情况：
   1. 如果cur的左孩子不为空，并且pre不等于cur的左孩子，也不等于cur的右孩子(代表左孩子存在，且左右孩子都没有访问过)，则把cur的左孩子压入栈s中。
   2. 如果情况1不成立，并且cur的右孩子不为空，并且pre不等于cur的右孩子(代表其左孩子为空或者其已经访问过，但其右孩子没有访问过)，则把cur的右孩子压入栈s中。
   3. 如果情况1和情况2都不成立，那么从s中弹出cur并打印，然后令pre等于cur。
3. 一直重复步骤2，直到s为空，过程停止。

    void postOrderTraversal(TreeNode *root,vector<int> &post){
        stack<TreeNode *> s;
        TreeNode *cur = NULL;
        TreeNode *pre = root;  //注意这里的值
        s.push(root);
        while(!s.empty()){
            cur = s.top();
            if(cur->left && pre != cur->left && pre != cur->right)  
                s.push(cur->left);
            else if(cur->right && pre != cur->right)
                s.push(cur->right);
            else{
                s.pop();
                post.push_back(cur->val);
                pre = cur;
            }
        }
    }