二叉树的重建，遍历，求深度算法

#include "stdafx.h"
#include<stdio.h>
#include<malloc.h>
#define STACK_INCREMENT  10
#define STACK_INIT_SIZE 100
#define MAXSIZE         50
//char*ch="ABC  D  EFH  I  G  ";
//char*ch="AB  CD  E  ";
char*ch="-+a  *b  -c  d  /e  f  ";
//二叉排序树的链式存储结构
typedef struct BiTNode
{
char data;
int count;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//队列的链式存储结构
typedef struct QNode
{
BiTree data;
struct QNode *next;
}QNode,*QueuePtr;

typedef struct
{
QueuePtr front;
QueuePtr rear;
}LinkQueue;

//栈的顺序存储结构
typedef struct
{
BiTree *base;
BiTree *top;
int stacksize;
}Sqstack;

//初始化一个队列，用于二叉树的层次遍历
bool InitQueue(LinkQueue&Q)
{
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front )
exit(OVERFLOW);
Q.front ->next =NULL;
return true;
}

//初始化一个栈，用于二叉树的遍历
void InitStack(Sqstack&S)
{
S.base=(BiTree*)malloc(STACK_INIT_SIZE*sizeof(BiTNode));
if(!S.base)
exit(0);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
}

bool EnQueue(LinkQueue&Q,BiTree T)
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
if(!p)
return false;
p->data =T;
p->next =NULL;
Q.rear->next =p;
Q.rear=p;
return true;
}

bool DeleteQueue(LinkQueue&Q,BiTree &e)
{
QueuePtr q;
if(Q.front ==Q.rear )
return false;
q=Q.front->next ;
e=q->data;
Q.front->next=q->next ;
if(q==Q.rear )
Q.rear=Q.front ;
free(q);
return true;
}

//采用先序递归遍历创建一个二叉树
void CreateBiTree(BiTree&T)
{
//static int n=0;//用静态变量保存上次运算结果的值。
//char ch;
//static char *ch="ABCD  E   F  ";
//ch=ch+n;
//scanf("%c",&ch);
if(*ch==' ')
{
T=NULL;
ch++;
//n++;
return;
}
else
{
if(!(T=(BiTNode*)malloc(sizeof(BiTNode))))
exit(OVERFLOW);
T->data=*ch++;
T->count =0;
//n++;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}

}

//计算二叉树的深度
int depth(BiTree T)
{
int d1,d2;
if(!T)
return 0;
else
{
d1=depth(T->lchild);
d2=depth(T->rchild);
return (d1>d2)?(d1+1):(d2+1);
}

}

//先序递归遍历二叉树
void PreRecursTraverse(BiTree T)
{
if(T)
{
printf("%c ",T->data);
PreRecursTraverse(T->lchild);
PreRecursTraverse(T->rchild);
}
else
return;
}

//先序非递归遍历二叉树
void PreOrderTraverse(BiTree T)
{
BiTree p;
Sqstack Sqt;
InitStack(Sqt);
p=T;

while(p||Sqt.top!=Sqt.base)
{
if(p)
{
printf("%c ",p->data);
*Sqt.top++=p;
p=p->lchild;
}
else
{
p=*--Sqt.top ;
p=p->rchild ;
}
}
printf("\n");
}

//中序递归遍历二叉树
void InRecursTraverse(BiTree T)
{
if(T)
{
InRecursTraverse(T->lchild);
printf("%c ",T->data);
InRecursTraverse(T->rchild);
}
else
return;
}

//中序非递归遍历二叉树
void InOrderTraverse(BiTree T)
{
BiTree p;
Sqstack Sqt;
InitStack(Sqt);
p=T;
while(p||Sqt.base!=Sqt.top)
{
if(p)
{
*Sqt.top++=p;
p=p->lchild;
}
else
{
p=*--Sqt.top;
printf("%c ",p->data);
p=p->rchild;
}
}
printf("\n");
}

//后序递归遍历二叉树
void SubRecursTraverse(BiTree T)
{
if(T)
{
SubRecursTraverse(T->lchild);
SubRecursTraverse(T->rchild);
printf("%c ",T->data);
}
else
return;
}

//后序非递归遍历二叉树
void SubOrderTraverse(BiTree T)
{
BiTree p;
Sqstack Sqt;
InitStack(Sqt);
p=T;
int count=0;
while(p||Sqt.top!=Sqt.base)
{
if(p)
{
*Sqt.top++=p;
p=p->lchild;
}
else
{
p=*--Sqt.top ;
p->count+=1;
if(p->count==2)//后序遍历，每个节点都是两次入栈，两次出栈，在第二次出栈时，访问。
{
printf("%c ",p->data );
p=NULL;//这里要将p设为空，以便于栈顶元素能出栈。
}
else
{
*Sqt.top++=p;
p=p->rchild ;
}
}
}
printf("\n");
}

//二叉树的层次遍历算法
void LevelTraverse(BiTree T)
{
LinkQueue Q;
InitQueue(Q);
BiTree p;
EnQueue(Q,T);
while(Q.front!=Q.rear )
{
DeleteQueue(Q,p);
printf("%c ",p->data);
if(p->lchild )
EnQueue(Q,p->lchild);
if(p->rchild )
EnQueue(Q,p->rchild);
}
printf("\n");
}

void main()
{
int length;
BiTree BST;
printf("*************************************************\n");
printf("        二叉树的重建，遍历，求深度算法           \n");
printf("*************************************************\n");
printf("输入的待建二叉树序列为：");
printf("%s",ch);
printf("\n");
CreateBiTree(BST);
printf("\n");
printf("输出先序递归遍历结果：");
PreRecursTraverse(BST);
printf("\n");
printf("\n");
printf("输出先序非递归遍历结果：");
PreOrderTraverse(BST);
printf("\n");
printf("输出中序递归遍历结果：");
InRecursTraverse(BST);
printf("\n");
printf("\n");
printf("输出中序非递归遍历结果：");
InOrderTraverse(BST);
printf("\n");
printf("输出后序递归遍历结果：");
SubRecursTraverse(BST);
printf("\n");
printf("\n");
printf("输出后序非递归遍历结果：");
SubRecursTraverse(BST);
printf("\n");
printf("\n");
printf("输出层序遍历结果：");
LevelTraverse(BST);
printf("\n");
length=depth(BST);
printf("输出二叉树的深度:");
printf("%d\n",length);
printf("\n");
free(BST);
}