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

1，代码如下：

#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);
}

   运行结果图：