实验中序线索化二叉树

前情提要

程序采用cpp文件，实现中序线索化二叉树，采用递归和非递归两种方式输出线索中序序列。

函数操作

TBTNode *CreateTBTNode(char *str);//根据str串创造线索化二叉树
void DispTBTNode(TBTNode *b);//输出线索化二叉树
void Thread(TBTNode *&p);//由CreateThread()调用，对二叉树进行中序线索化
TBTNode *CreateThread(TBTNode *b);//中序线索化二叉树
void InOrder(TBTNode *tb);//中序递归遍历二叉树
void ThInOrder(TBTNode *tb);//在中序线索化二叉树tb中实现递归中序遍历
void ThInOrder1(TBTNode *tb);//在中序线索化二叉树tb中实现非递归中序遍历
void DestroyTBTNode1(TBTNode *tb);//释放中序线索化二叉树bt
void DestroyTBTNode(TBTNode *tb);//释放中序线索化二叉树bt

 

整体代码

#include<stdio.h>
#include<malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
	ElemType data;
	int ltag,rtag;
	struct node *lchild;
	struct node *rchild;
}TBTNode;

TBTNode *CreateTBTNode(char *str);//根据str串创造线索化二叉树
void DispTBTNode(TBTNode *b);//输出线索化二叉树
void Thread(TBTNode *&p);//由CreateThread()调用，对二叉树进行中序线索化
TBTNode *CreateThread(TBTNode *b);//中序线索化二叉树
void InOrder(TBTNode *tb);//中序递归遍历二叉树
void ThInOrder(TBTNode *tb);//在中序线索化二叉树tb中实现递归中序遍历
void ThInOrder1(TBTNode *tb);//在中序线索化二叉树tb中实现非递归中序遍历
void DestroyTBTNode1(TBTNode *tb);//释放中序线索化二叉树bt
void DestroyTBTNode(TBTNode *tb);//释放中序线索化二叉树bt

TBTNode *CreateTBTNode(char *str)
{
	TBTNode *St[MaxSize],*p=NULL,*b;
	int top=-1,k=0,j=0;
	char ch;
	b=NULL;
	ch=str[j];
	while(ch!='\0')
	{
		switch(ch)
		{
		case '(':top++;St[top]=p;k=1;break;
		case ')':top--;break;
		case ',':k=2;break;
		default:p=(TBTNode *)malloc(sizeof(TBTNode));
			p->data=ch;p->lchild=p->rchild=NULL;
			if(b=NULL)
				b=p;
			else
			{
				switch(k)
				{
				case 1:St[top]->lchild=p;break;
				case 2:St[top]->rchild=p;break;
				default :break;
		         }
	         }
          }
			j++;
			ch=str[j];
	}
	return *St;
}

void DispTBTNode(TBTNode *b)
{
	if(b!=NULL)
	{
		printf("%c",b->data);
		if(b->lchild!=NULL||b->rchild!=NULL)
		{
			printf("(");
			DispTBTNode(b->lchild);
			if(b->rchild!=NULL)printf(",");
			DispTBTNode(b->rchild);
			printf(")");
		}
	}
}
TBTNode *pre;
void Thread(TBTNode *&p)
{
	if(p!=NULL)
	{
		Thread(p->lchild);
		if(p->lchild==NULL)
		{
			p->lchild=pre;
			p->ltag=1;
		}
		else p->ltag=0;
		if(pre->rchild==NULL)
		{
			pre->rchild=p;
			pre->rtag=1;
		}
		else pre->rtag=0;
		pre=p;
		Thread(p->rchild);
	}
}

TBTNode *CreateThread(TBTNode *b)
{
	TBTNode *root;
	root=(TBTNode *)malloc(sizeof(TBTNode));
	root->ltag=0;root->rtag=1;
	root->rchild=b;
	if(b==NULL)
		root->lchild=root;
	else
	{
		root->lchild=b;
		pre=root;
		Thread(b);
		pre->rchild=root;
		pre->rtag=1;
		root->rchild=pre;
	}
	return root;
}

void InOrder(TBTNode *tb)
{
	if(tb->lchild!=NULL&&tb->ltag==0)
		InOrder(tb->lchild);
	printf("%c ",tb->data);
	if(tb->rchild!=NULL&&tb->rtag==0)
		InOrder(tb->rchild);
}

void ThInOrder(TBTNode *tb)
{
	InOrder(tb->lchild);
}

void ThInOrder1(TBTNode *tb)
{
	TBTNode *p=tb->lchild;
	while(p!=tb)
	{
		while(p->ltag==0)p=p->lchild;
		printf("%c ",p->data);
		while(p->rtag==1&&p->rchild!=tb)
		{
			p=p->rchild;
			printf("%c ",p->data);
		}
		p=p->rchild;
	}
}

void DestroyTBTNode1(TBTNode *tb)
{
	if(tb!=NULL)
	{
		if(tb->lchild!=NULL&&tb->ltag==0) DestroyTBTNode1(tb->lchild);
		if(tb->rchild!=NULL&&tb->rtag==0) DestroyTBTNode1(tb->rchild);
		free(tb);
	}
}

void DestroyTBTNode(TBTNode *tb)
{
	DestroyTBTNode1(tb->lchild);
	free(tb);
}

void main()
{
	TBTNode *b,*tb;
	b=CreateTBTNode("A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
	printf("二叉树：");
	DispTBTNode(b);
	printf("\n");
	tb=CreateThread(b);
	printf("线索中序序列：\n");
	printf("    递归算法：");ThInOrder(tb);printf("\n");
	printf("  非递归算法：");ThInOrder1(tb);printf("\n");
	DestroyTBTNode(tb);
}

输出