数据结构：二叉树的链式存储实现

/***********************************************************************************

				程序：二叉树的链式存储实现
				作者：小单
				完成时间:2013年4月25日

*************************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0
#define STACK_INIT_SIZE 100   //栈的存储空间初始化分配量
#define STACKINCREMENT 10
typedef int Status;
typedef int TElemType;

/***************************************************
				二叉树的节点
****************************************************/
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

/********************************************************/



/***********************************************************
			
			  栈的实现

***********************************************************/
typedef BiTree SElemType;
typedef struct  
{
	SElemType *base;  //在栈构造之前和销毁之后，base的值为NULL
	SElemType *top;  //栈顶指针
	int stackSize;   //当前已分配的存储空间
}SqStack;

Status InitStack(SqStack &S)
{
	//构造一个空栈
	S.base = (SElemType *)malloc(sizeof(SElemType) * STACK_INIT_SIZE);
	if(!S.base)
		exit(OVERFLOW);
	S.top = S.base;
	S.stackSize = STACK_INIT_SIZE;
	return OK;
}

Status DestroyStack(SqStack &S)
{
	//销毁栈
	if(S.base == S.top)
		return ERROR;
	free(S.base);
	S.base = NULL;
	S.top = NULL;
	return OK;
}

Status ClearStack(SqStack &S)
{
	//清空栈
	S.top = S.base;
	S.stackSize = 0;
	return OK;

}

Status StackEmpty(const SqStack &S)
{
	//判断栈是否为空
	if(S.top == S.base)  
		return TRUE;  //栈空
	return FALSE;
}

int StackLength(const SqStack &S)
{
	//返回S的元素个数 
	return S.top - S.base;
}

Status GetTop(const SqStack &S, SElemType &e)
{
	//返回栈顶元素
	if(S.top == S.base)
		return ERROR;
	e = *(S.top - 1);
	return OK;
}

Status Push(SqStack &S, const SElemType &e)
{
	//插入元素e为新的栈顶元素
	if(S.top - S.base >= S.stackSize)
	{
		//栈满
		S.base = (SElemType *)realloc(S.base, sizeof(SElemType) * (S.stackSize + STACKINCREMENT));
		if(!S.base)
			exit(OVERFLOW);
		S.top = S.base + S.stackSize;
		S.stackSize += STACKINCREMENT;
	}
	*S.top++ = e;
	return OK;
}

Status Pop(SqStack &S,SElemType &e)
{
	//若栈不空，则删除S的栈顶元素
	if(S.top == S.base )
		return ERROR;
	e = *--S.top;
	return OK;
}

Status Disp(const SElemType &a)
{
	printf("%d\t",a);
	return OK;
}

Status StackTraverse(SqStack S, Status (*Visit)(const SElemType &e))
{
	//从栈底到栈顶依次输出元素
	if(S.top == S.base)
		return ERROR;
	while(S.base < S.top)
	{
		Visit(*S.base++);
	}
	return OK;
}


