数据结构上机作业（2）—— 树的创建，遍历，求树深

程序功能：

1. 先序拓展序列建立二叉树的存储结构
2. 二叉树 先序，中序，后序遍历的递归算法
3. 二叉树中序遍历非递归算法
4. 二叉树层次遍历非递归算法
5. 求二叉树的深度（后序）
6. 建立数的存储结构
7. 求树的深度

/*
上机序号：13-19
程序功能：13.先序拓展序列建立二叉树的存储结构； 14.二叉树 先序，中序，后序遍历的递归算法 15.二叉树中序遍历非递归算法
		  16.二叉树层次遍历非递归算法  17.求二叉树的深度（后序）18.建立数的存储结构 19.求树的深度

*/
#include <stdio.h>
#include <malloc.h> 
#include<stdlib.h>
#define MAXSIZE 100
#define OVERFLOW -2
#define OK 1
#define TRUE 1
#define FALSE 0
#define ERROR -1 
typedef int Status;
typedef char TElemType;

//二叉树的存储结构-二叉存储表示
typedef struct BiTNode {  // 二叉树结点结构
	TElemType      data;
	struct BiTNode* lchild, *rchild;   // 左右孩子指针
} BiTNode, *BiTree;

//树的存储结构 -孩子兄弟表示
typedef struct CSNode {
	TElemType  data;
	struct CSNode* firstchild, *nextsibling;
} CSNode, *CSTree;

typedef  BiTree SElemType;
typedef CSTree QElemType;

//队列存储结构
typedef struct {
	QElemType data[MAXSIZE];
	int f;//头指针
	int r;//尾指针
}SqQueue;

//栈的存储结构-循环队列
typedef struct SqStack {
	SElemType data[MAXSIZE];
	int top;//指向栈顶元素
}SqStack;




//**************队列的基本操作*********************************************************

//初始化空队列
void initQueue(SqQueue* Q) {
	Q->f = Q->r = 0;
}
//入队
void enQueue(SqQueue* Q, QElemType e) {
	//先判断队列是否已满
	if (Q->f == (Q->r + 1) % MAXSIZE) {
		return;
	}
	Q->data[Q->r] = e;
	Q->r = (Q->r + 1) % MAXSIZE;
}

//出队
void deQueue(SqQueue* Q) {
	//先判断队列是否为空
	if (Q->f == Q->r) {
		return;
	}
	Q->f = (Q->f + 1) % MAXSIZE;
}

//队头元素
QElemType GetHead(SqQueue* Q) {
	return Q->data[Q->f];
}
//**************栈的基本操作*********************************************************

//创建
void initStack(SqStack* s) {
	s->top = 0;
}
//判栈空
int isEmpty(SqStack* s) {
	if (s->top == 0) {
		return OK;
	}
	else
		return FALSE;
}
//栈顶元素
Status getTop(SqStack* s, BiTree& e) {
	if (!isEmpty(s))
	{
		e = s->data[s->top - 1]; return OK;
	}
	else
		return FALSE;
}
//入栈
void push(SqStack* s, SElemType& e) {
	s->data[s->top] = e;
	s->top++;
}
//出栈
void pop(SqStack* s, SElemType& e) {
	if (!isEmpty(s)) {
		e = s->data[s->top - 1];
		s->top--;
	}
	else
		printf("此栈为空栈，出栈操作失败\n");
}

//**************二叉树的基本操作*************************************************

