二叉树的构造 遍历

#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define INFEASIBLE -1

typedef int Status;
typedef char TElemType;
//二叉树结构
typedef struct BiTNode {
 TElemType data;
 struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree,*SElemType;
//栈结构
typedef struct{
    SElemType* base;
    SElemType* top;
    int stacksize;
}SqStack;
typedef BiTree QElemType; /* 设队列元素为二叉树的指针类型 */

//队列
typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct{
    QueuePtr front,rear; /* 队列头、队列尾指针 */
}LinkQueue;
/**************链队列基本操作****************/
//构造一个空队列Q
Status InitQueue(LinkQueue *Q){
    (*Q).front = (*Q).rear = (QueuePtr)malloc(sizeof(QNode));
    if(!(*Q).front)
    exit(OVERFLOW);
    (*Q).front->next = NULL;
    return OK;
}

//判断是不是空队列
Status QueueEmpty(LinkQueue Q){
    if(Q.front == Q.rear)
    return TRUE;
    else
    return FALSE;
}
//向队列中插入元素e作为新的队尾元素
Status EnQueue(LinkQueue *Q, QElemType e){
    QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    if(!p)
    exit(OVERFLOW);
    p->data = e;
    p->next = NULL;
    (*Q).rear->next = p;
    (*Q).rear = p;
    return OK;
}

//删除Q的队头元素，用e返回
Status DeQueue(LinkQueue *Q, QElemType *e){
    QueuePtr p;
    if((*Q).front == (*Q).rear){
        return ERROR;
    }   
    p = (*Q).front->next;
    *e = p->data;
    (*Q).front->next = p->next;
    if((*Q).rear == p){
        (*Q).rear = (*Q).front;
    }
    free(p);
    return OK;
}         
/***********栈基本操作************/
 
//栈的初始化
Status InitStack(SqStack* s){
    s->base = (SElemType*)malloc(30 * sizeof(SElemType));
    if(!s->base)
    exit(OVERFLOW);
    s->top = s->base;
    s->stacksize = 30;
    return OK;
}
//isEmpty
Status StackEmpty(SqStack s){
    if(s.base == s.top)
    return TRUE;
    else
    return FALSE;
}
//取栈顶元素
Status GetTop(SqStack* s,SElemType *e){
    if(s->top == s->base)
    return ERROR;
    else
    *e = *(s->top-1);
    return OK;
}
   
//push
Status Push(SqStack* s,SElemType e){
    if(s->top - s->base >= s->stacksize){
        s->base = (SElemType*)realloc(s->base, 60 * sizeof(SElemType));
        if(!s->base)
        exit(OVERFLOW);
        s->top = s->base + 30;
        s->stacksize = 60;
    }    
    *s->top++ = e;
    return OK;
}
//pop
Status Pop(SqStack* s, SElemType *e){
    if(s->top == s->base)
    return ERROR;
    else
    *e = * --s->top;
    return OK;
}

/************二叉树基本操作*************/
//create a BiTree
void CreateBT(BiTree *bt){
    char ch;
    scanf("%c",&ch);
    if(ch == '0')
    *bt = NULL;
    else{
        if(!((*bt) = (BiTNode*)malloc(sizeof(BiTNode))))
        exit(OVERFLOW);
        (*bt)->data = ch;
        CreateBT(&(*bt)->lchild);
        CreateBT(&(*bt)->rchild);
    }   
}
//visit
int visit(TElemType e){
 printf("%c ",e);
 return OK;
}    
//先序遍历PreOrderTraverse a bTree
void PreOrderTraverse(BiTree t,int(*visit)(TElemType e)){
    if(t){//t不空
        visit(t->data);//先访问根结点
        PreOrderTraverse(t->lchild,visit);//先序遍历左子树
        PreOrderTraverse(t->rchild,visit);//先序遍历右子树
    }
}
//中序遍历
void InOrderTraverse(BiTree t,int(*visit)(TElemType e)){
    if(t){
        InOrderTraverse(t->lchild,visit);//中序遍历左子树
        visit(t->data);//访问根结点
        InOrderTraverse(t->rchild,visit);//中序遍历右子树
    }
}
//非递归遍历二叉树(中序)   
Status InOrderTraverse1(BiTree t,int(*visit)(TElemType e)){   
    SqStack s;
    InitStack(&s);      
    while( t || !StackEmpty(s) ) {
        if(t){
        /*根指针进栈，遍历左子树*/
        Push(&s,t);
        t = t->lchild;
        }
        else{
            /*根指针退栈，访问根结点，遍历右子树*/
            Pop(&s,&t);
            if(!visit(t->data))
            return ERROR;
            t = t->rchild;
        }
    }
    printf("/n");
    return OK;
}          
//后序遍历
void PostOrderTraverse(BiTree t, void(*visit)(TElemType e)){
 if(t){
     PostOrderTraverse(t->lchild, visit);//后序遍历左子树   
     PostOrderTraverse(t->rchild, visit);//后序遍历右子树
     visit(t->data);//访问根结点
    }
}
//层序遍历
void LevelOrderTraverse(BiTree t,Status(*visit)(TElemType))
{
    LinkQueue q;
    QElemType a;
    if(t){
        InitQueue(&q);
        EnQueue(&q,t);
        while(!QueueEmpty(q)){
            DeQueue(&q,&a);
            visit(a->data);
            if(a->lchild != NULL)
            EnQueue(&q,a->lchild);
            if(a->rchild!=NULL)
            EnQueue(&q,a->rchild);
        }
    printf("/n");
    }
}                    

 

#include "BinTree.h"
main(){
 BiTree BT;
 /*创建二叉树*/
 printf("请按先序正确输入二叉树(空格为空树):/n");
 CreateBT(&BT);
 /*递归遍历*/
 printf("1> 先序序列(递归遍历)为：/n");
 PreOrderTraverse(BT, &visit);
 printf("/n2> 中序序列(递归遍历)为：/n");
 InOrderTraverse(BT, &visit);
  printf("/n3> 后序序列(递归遍历)为：/n");
 PostOrderTraverse(BT, &visit);
 /*非递归遍历*/
 printf("/n4> 中序序列(非递归遍历)为：/n");
 InOrderTraverse1(BT, &visit);
 /*层次遍历*/
    printf("/n5> 层次遍历:/n");
    LevelOrderTraverse(BT,&visit);    
 getchar();
}