严蔚敏数据结构二叉树及二叉树的线索化

头文件Tree.h

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_TREE_SIZE 100
#define OVERFLOW -1
#define OK 1
#define ERROR -1
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef char TElemType;
typedef TElemType SqBiTree[MAX_TREE_SIZE];
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
BiTree CreatTree()
{
	BiTree T;
	char c = getchar();
	getchar();
	if (c == '#')
		T = NULL;
	else
	{
		T = (BiTree)malloc(sizeof(BiTNode));
		if (!T) exit(OVERFLOW);
		T->data = c;
		T->lchild = CreatTree();
		T->rchild = CreatTree();
	}
	return T;
}
Status PreOrderTraverse(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;
	}
	else
		return OK;
}


//用到的栈的数据结构（遍历二叉树的非递归方法）
#define STACK_INIT_SIZE 100
#define STACKINCREASMENT 10
typedef BiTree SElemType;
typedef struct
{
	SElemType* base, * top;
	int stacksize;
}SqStack;
Status Push(SqStack* S, SElemType e)
{
	if (S->top - S->base >= S->stacksize)
	{
		SElemType* base;
		base = (SElemType*)realloc(S->base, (S->stacksize + STACKINCREASMENT) * sizeof(SElemType));
		if (!base) exit(OVERFLOW);
		S->base = base;
		S->top = S->base + S->stacksize;
		S->stacksize += STACKINCREASMENT;
	}
	*S->top = e;
	S->top++;
	return OK;
}
Status Pop(SqStack* S, SElemType* e)
{
	if (S->top == S->base) return ERROR;
	S->top--;
	*e = *S->top;
	return OK;
}
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;
}
SElemType GetTop(SqStack S)
{
	return *(S.top - 1);
}
Status StackEmpty(SqStack S)
{
	if (S.top == S.base)
		return TRUE;
	return FALSE;
}
Status InOrderTraverse_1(BiTree T, Status(*Visit)(TElemType e))  //P130算法6.2
{
	SqStack* S;
	SElemType p;
	S = (SqStack*)malloc(sizeof(SqStack));
	if (!S) exit(OVERFLOW);
	InitStack(S);
	Push(S, T);
	p = GetTop(*S);
	while (!StackEmpty(*S))
	{
		while (p)
		{
			Push(S, p->lchild);
			p = GetTop(*S);
		}
		Pop(S, &p);
		if (!StackEmpty(*S))
		{
			Pop(S, &p);
			if (!Visit(p->data)) return ERROR;
			p = p->rchild;
			Push(S, p);
		}
	}
	return OK;
}
Status InOrderTraverse_2(BiTree T, Status(*Visit)(TElemType e))       //P131算法6.3
{
	SqStack* S;
	S = (SqStack*)malloc(sizeof(SqStack));
	if (!S) exit(OVERFLOW);
	InitStack(S);
	BiTNode* p = T;
	while (!StackEmpty(*S) || p)
	{
		if(p)
		{
			Push(S, p);
			p = p->lchild;
		}
		else
		{
			Pop(S, &p);
			if (!Visit(p->data))
				return ERROR;
			p = p->rchild;
		}
	}
	return OK;
}



//线索二叉树
typedef enum { LINK, THREAD } PointerTag;    //LINK为0，THREAD为1
typedef struct BiThrNode
{
	TElemType data;
	struct BiThrNode* lchild, * rchild;
	PointerTag LTag, RTag;
}BiThrNode, * BiThrTree;
BiThrTree CreatTree_Thr()
{
	BiThrTree T;
	char c = getchar();
	getchar();
	if (c == '#')
		T = NULL;
	else
	{
		T = (BiThrTree)malloc(sizeof(BiThrNode));
		if (!T) exit(OVERFLOW);
		T->data = c;
		T->lchild = CreatTree_Thr();
		if (T->lchild != NULL)
			T->LTag = LINK;
		T->rchild = CreatTree_Thr();
		if (T->rchild != NULL)
			T->RTag = LINK;
	}
	return T;
}
Status InOrderTraverse_Thr(BiThrTree T, Status(*Visit)(TElemType e))
{
	BiThrNode* p = T->lchild;
	while (p != T)
	{
		while (p->LTag == LINK)
			p = p->lchild;
		if (!Visit(p->data))
			return ERROR;
		while (p->RTag == THREAD && p->rchild != T)
		{
			p = p->rchild;
			if (!(Visit)(p->data))
				return ERROR;
		}
		p = p->rchild;
	}
	return OK;
}
void InThreading(BiThrNode* p,BiThrNode **pre)          //P135算法6.7
{
	if (p)
	{
		InThreading(p->lchild, pre);
		if (!p->lchild)
		{
			p->lchild = *pre;
			p->LTag = THREAD;
		}
		if (!(*pre)->rchild)
		{
			(*pre)->rchild = p;
			(*pre)->RTag = THREAD;
		}
		*pre = p;
		InThreading(p->rchild, pre);
	}
}
Status InOrderThreading(BiThrTree Thrt, BiThrTree T)     //P134算法6.6
{
	Thrt->LTag = LINK;
	Thrt->RTag = THREAD;
	Thrt->rchild = Thrt;
	if (!T)
		Thrt->lchild = Thrt;
	else
	{
		Thrt->lchild = T;
		BiThrNode* pre = Thrt, * p = T;
		InThreading(p, &pre);
		pre->RTag = THREAD;
		pre->rchild = Thrt;
		Thrt->rchild = pre;
	}
	return OK;
}

c文件：

#include "Tree.h"
//中序遍历主函数
Status Print(TElemType e)
{
	putchar(e);
	printf("\t");
	return OK;
}
int main()
{
	BiThrTree T, Thrt;
	T = CreatTree_Thr();
	Thrt = (BiThrTree)malloc(sizeof(BiThrNode));
	if (!Thrt) exit(OVERFLOW);
	InOrderThreading(Thrt, T);
	Status* Visit;
	Visit = Print;
	InOrderTraverse_Thr(Thrt, Visit);
	return OK;
}

输入：（P129图6-9）

-
+
a
#
#
*
b
#
#
-
c
#
#
d
#
#
/
e
#
#
f
#
#

输出：