//按照先序遍历的拓展序列建立二叉树的存储结构 
Status CreateBiTree(BiTree& T) {
	char ch;
	scanf_s("%c", &ch, 1);
	if (ch == '#') T = NULL;
	else {
		if (!(T = (BiTNode*)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		T->data = ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	return OK;
}

//访问
int visit(TElemType e)
{
	printf("%c ", e);
	return OK;
}
//先序遍历二叉树 
void Preorder(BiTree T, int(*visit)(TElemType e))
{
	if (T) {
		visit(T->data);
		Preorder(T->lchild, visit);
		Preorder(T->rchild, visit);
	}
}
// 中序遍历二叉树 
void Inorder(BiTree T, int(*visit)(TElemType e))
{
	if (T) {
		Inorder(T->lchild, visit);
		visit(T->data);
		Inorder(T->rchild, visit);
	}
}
// 后序遍历二叉树 
void Postorder(BiTree T, int(*visit)(TElemType e))
{
	if (T) {
		Postorder(T->lchild, visit);
		Postorder(T->rchild, visit);
		visit(T->data);
	}
}
//中序遍历的非递归算法 
Status InOrderTraverse(BiTree T, Status(*Visit)(TElemType e))
{
	SqStack s;
	SqStack* S = &s;
	BiTree p; p = NULL;
	initStack(S);
	push(S, T);   //根指针进栈
	while (!isEmpty(S)) {
		while (getTop(S, p) && p) push(S, p->lchild);
		pop(S, p);   //空指针退栈
		if (!isEmpty(S)) {  //访问节点，退后一步
			pop(S, p); if (!visit(p->data))   return ERROR;
			push(S, p->rchild);
		}  //if
	}  //while
	return OK;
}

//二叉树的层次遍历的非递归算法
void LevelOrderTraverse(BiTree T, Status(Visit)(TElemType))
{
	int i, j;
	BiTree p[100];					//树指针数组
	i = j = 0;
	if (T)
		p[j++] = T;
	while (i < j)
	{
		Visit(p[i]->data);
		if (p[i]->lchild)
			p[j++] = p[i]->lchild;
		if (p[i]->rchild)
			p[j++] = p[i]->rchild;
		i++;
	}
}
// 求二叉树的深度
int Depth(BiTree T) {
	int depthval, depthLeft, depthRight;
	if (!T)     depthval = 0;
	else {
		depthLeft = Depth(T->lchild);
		depthRight = Depth(T->rchild);
		depthval = 1 + (depthLeft > depthRight ? depthLeft : depthRight);
	}
	return depthval;
}

//*****************树的基本操作*********************************************************

// 创建结点
CSTree GetTreeNode(TElemType item)
{
	CSTree T;
	if (!(T = (CSNode*)malloc(sizeof(CSNode))))
		exit(1);
	T->data = item;
	T->firstchild = NULL;
	T->nextsibling = NULL;
	return T;
}
//建立树的存储结构 
void CreatTree(CSTree& T)
{
	T = NULL;
	char fa, ch;
	CSTree p, s, r; r = NULL;
	SqQueue q;
	SqQueue* Q; Q = &q;
	initQueue(Q);
	getchar();
	for (scanf_s("%c%c", &fa, 1, &ch, 1); ch != '#'; scanf_s("%c%c", &fa,1, &ch,1))
	{
		getchar();
		p = GetTreeNode(ch);    // 创建结点
		enQueue(Q, p);       // 指针入队列
		if (fa == '#')  T = p;   // 所建为根结点
		else {	 // 非根结点的情况
			s = GetHead(Q);   // 取队列头元素(指针值)
			while (s->data != fa)  // 查询双亲结点
			{
				deQueue(Q); s = GetHead(Q);
			}
			if (!(s->firstchild))
			{
				s->firstchild = p; r = p;
			}   // 链接第一个孩子结点
			else { r->nextsibling = p;  r = p; }   // 链接其它孩子结点 
		}
	}
}
//求树的深度 
int TreeDepth(CSTree T)
{
	int h1, h2;
	if (!T)  return 0;
	else {
		h1 = TreeDepth(T->firstchild);
		h2 = TreeDepth(T->nextsibling);
		if (h1 + 1 > h2) h2 = h1 + 1;
		return h2;
	}
}

int main()
{
	printf("***********二叉树**********\n");
	BiTree T; T = NULL;

	printf("13.为建立二叉树，请输入先序遍历的扩展序列\n");
	CreateBiTree(T);

	printf("14.1.先序遍历二叉树递归算法：\n");
	Preorder(T, visit);
	printf("\n");

	printf("14.2.中序遍历二叉树递归算法：\n");
	Inorder(T, visit);
	printf("\n");

	printf("14.3.后序遍历二叉树递归算法：\n");
	Postorder(T, visit);
	printf("\n");

	printf("15.中序遍历二叉树非递归算法：\n");
	InOrderTraverse(T, visit);
	printf("\n");

	printf("16.层次遍历二叉树非递归算法：\n");
	LevelOrderTraverse(T, visit);
	printf("\n");

	int depth; depth = Depth(T);
	printf("17.二叉树的深度是：%d\n", depth);


	printf("***********树*************\n");
	CSTree CT; CT = NULL;
	printf("18.为建立树，请输入父子对\n");
	CreatTree(CT);

	int Tdepth; Tdepth = TreeDepth(CT);
	printf("19.树的深度是：%d\n", Tdepth);
}
/*
二叉树的测试用例
ACE###GD###

树的测试用例
#A
AB
AC
AD
CE
CF
FG
##

*/