线索二叉树的创建和遍历

1、采用书上第 133 页定义的线索二叉树的线索链表存储表示，编程实现线索二叉树的下列基本操作。
（1）建立先序线索二叉树 （2）建立中序线索二叉树 （3）建立后序线索二叉树
（4）先序遍历线索二叉树 （5）中序遍历线索二叉树 （6）后序遍历线索二叉树

//测试样例---输入：ABC##DE#G##F###   //

分布实现

1：

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

Status PrintElement(TElemType e) {
	printf("%c", e);
	return OK;
}
typedef enum PointerTag{Link ,Thread};

typedef struct BiThrNode {
	TElemType data;
	struct BiThrNode* lchild, * rchild;
	PointerTag LTag, RTag;
}BiThrNode,*BiThrTree;
BiThrTree pre;
Status CreateBiThrTree(BiThrTree &T) {
	char ch;
	scanf("%c", &ch);
	if (ch == '#')T = NULL;
	else {
		if (!(T = (BiThrNode*)malloc(sizeof(BiThrNode))))
			exit(OVERFLOW);
		T->data = ch;
		CreateBiThrTree(T->lchild);
		if (T->lchild != NULL) T->LTag = Link;
		CreateBiThrTree(T->rchild);
		if (T->rchild != NULL) T->RTag = Link;
	}
	return OK;
}
	
void  InThreading(BiThrTree p) {
	if (p) {
		InThreading(p->lchild);
		if (!p->lchild)
		{
			p->LTag = Thread; p ->lchild = pre;
		}
		if (!pre->rchild)
		{
			pre->RTag = Thread; pre->rchild = p;
		}
		pre = p;
		InThreading(p->rchild);
	}
}
Status InOrderThreading(BiThrTree& Thrt, BiThrTree T) {
	if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))exit(OVERFLOW);
	Thrt->LTag = Link; Thrt->RTag = Thread;
	Thrt->rchild = Thrt;
	if (!T)Thrt->lchild = Thrt;
	else {
		Thrt->lchild = T; pre = Thrt;
		InThreading(T);
		pre->rchild = Thrt; pre->RTag = Thread;
		Thrt->rchild = pre;
	}
	return OK;
}
Status InOrderTraverse_Thr(BiThrTree T, Status (*Visit)(TElemType e)) {
	BiThrNode* p;
	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; Visit(p->data);
		}
		p = p->rchild;
	}
	return OK;
}


int main()
{
	BiThrTree T, Thrt;
	printf("创建线索二叉树，按先序次序输入线索二叉树中结点的值：\n");
	CreateBiThrTree(T);
	if (InOrderThreading(Thrt, T) == OK)printf("成功建立中序线索化链表！\n");
	printf("中序遍历线索二叉树，结果是：\n");
	InOrderTraverse_Thr(Thrt, PrintElement);
	printf("\n");
}

