二叉树遍历

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

//结点的结构
struct Tree_Node
{
    //每个结点的数据
    char data;
    //左子树
    Tree_Node * left;
    //右孩子
    Tree_Node * right;
};


//按照先序遍历的方式，构建我们的二叉树,输入的时候，我们要按照完全二叉树的形式输入，结点为空的位置，输入“#”
void createTree(Tree_Node * & t)
{
    char str;
    cin>>str;
    if(str=='#')
    {
        t=NULL;
    }
    else
    {
        t=new Tree_Node; //为t开辟空间
        t->data=str;
        createTree(t->left);
        createTree(t->right);
    }
}

//先序遍历，递归实现
void PreorderTraverse(Tree_Node * T)
{
    if(T){
        if(T->data!='#')
       cout<<T->data<<" ";   //访问根结点
       PreorderTraverse(T->left);  //访问左子树
       PreorderTraverse(T->right);  //访问右子树
    }
}

//非递归实现,思路：
//首先我们的循环条件是：结点不为空或者栈不为空。然后是先把根结点加入桟中，然后，遍历左子树，当左子树遍历完后，栈顶元素为刚刚的根结点，然后，让根结点出栈，遍历右子树
void PreorderTraverse_no_recursive(Tree_Node * T)   
{
    stack<Tree_Node*> s;
    Tree_Node * p=T;
        //栈不为空或者T不为空时，循环继续
    while(p || !s.empty())
    {
        if(p!=NULL)  
        {
            s.push(p); //根结点入栈
            if(p->data!='#')//访问根结点
            cout<<p->data<<' ';
            p=p->left; //先遍历左子树
        }
        else
        {
            p=s.top(); //根结点出栈
            s.pop();   //
            p=p->right;//遍历右子树
        }
    }
}

//递归实现中序遍历
void InorderTraverse(Tree_Node * T)
{
    if(T)
    {
        InorderTraverse(T->left); //中序遍历左孩子     
        if(T->data!='#')
        cout<<T->data<<" ";       //访问根结点
        InorderTraverse(T->right); //中序遍历右孩子
    }
}

//非递归实现中序遍历，思路：
//思路：T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 
//先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。 
void InorderTraverse_recursive(Tree_Node * T)
{
    stack<Tree_Node*> s;
    Tree_Node * p=T;
        //栈不为空或者T不为空时，循环继续
    while(p || !s.empty())
    {
        if(p!=NULL)  
        {
            s.push(p); //根结点入栈
            p=p->left; //先遍历左子树
        }
        else
        {
            p=s.top(); //根结点出栈
            s.pop();   //
            if(p->data!='#')//访问根结点
            cout<<p->data<<' ';
            p=p->right;//遍历右子树
        }
    }
}       


//递归实现后序遍历
void PostorderTraverse(Tree_Node * T)
{
    if(T)
    {
        PostorderTraverse(T->left); //访问左子树
        PostorderTraverse(T->right); //访问右子树
        if(T->data!='#')
        cout<<T->data<<" "; //访问根结点
    }
}

//非递归实现后序遍历
//思路：我们要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；
//或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，
//则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。 
void PostorderTraverse_recursive(Tree_Node * T)
{
    Tree_Node * pre; //前一个被访问的结点。
    pre=NULL;
    stack<Tree_Node*> s;
    Tree_Node * cur;  //记录栈顶的结点，
    s.push(T); //先把根结点入栈
    while(!s.empty())
    {
        cur=s.top(); //cur记录的是栈顶的结点
        if((cur->left==NULL && cur->right==NULL) || (pre!=NULL && (pre==cur->left || pre==cur->right)))
        {
            cout<<cur->data<<" "; //满足：不存在左孩子和右孩子；或者存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了
            s.pop();
            pre=cur; //更新pre的值
        }
        else
        {
            if(cur->right!=NULL) //一定是右子树先入栈的，因为这样才可以比左子树后被访问
            s.push(cur->right);
            if(cur->left!=NULL) //左子树入栈
            s.push(cur->left);   
        }
    }
}

int main()
{
    Tree_Node * T;
    createTree(T);
    cout<<"先序遍历--递归实现"<<endl;
    PreorderTraverse(T);
    cout<<endl;
    cout<<"先序遍历--非递归实现"<<endl;
    PreorderTraverse_no_recursive(T);
    cout<<endl;
    cout<<"中序遍历--递归实现"<<endl;
    InorderTraverse(T);
    cout<<endl;
    cout<<"中序遍历--非递归实现"<<endl;
    InorderTraverse_recursive(T);
    cout<<endl;
    cout<<"后序遍历--递归实现"<<endl;
    PostorderTraverse(T);
    cout<<endl;
    cout<<"后序遍历--非递归实现"<<endl;
    PostorderTraverse_recursive(T);
    cout<<endl;
    return 0;

}