数据结构 二叉树的线索存储

#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>


#define  OK             1
#define  ERROR          0
#define  OVERFLOW       -2


typedef char TElemType;
typedef enum {Link,Thread} PointerTag;

typedef struct BiThrNode
{
	TElemType data;
	struct BiThrNode *lchild,*rchild;
	PointerTag LTag;
	PointerTag RTag;
}BiThrNode, *BiThrTree;


BiThrTree pre;

void Create_BiThrTree(BiThrTree &T)
{
	TElemType ch;
	cin >> ch;
	if (ch == '#')
	{
		T = NULL;
	}
	else
	{
		T = (BiThrTree)malloc(sizeof(BiThrNode));
		if (!T)
		{
			exit(OVERFLOW);
		}
		T->data = ch;
		Create_BiThrTree(T->lchild);
		if (T->lchild)
		{
			T->LTag = Link;
		}
		Create_BiThrTree(T->rchild);
		if (T->rchild)
		{
			T->RTag = Link;
		}
	}
}


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

int 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;
}


int InOrderTraverse_Thr(BiThrTree T)
{
	BiThrTree p;
	p = T->lchild;
	while (p != T)
	{
		while (p->LTag == Link)
		{
			p = p->lchild;
		}
		printf("%c",p->data);
		while (p->RTag == Thread && p->rchild != T)
		{
			p = p->rchild;
			printf("%c",p->data);
		}
		p = p->rchild ;
	}
	return OK;
}



int main()
{
	BiThrTree T,H;
	Create_BiThrTree(T);
	InOrderThreading(H,T);
	InOrderTraverse_Thr(T);
	printf("\n");
	return 0;
}