2~3：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define OK	1
#define OVERFLOW -2
typedef int Status;
typedef char TElemType;
typedef enum PointterTag { Link, Thread };
typedef struct BiThrNode
{
	TElemType data;
	struct BiThrNode* lchild, * rchild;
	PointterTag LTag, RTag;
}BiThrNode, * BiThrTree;
BiThrTree pre;
Status CreateBiThrTree(BiThrTree& T)
{
	char ch;
	scanf("%c", &ch);
	if (ch == '#')	T = NULL;
	else
	{
		if (!(T = (BiThrNode*)malloc(sizeof(BiThrNode))))	exit(OVERFLOW);
		T->data = ch;
		CreateBiThrTree(T->lchild);
		if (T->lchild != NULL)	T->LTag = Link;
		CreateBiThrTree(T->rchild);
		if (T->rchild != NULL)	T->RTag = Link;
	}
	return OK;
}
void InThreading(BiThrTree p)
{
	if (p)
	{
		InThreading(p->lchild);
		if (!p->lchild) { p->LTag = Thread; p->lchild = pre; }
		if (!pre->rchild) { pre->RTag = Thread; pre->rchild = p; }
		pre = p;
		InThreading(p->rchild);
	}
}
Status PreOrderThreading(BiThrTree& Thrt, BiThrTree T)
{
	if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))	exit(OVERFLOW);
	Thrt->LTag = Link;	Thrt->RTag = Thread;
	Thrt->rchild = Thrt;
	if (!T)	Thrt->lchild = Thrt;
	else
	{
		Thrt->lchild = T; pre = Thrt;
		InThreading(T);
		pre->rchild = Thrt;	pre->RTag = Thread;
		Thrt->rchild = pre;
	}
	return OK;
}
Status PrintElement(TElemType e)
{
	printf("%c", e);
	return OK;
}
Status PreOrderTraverse_Thr(BiThrTree T)
{
	BiThrTree p = T->lchild;
	while (p != T)
	{
		while (p->LTag == Link) {
			PrintElement(p->data);
			p = p->lchild;
		}
		PrintElement(p->data);
		while (p->RTag == Thread && p->rchild != T)
		{
			p = p->rchild;	
		}
		p = p->rchild;
	}
	return OK;
}
int main()
{
	BiThrTree T, Thrt;
	printf("创建线索二叉树，按先序次序输入线索二叉树中结点的值：\n");
	CreateBiThrTree(T);
	if (PreOrderThreading(Thrt, T) == OK)	printf("成功建立先序线索化链表！\n");
	printf("先序遍历线索二叉树，结果是：\n");
	PreOrderTraverse_Thr(Thrt);
	printf("\n");
	return OK;
}
9.3
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define Link	0	
#define Thread	1
#define  OK  1
typedef int Status;
typedef struct BiThrNode
{
	char Data;
	struct BiThrNode* lchid, * rchild, * parent;
	int Ltag;
	int Rtag;
}BiThrNode, * BiThrTree;
BiThrTree Pre;
BiThrTree Temp;
Status CreateThreadTree(BiThrTree& Tree, BiThrTree Parent = NULL)
{
	char Data;
	scanf("%c", &Data);
	if (Data == '#')
		Tree = NULL;
	else
	{
		Tree = (BiThrNode*)malloc(sizeof(BiThrNode));
		Tree->parent = Parent;
		Tree->Data = Data;
		Tree->Ltag = Link;
		Tree->Rtag = Link;
		CreateThreadTree(Tree->lchid, Tree);
		CreateThreadTree(Tree->rchild, Tree);
	}
	Temp = Tree;
	return OK;
}
Status PostOrderThread(BiThrTree& Tree)
{
	if (Tree == NULL)
		return OK;

	PostOrderThread(Tree->lchid);
	PostOrderThread(Tree->rchild);

	if (Tree->lchid == NULL)
	{
		Tree->lchid = Pre;
		Tree->Ltag = Thread;
	}
	if (Pre != NULL && Pre->rchild == NULL)
	{
		Pre->rchild = Tree;
		Pre->Rtag = Thread;
	}

	Pre = Tree;
	return OK;
}
void PostOrder(BiThrTree& Tree)
{
	BiThrTree p = Tree;
	Pre = NULL;
	while (p != NULL)
	{
		while (p->Ltag == Link)
		{
			p = p->lchid;
		}

		while (p != NULL && p->Rtag == Thread)
		{

			printf("%c ", p->Data);
			Pre = p;
			p = p->rchild;
		}

		while (p != NULL && p->rchild == Pre)
		{

			printf("%c ", p->Data);

			if (p == Tree)
				return;
			Pre = p;
			p = p->parent;
		}

		if (p != NULL && p->Rtag == Link)
		{
			p = p->rchild;
		}
	}
	printf("%c ", Temp->Data);
	return;
}
int main()
{
	BiThrTree T;
	printf("创建线索二叉树，按先序次序输入线索二叉树中结点的值：\n");
	CreateThreadTree(T);
	if(PostOrderThread(T))	printf("成功建立后序线索化链表！\n");
	printf("后序遍历线索二叉树，结果是：\n");
	PostOrder(T);
	return 0;
}