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

二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。
1.前序遍历
（1）递归实现前序遍历

void PreOrder(BtNode *root)
{
    BtNode *p = root;
    if(p == NULL)
    {
        return ;
    }
    cout<<p->data<<" ";
    PreOrder(p->leftchild);
    PreOrder(p->rightchild);
}

（2）非递归实现前序遍历
用栈实现二叉树的遍历
思想：前序遍历的特点是先访问根节点，再访问左子树，最后访问右子树。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。
对于任何一个结点p：
a.先访问该节点，再将这个节点入栈
b.判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
c.直到P为NULL并且栈为空，则遍历结束。

void PreOrder1(BtNode *root) 
{
    BtNode *p = root;
    stack<BtNode *> s;
    while(p != NULL && !s.empty())
    {
        while(p != NULL)
        {
           cout<<p->data;
           s.push(p);
           p = p->leftchild; 
        }
        else
        {
            p = s.top();
            s.pop();
            p = p->rightchild;
        }
}

2.中序遍历
(1)递归实现

void InOrder(BtNode *root)
{
    BtNode *p = root;
    if(p == NULL)
    {
        return ;
    }
    InOrder(p->leftchild);
    cout<<p->data<<" ";
    InOder(p->rightchild);
}

(2)非递归实现
思想：对于任一结点，先访问左子树，再访问根节点，最后访问右子树。
对任一结点p：
a.若其左孩子不为空，将p入栈，并将p的左孩子置为P,然后对当前结点P再进行相同的处理;
b.若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；
c.直到P为NULL并且栈为空则遍历结束。

void InOrder1(BtNode *root)
{
    BtNode *p = root;
    stack<BtNode *> s;
    while( p != NULL && !s.empty())
    {
        while(p != NULL)
        {
            s.push(p);
            p = p->leftchild;
        }
        else
        {
            p = s.top();
            cout<<p->data<<" ";
            s.pop();
            p = p->rigthchild;
        }
    }
}

3.后序遍历
(1)递归遍历

void PastOrder(BtNode *root)
{
    BtNode *p = root;
    if(p == NULL)
    {
        return ;
    }
    PastOrder(p->leftchild);
    PastOrder(p->rightchild);
    cout<<p->data<<" ";
}

(2)非递归遍历
思想：先访问左子树，再访问右子树，最后访问根节点。但在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点。
要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void PastOrder1(BtNode *root)
{
    stack<BtNode *> s;
    BtNode *p = root;  //当前结点
    BtNode *pre = NULL;  //前一次被访问的结点
    s.push(p);
    while( !s.empty())
    {
        s = s.top();
        if( p ->rightchild == NULL && p->leftchild == NULL || (pre!=NULL && (pre == p->leftchild || pre == cp->rightchild)))
        {
            cout<<p->data<<" ";
            s.top();
            pre = p;
        }
        else
        {
            if(p ->rightchild != NULL)
            {
                s.push(p->rightchild);
            }
            if(p ->leftchild != NULL)
            {
                s.push(p->leftchild);
            }
        }
    }
}

4.全部代码

#include<iostream>
#include<stack>
using namespace std;
typedef char ElemType;
typedef struct BtNode
{
    BtNode *leftchild;
    BtNode *rightchild;
    ElemType data;
}BtNode,*BinaryTree;

BtNode *BuyNode()
{
    BtNode *p = (BtNode *)malloc(sizeof(BtNode));
    if(p != NULL)
    {
        p->leftchild = NULL;
        p->rightchild = NULL;
    }
    return p;
}

void FreeNode(BtNode *p)
{
    free(p);
}
/////////////////////////////////////////////
void PreOrder(BtNode *p)       //递归遍历
{
    if(p != NULL)
    {
        cout<<p->data<<" ";
        PreOrder(p->leftchild);
        PreOrder(p->rightchild);        
    }
}
void InOrder(BtNode *p)
{
    if(p != NULL)
    {
        InOrder(p->leftchild);
        cout<<p->data<<" ";
        InOrder(p->rightchild);
    }
}
void PastOrder(BtNode *p)
{
    if(p != NULL)
    {
        PastOrder(p->leftchild);
        PastOrder(p->rightchild);
        cout<<p->data<<" ";
    }
}
/////////////////////////////////////////
BtNode * CreatNode()
{
    BtNode *s = NULL;
    ElemType x;
    cin>>x;
    if(x != '#')
    {
        s = BuyNode();
        s->data = x;
        s->leftchild = CreatNode();
        s->rightchild = CreatNode();
    }
    return s;
}    //ABC##DE##F##G#H##
//////////////////////////////////////////////////////////
//非递归遍历(用栈实现)
//中序遍历
void InOrder1(BtNode *root)      //非递归中序遍历
{
    stack<BtNode*> s;
    BtNode *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->leftchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rightchild;
        }
    }    
} 
//前序遍历  
void PreOrder1(BtNode* root)  
{  
    if (root == NULL)  
        return;  
    BtNode* p = root;  
    stack<BtNode*> s;  
    while (!s.empty() || p != NULL)  
    {  
        if (p != NULL)  
        {  
            cout <<p->data<<" ";  
            s.push(p);  
            p = p->leftchild; 
        }  
        else  
        {  
            p = s.top();  
            s.pop();  
            p = p->rightchild;  
        }  
    }  
}  
//后序遍历
void PastOrder1(BtNode *root)
{
    if( root == NULL)
    {
        return ;
    }
    BtNode *p= root;  //当前结点
    stack<BtNode *> s;
    BtNode *pre = NULL; //前一次访问的结点
    s.push(p);
    while(!s.empty())
    {
        p = s.top();
        if(p->leftchild ==NULL && p->rightchild == NULL || (pre != NULL && (pre == p->leftchild || pre == p->rightchild)))
        {
            cout<<p->data<<" ";
            s.pop();
            pre = p;
        }
        else
        {
            if(p->leftchild != NULL)
            {
                s.push(p->leftchild);
            }
            if(p->rightchild != NULL)
            {
                s.push(p->rightchild);
            }
        }
    }
}




////////////////////////////////////////////////////////////////////
int main()
{
    BinaryTree root = NULL;
    root = CreatNode();
    /*char *arr= "ABC##DE##F##G#H##";
    int len = sizeof(arr)/sizeof(arr[0]);*/

    /*for(int i = 0;i<len;++i)
    {
        root = CreatNode1(arr);
    }*/
    cout<<"前序遍历"<<endl;
    //PreOrder(root);
    PreOrder1(root);
    cout<<endl;
    cout<<"中序遍历"<<endl;
    InOrder1(root);
    //InOrder(root);
    cout<<endl;
    cout<<"后序遍历"<<endl;
    //PastOrder(root);
    PastOrder1(root);
    cout<<endl;
    return 0;
}