/*******************************************************
			
			  二叉树功能实现代码

********************************************************/
Status CreateBiTree(BiTree &T)
{//按先序次序输入二叉树
	int a;
	scanf("%d",&a);
	//if(ch == 'q')
	//	exit(0);
	if(a == 0 )
		T = NULL;
	else
	{
		T = (BiTree)malloc(sizeof(BiTNode));
		if(!T)
			exit(OVERFLOW);
		T->data = a;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	return OK;
}

Status PreOrderTraverse(const BiTree T, Status(*Visit)(TElemType e))
{
	//先序递归遍历
	if(T)
	{
		if(Visit(T->data))
			if(PreOrderTraverse(T->lchild,Visit))
				if(PreOrderTraverse(T->rchild,Visit))
					return OK;
		return ERROR;
	}
	return OK;
}

Status PreOrderTraverseExt(const BiTree &T, Status(*Visit)(TElemType e))
{
	//先序非递归遍历
	SqStack S;
	SElemType e;
	InitStack(S);
	Push(S,T);  //根指针入栈
	while(!StackEmpty(S))
	{
		Pop(S,e);  //访问结点
		while(e)
		{
			if(!Visit(e->data))
				return ERROR;
			Push(S,e->rchild); //右孩子入栈
			Push(S,e->lchild);  //左孩子入栈
			Pop(S,e);    //弹出左孩子
		}
		//Pop(S,e);  //弹出空指针
	}
	return OK;
}

Status InOrderTraverse(const BiTree &T, Status(*Visit)(TElemType e))
{
	//中序递归遍历
	if(T)
	{
		if(InOrderTraverse(T->lchild,Visit))
			if(Visit(T->data))
				if(InOrderTraverse(T->rchild,Visit))
					return OK;
		return ERROR;
	}
	return OK;
}

Status InOrderTraverseExt(const BiTree &T, Status(*Visit)(TElemType e))
{
	//中序非递归遍历
	/*SqStack S;
	SElemType e;
	InitStack(S);
	Push(S,T);  //根指针进栈
	while(!StackEmpty(S))
	{
		while(GetTop(S,e) && e)
			Push(S,e->lchild);  //向左走到尽头
		Pop(S,e);   //空指针退栈
		if(!StackEmpty(S))
		{
			//访问结点，向右一步
			Pop(S,e);
			if(!Visit(e->data))
				return ERROR;
			Push(S,e->rchild);
		}
	}
	return OK;*/
	SqStack S;
	SElemType e;
	InitStack(S);
	e = T;
	while(e || !StackEmpty(S))
	{
		if(e)
		{
			Push(S,e);
			e = e->lchild;
		}
		else
		{
			Pop(S,e);
			if(!Visit(e->data))
				return ERROR;
			e = e->rchild;
		}
	}
	return OK;

}

Status PostOrderTraverse(const BiTree &T, Status(*Visit)(TElemType e))
{
	//后序递归遍历
	if(T)
	{
		if(PostOrderTraverse(T->lchild , Visit))
			if(PostOrderTraverse(T->rchild, Visit))
				if(Visit(T->data))
					return OK;
		return ERROR;
	}
	return OK;
}

Status PostOrderTraverseExt(const BiTree &T, Status(*Visit)(TElemType e))
{
	//后序非递归遍历
	SqStack S;
	SElemType e;
	InitStack(S);
	SElemType lastVist = NULL;
	e = T; 
	while(!StackEmpty(S) || e)
	{
		while(e)
		{
			Push(S,e);
			e = e->lchild;//左孩子进栈
		}
		GetTop(S,e);
		if(!e->rchild)
		{  
			//如果结点没有右孩子
			//则说明该访问该结点了	
			if(!Visit(e->data))
				return ERROR;
			Pop(S,lastVist);
			e = e->rchild;
		}
		else if(lastVist == e->rchild)
		{
			//上次访问了它的右孩子
			//则说明该访问该结点了
			if(!Visit(e->data))
				return ERROR;
			Pop(S,lastVist);
			e = NULL;
		}
		else
		{
			e = e->rchild;
		}
	}
	return OK;



}
Status OutData(TElemType e)
{
	//std::cout << e << " ";
	printf("%d\t",e);
	return OK;
}

Status PrintTree(const BiTree &T)
{
	//以嵌套的形式输出二叉树
	if(T)
	{
		printf("%d",T->data);
		if(T->lchild || T->rchild)
		{
			printf("(");
			if(PrintTree(T->lchild))
			{
				if(T->rchild)
					printf(",");
				if(PrintTree(T->rchild))
				{
					printf(")");
				}
			}
		}
		return OK;			
	}
	else
		return OK;

}
int main()
{
	BiTree test;
	printf("请按先序输入数据，0表示空树\n");
	CreateBiTree(test);

	printf("\n先序遍历结果：\n");
	PreOrderTraverse(test,OutData);
	printf("\n先序非递归遍历结果：\n");
	PreOrderTraverseExt(test,OutData);

	printf("\n中序遍历结果：\n");
	InOrderTraverse(test,OutData);
	printf("\n中序非递归遍历结果：\n");
	InOrderTraverseExt(test,OutData);

	printf("\n后序遍历结果：\n");
	PostOrderTraverse(test,OutData);
	printf("\n后序非递归遍历结果:\n");
	PostOrderTraverseExt(test,OutData);

	printf("\n以嵌套括号表示法输出：\n");
	PrintTree(test);
	printf("\n");
	return 0;
}