BiTree建立，先序，中序，后序递归、非递归遍历

二叉树建立：

#include <iostream>

#include <stack>

using namespace std;

typedef char ElemType;

typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *lson,*rson;
}BiTNode,*BiTree;

void InitBiTree(BiTree &T)//初始化一棵二叉树
{
    T=NULL;
}
void BuildBiTree(BiTree &T)//先序建树
{
    ElemType num;
    cin>>num;
    if(num=='#')
        T=NULL;
    else
    {
        if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
        T->data=num;
        BuildBiTree(T->lson);
        BuildBiTree(T->rson);
    }
}

 

 

递归遍历：

/**********************递归实现***************************/
void PreOderTraverse(BiTree T)//先序遍历，递归实现
{
    if(T)
    {
        visit(T);
        InOderTraverse(T->lson);
        InOderTraverse(T->rson);
    }
}

void InOderTraverse(BiTree T)//中序遍历，递归实现
{
    if(T)
    {
        InOderTraverse(T->lson);
        visit(T);
        InOderTraverse(T->rson);
    }
}

void PostOderTraverse(BiTree T)//后序遍历，递归实现
{
    if(T)
    {
        InOderTraverse(T->lson);
        InOderTraverse(T->rson);
        visit(T);
    }
}

 

非递归遍历：

/**********************非递归实现****************************/
void PreOrderTraverse(BiTree T)//先序遍历，非递归实现
{
    //queue<BiTree> que;
    stack<BiTree> que;
    BiTree p=T;
    while(p||!que.empty())
    {
        if(p)
        {
            visit(p);
            que.push(p);
            p=p->lson;
        }
        else if(!que.empty())
        {
            p=que.top();
            que.pop();
            p=p->rson;
        }
    }
}
void InOrderTraverse(BiTree T)// 中序遍历，非递归实现
{
    stack<BiTree> s;
    BiTree p=T;
    while(p||!s.empty())
    {
        if(p){s.push(p);p=p->lson;}
        else
        {
            p=s.top();
            visit(p);
            s.pop();
            p=p->rson;
        }
    }
}
void PostOrderTraverse(BiTree T)//后序遍历，非递归实现
{
    stack<BiTree> s;

    BiTree p = NULL;
    BiTree root=T;
    while(root!=NULL||!s.empty())
    {
        while(root!=NULL)
        {
            s.push(root);
            root=root->lson;
        }
        root=s.top();
        if(root->rson == NULL || p == root->rson)
        {
            visit(root);
            p = root;
            s.pop();
            root=NULL;
        }
        else
            root=root->rson;
    }
    return;
}

调用调试：

int main()
{   //abcd###e##fg##h##
    BiTree T;
    InitBiTree(T);
    BuildBiTree(T);
    cout<<"InOrderTraverse:";
    InOrderTraverse(T);
    cout<<endl;
    cout<<"PreOrderTraverse:";
    PreOrderTraverse(T);
    cout<<endl;
    cout<<"PostOrderTraverse:";
    PostOrderTraverse(T);
    cout<<endl;
    return 0;
}