二叉树的创建和遍历

#include<stdlib.h>
#include<stdio.h>
#define MAXQSIZE 50
#define STACK_INIT_SIZE 50
#define TRUE 1               /*状态码预定义*/
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef char TElemType;
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode *lchild,*rchild;  //左右孩子指针
}BiTNode, *BiTree; 
typedef struct BiTNode* QElemtype;
typedef  struct BiTNode* SElemtype; 

typedef struct
{
    QElemtype *base;
    int front,rear;
}SqQueue;

typedef struct 
{
    SElemtype base[STACK_INIT_SIZE];
    int  top;
    int stacksize;
}SqStack;

Status InitStack(SqStack *S)     
{
    S->top=0;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}

SElemtype GetTop(SqStack S)   
{
    if(S.top==0)   
        return ERROR;
    else
        return S.base[S.top-1];
}

Status Push(SqStack *S,SElemtype e)   
{
    S->base[S->top++]=e;
    return OK;
}

SElemtype Pop(SqStack *S)   
{
    if(S->top == 0) return ERROR;
    S->top--;
    return S->base[S->top];
    
}

Status StackEmpty(SqStack S)  
{
    return S.top==0;
}

int GetStackSize(SqStack S)  
{
    return S.top-1;
}

Status InitQueue(SqQueue *Q)   
{
    Q->base=(QElemtype*)malloc(sizeof(QElemtype));
    if(!Q->base) exit(OVERFLOW);
    Q->front=Q->rear=0;
    return OK;
}

Status EnQueue(SqQueue *Q,QElemtype e)   
{
    if((Q->rear+1)%MAXQSIZE==Q->front)     /*If the queue is full*/
    {
        printf("The queue is full!\n");    
        return ERROR;   
    }
    Q->base[Q->rear]=e;      
    Q->rear=(Q->rear+1)%MAXQSIZE;
    return OK;
}

Status Dequeue(SqQueue *Q,QElemtype *e)   
{
    if(Q->front==Q->rear) 
    {
        printf("The queue is empty!\n");
        return ERROR;
    }
    *e=Q->base[Q->front];
    Q->front=(Q->front+1)%MAXQSIZE;
    return OK;
}

Status TraverseQueue(SqQueue Q)   
{
    int i;
    i=Q.front;
    printf("The elements in the queue are:");
    while((i%MAXQSIZE)!=Q.rear)
    {
        printf("%d ",Q.base[i]);
        i++;
    }
    printf("\n");
    return OK;
}

Status QueueEmpty(SqQueue q)   
{
    return q.rear==q.front;
}

Status CreateBiTree_1(BiTree *T,char ch[])   //先序遍历创建节点，递归(自动输入)
{
    static int i=-1;  //静态变量
    i++;      
    if(ch[i]=='#') 
        *T=NULL;
    else if(ch[i]!='\0')
    {
        *T=(BiTNode *)malloc(sizeof(BiTNode));  //为T分配内存空间
        if(T==NULL) exit(OVERFLOW);
        (*T)->data=ch[i];
        CreateBiTree_1(&(*T)->lchild,ch);     
        CreateBiTree_1(&(*T)->rchild,ch);      
    }
    return OK;
}

Status CreateBiTree_2(BiTree *T)   //先序遍历创建节点，递归（手动输入）
{
    char e;
    scanf("%c",&e);  
    if(e=='#') 
        *T=NULL;
    else 
    {
        *T=(BiTNode *)malloc(sizeof(BiTNode));  //为T分配内存空间
        if(T==NULL) exit(OVERFLOW);
        (*T)->data=e;
        CreateBiTree_2(&(*T)->lchild);     
        CreateBiTree_2(&(*T)->rchild);      
    }
    return OK;
}

Status PrintElement(TElemType e)   //简单的打印元素函数
{
    printf("%c",e);
    return OK;
}

/*先序遍历，使用递归*/
void PreOrderTraverse(BiTree T,Status (*visit)(TElemType e))  
{
    if(T==NULL)   return;
    visit(T->data);
    PreOrderTraverse(T->lchild,visit);
    PreOrderTraverse(T->rchild,visit); 
}

/*非递归中序遍历方法1*/
Status InOrderTraverse_1(BiTree T,Status (*visit)(TElemType e))
{
    SqStack S;
    BiTree p;
    InitStack(&S);  //初始化栈
    Push(&S,T);
    while(!StackEmpty(S))  //栈非空
    {
        while(p=GetTop(S)) Push(&S,p->lchild);
        p=Pop(&S);
        if(!StackEmpty(S))
        {
            p=Pop(&S); if(!visit(p->data)) return ERROR;
            Push(&S,p->rchild);
        }
    }
}

/*非递归中序遍历方法2*/
Status InOrderTraverse_2(BiTree T,Status(*visit)(TElemType e))
{
    SqStack S;
    BiTree p;
    InitStack(&S);
    p=T;
    while(p||!StackEmpty(S))
    {
        if(p)
        {
            Push(&S,p);
            p=p->lchild;
        } //左子树全部进栈
        else
        {
            p=Pop(&S);
            if(!visit(p->data)) return ERROR;
            p=p->rchild;
        }
    }
    return OK;
}

/*递归后序遍历*/
Status PostOrderTraverse(BiTree T,Status(*visit)(TElemType e))
{
    if(T==NULL)
    return ERROR;
    PostOrderTraverse(T->lchild,visit);  /*先左后右*/
    PostOrderTraverse(T->rchild,visit);
    visit(T->data);
}

/*层序遍历*/
Status LevelOrderTraverse(BiTree T,Status(*visit)(TElemType e))
{   
    SqQueue q;
    BiTree p;
    InitQueue(&q);   //初始化队列
    EnQueue(&q,T);
    while (!QueueEmpty(q))
    {
        Dequeue(&q,&p);
        printf("%c",p->data);
        if(p->lchild)
            EnQueue(&q,p->lchild);
        if(p->rchild)
            EnQueue(&q,p->rchild);
    }
    return OK;
}

void main()
{
    BiTree T;
    char ch[]="ABDF###E##C##"; //测试数据  先序序列
    /*可替换为："-+a##*b##-c##d##/e##f##"  ,  '#'代表空*/  
    CreateBiTree_1(&T,ch);  //二选一
    //CreateBiTree_2(&T);   //此为符合实验要求函数
    printf("层序遍历:\n");
    LevelOrderTraverse(T,PrintElement);  
    printf("\n后序遍历:\n");
    PostOrderTraverse(T,PrintElement); 
    printf("\n先序遍历:\n");
    PreOrderTraverse(T,PrintElement); 
    printf("\n非递归中序遍历方法1:\n");
    InOrderTraverse_1(T,PrintElement);
    printf("\n非递归中序遍历方法2:\n");
    InOrderTraverse_2(T,PrintElement); 
	printf("\n");
}

运行结果