深度优先遍历（先序、后序、中序）非递归实现（C++）

        二叉树的深度优先遍历递归实现很简单，只要调整调用顺序就分别能得到先序、后序、中序遍历的结果。这里记录下非递归的思想（都用到了栈）并给出代码。

        先序遍历：根-左-右    栈是先进后出的，希望以根-左-右的顺序出栈，我们首先将根节点压栈，然后弹出（根），在弹出的同时，分别压入右子树的根节点和左子树的根节点，以保证先弹左后弹右，接下来弹出栈顶元素，并将其右、左子树的根节点压栈，以此类推，直到栈为空。

        后序遍历：左-右-根    类似先序遍历，分别压入根节点、右子树的根节点、左子树的根节点，不同的是压入左右节点前不弹出根节点，以保证左-右-根这样一个顺序向外弹。压入根、右、左，对栈顶元素判断是否还有孩子，有的话继续压入其右、左，直到栈顶元素没有了子树。有个问题是，我们总是对栈顶元素压入右左孩子，栈顶大多是左子树，那所有右子树的孩子并没有被压入栈中。这就需要我们在弹出时操作了，想办法遇到有孩子的右子树时，先不要将其弹出，而是类似之前对根节点的操作，将其右左孩子压栈至栈顶元素无子树，再继续向外弹。那如何判断栈顶是不是有孩子的右子树呢？记录上次弹出的节点A，如果栈顶节点有孩子，且其左右子树均不为A，则可证明栈顶是有孩子的右子树。

        中序遍历：左-根-右    压入根节点，如果栈顶元素有左孩子，不断将其左孩子压栈，直至叶子节点，接下来向外弹出，对弹出的元素判断如果有右孩子，则将右孩子压栈（注意，先弹出再压栈，以保证先根后右），并不断压入其左孩子直至叶子节点。不断重复这个过程，直至栈为空。

 

附上C++实现：

#include<vector>
#include<queue>
#include<stack>
#include<iostream>
using namespace std;

struct TreeNode
{
    int value;
    TreeNode *left,*right;
    TreeNode(int v, TreeNode* l, TreeNode* r):value(v), left(l), right(r){}
};

//先序
vector<int> treepre(TreeNode *root);
//后序
vector<int> treebehind(TreeNode *root);
//中序
vector<int> treemiddle(TreeNode *root);

//二叉树深度优先遍历（非递归）
int main()
{
    TreeNode* node1 = new TreeNode(3,NULL,NULL);
    TreeNode* node2 = new TreeNode(2,NULL,NULL);
    TreeNode* node3 = new TreeNode(5,node1,node2);
    TreeNode* node4 = new TreeNode(1,NULL,node3);
    TreeNode* node6 = new TreeNode(6,NULL,NULL);
    TreeNode* node7 = new TreeNode(7,NULL,NULL);
    TreeNode* node5 = new TreeNode(4,node6,node7);
    TreeNode* node = new TreeNode(9,node4,node5);
    
    
    vector<int> res = treemiddle(node);

    for(int i=0;i<res.size();++i)
        cout<<res[i]<<" ";
    cout<<endl;
    
    return 0;
}


vector<int> treepre(TreeNode *root)
{//先序
    vector<int> res;
    stack<TreeNode*> s;
    s.push(root);
    
    while(!s.empty())
    {
        TreeNode* t = s.top();
        res.push_back(t->value);
        s.pop();
        if(t->right)
            s.push(t->right);
        if(t->left)
            s.push(t->left);
    }
    
    return res;
}

vector<int> treebehind(TreeNode *root)
{//后序
    vector<int> res;
    stack<TreeNode*> s;
    s.push(root);
    TreeNode* last = NULL;
    TreeNode* t;

    while(!s.empty())
    {
        t = s.top();
        while(!s.empty()&&(t->right||t->left))
        {
            if(t->right)
                s.push(t->right);
            if(t->left)
                s.push(t->left);
            t = s.top();
        }

        if(!s.empty())
            t = s.top();
        while(!s.empty()&&(!(t->right||t->left)||last==NULL ||(t->right&&t->right==last) ||(t->left&&t->left==last)))
        {
            res.push_back(t->value);
            last = t;
            s.pop();
            
            if(!s.empty())
                t = s.top();
        }
    }

    return res;
}

vector<int> treemiddle(TreeNode *root)
{//中序
    vector<int> res;
    stack<TreeNode*> s;
    TreeNode* t;
    s.push(root);
    
    while(!s.empty())
    {
        t = s.top();
        while(t->left)
        {
            s.push(t->left);
            t = s.top();
        }
        while(!s.empty())
        {
            t = s.top();
            res.push_back(t->value);
            s.pop();
            if(t->right)
            {
                s.push(t->right);
                break;
            }
        }
    }
    
    return res;
}