王道数据结构——树

先中后序遍历 递归和非递归

层次遍历

二叉树的中序线索化

中序线索二叉树的中序序列（找后继）和逆中序序列（找前驱）

#include
#include
 
#define Maxsize 100
 
typedef struct BiNode
{
	int data;
	struct BiNode *lchild;
	struct BiNode *rchild;
} BiNode,*BiTree;
 
typedef struct
{
	BiNode* data[Maxsize];
	int top;
}SqStack;
 
typedef struct
{
	BiNode* data[Maxsize];
	int front,rear;
}SqQueue;
 
typedef struct ThreadNode
{
	int data;
	struct ThreadNode *lchild;
	struct ThreadNode *rchild;
	int ltag;
	int rtag;
}ThreadNode,*ThreadTree;
 
 
ThreadNode *pre=NULL;//全局变量pre,指向当前访问结点的前驱 
 
//以下是顺序栈的操作的代码 
void InitStack(SqStack &S)
{
	S.top=-1;
}
 
bool IsEmpty(SqStack S)
{
	if(S.top==-1) return true;
	else return false;
}
 
bool Push(SqStack &S,BiNode* x)
{
	if(S.top==Maxsize-1) return false;
	S.data[++S.top]=x;
	return true;
}
 
void Pop(SqStack &S,BiNode* &x)
{
	if(S.top==-1)
	{
		printf("栈空!\n");
	}
	x=S.data[S.top];
	S.top--;
}
 
void GetTop(SqStack S,BiNode* &y)
{
	y=S.data[S.top];
}
 
void InitTree(BiTree &T)
{
	T->data=1;
	T->lchild=NULL;
	T->rchild=NULL;
}
 
//以下是顺序循环队列操作的代码
 
 
void InitQueue(SqQueue &Q)
{
	Q.front=1;
	Q.rear=1;
}
 
bool IsEmpty(SqQueue Q)
{
	if(Q.front==Q.rear) return true;
	else return false;
}
 
void Push(SqQueue &Q,BiNode* x)
{
	if(Q.front==(Q.rear+1)%Maxsize)
	{
		printf("队满了\n");
	}
	
	Q.data[Q.rear]=x;
	Q.rear=(Q.rear+1)%Maxsize;
}
 
void Pop(SqQueue &Q,BiNode* &y)
{
	if(Q.front==Q.rear)
	{
		printf("队空了\n");
	}
	y=Q.data[Q.front];
	Q.front=(Q.front+1)%Maxsize;
}
 
void GetTop(SqQueue Q,BiNode* &z1)
{
	z1=Q.data[Q.front];
}
 
void GetTail(SqQueue Q,BiNode* &z2)
{
	z2=Q.data[Q.rear-1];
}
 
int LenQueue(SqQueue Q)
{
//	int len;
//	len=(Q.rear-Q.front+Maxsize)%Maxsize;
//	return len;
	
	return (Q.rear+Maxsize-Q.front)%Maxsize;
}
 
//以下是树的操作的代码 
 
void PreOrder1(BiTree T)
{
	if(T!=NULL)
	{
		printf("%d ",T->data);
		PreOrder1(T->lchild);
		PreOrder1(T->rchild);
	}
}
 
void PreOrder2(BiTree T)
{
	SqStack(S);
	InitStack(S);
	BiNode *p=T;
	while(p||!IsEmpty(S))
	{
		if(p)
		{
			printf("%d ",p->data);
			Push(S,p);
			p=p->lchild;
		}
		else
		{
			Pop(S,p);
			p=p->rchild;
		}
	}
}
 
void InOrder1(BiTree T)
{
	if(T!=NULL)
	{
		InOrder1(T->lchild);
		printf("%d ",T->data);
		InOrder1(T->rchild);
	}
}
 
void InOrder2(BiTree T)
{
	SqStack(S);
	InitStack(S);
	BiNode *p=T;
	while(p||!IsEmpty(S))
	{
		if(p)
		{
			Push(S,p);
			p=p->lchild;
		}
		else
		{
			Pop(S,p);
			printf("%d ",p->data);
			p=p->rchild;
		}
	}
}
 
void PostOrder1(BiTree T)
{
	if(T!=NULL)
	{
		PostOrder1(T->lchild);
		PostOrder1(T->rchild);
		printf("%d ",T->data);
	}
}
 
void PostOrder2(BiTree T)
{
	SqStack(S);
	InitStack(S);
	BiNode *p=T;
	BiNode *r=NULL;
	while(p||!IsEmpty(S))
	{
		if(p)
		{
			Push(S,p);
			p=p->lchild;
		}
		else
		{
			GetTop(S,p);
			if(p->rchild&&p->rchild!=r)
			{
				p=p->rchild;
			}
			else
			{
				Pop(S,p);
				printf("%d ",p->data);
				r=p;
				p=NULL;
			}
		}
	}
}
 
void LevelOrder(BiTree T)
{
	SqQueue(Q);
	InitQueue(Q);
	BiNode *p;
	Push(Q,T);
	while(!IsEmpty(Q))
	{
		Pop(Q,p);
		printf("%d ",p->data);
		if(p->lchild!=NULL) Push(Q,p->lchild);
		if(p->rchild!=NULL) Push(Q,p->rchild);
	}
}
 
 
//以下是中序线索化的代码
 
void InitThreadTree(ThreadTree &T)
{
	T->data=1;
	T->lchild=NULL;
	T->rchild=NULL;
}
 
void visit(ThreadNode *q)//线索化就是让没有指向孩子的指针指向前驱或后继并修改ltag和rtag 
{
	if(q->lchild==NULL)//左指针域为空 
	{
		q->lchild=pre;
		q->ltag=1; 
	}
	if(pre!=NULL&&pre->rchild==NULL)左指针域不为空,右指针域为空
	{
		pre->rchild=q;
		pre->rtag=1;
	}
	pre=q; 
}
 
void InThread(ThreadTree T)//中序遍历,在visit里线索化 
{
	if(T!=NULL)
	{
		InThread(T->lchild);
		visit(T);
		InThread(T->rchild);
	}
}
 
void CreateInThread(ThreadTree T)
{
	pre=NULL;
	if(T!=NULL)
	{
		InThread(T);
		if(pre->rchild==NULL)//如果到了最右下的结点,在中序序列中就是最后一个结点 
		{
			pre->rtag=1;
		}
	}
}
 
//中序线索二叉树的逆中序序列
ThreadNode *LastNode(ThreadNode *p)
{
	while(p->rtag==0) p=p->rchild;
	return p;
}
 
ThreadNode *PreNode(ThreadNode *p)
{
	if(p->ltag==0) return LastNode(p->lchild);
	else return p->lchild;
}
 
void RevInOrder(ThreadNode *T)
{
	for(ThreadNode *p=LastNode(T);p!=NULL;p=PreNode(p))
	{
		printf("%d ",p->data);
	}
}
 
//中序线索二叉树的中序序列
 
ThreadNode *FirstNode(ThreadNode *p)
{
	while(p->ltag==0) p=p->lchild;
	return p;
}
 
ThreadNode *NextNode(ThreadNode *p)
{
	if(p->rtag==0) return FirstNode(p->rchild);
	else return p->rchild;
}
 
void InOrder3(ThreadNode *T)
{
	for(ThreadNode *p=FirstNode(T);p!=NULL;p=NextNode(p))
	{
		printf("%d ",p->data);
	}
}
 
int main()
{
	BiTree T=(BiNode*)malloc(sizeof(BiNode));
//	BiNode *T;
 
	InitTree(T);
 
	BiNode *p1=(BiNode*)malloc(sizeof(BiNode));
	p1->data=2;
	p1->lchild=NULL;
	p1->rchild=NULL;
	
	T->lchild=p1;
	
	BiNode *p2=(BiNode*)malloc(sizeof(BiNode));
	p2->data=3;
	p2->lchild=NULL;
	p2->rchild=NULL;
	
	T->rchild=p2;
	
	printf("递归先序序列为:");
	PreOrder1(T);
	printf("\n");
	
	printf("非递归先序序列为:");
	PreOrder2(T);
	printf("\n");
	
	printf("递归中序序列为:");
	InOrder1(T);
	printf("\n");
	
	printf("非递归中序序列为:");
	InOrder2(T);
	printf("\n");
	
	printf("递归后序序列为:");
	PostOrder1(T);
	printf("\n");
	
	printf("非递归后序序列为:");
	PostOrder2(T);
	printf("\n");
	
	printf("层次遍历序列为:");
	LevelOrder(T);
	printf("\n");
	
	
	
	ThreadTree TT=(ThreadNode*)malloc(sizeof(ThreadNode));
	InitThreadTree(TT);
	ThreadNode *p11=(ThreadNode*)malloc(sizeof(ThreadNode));
	p11->data=2;
	p11->lchild=NULL;
	p11->rchild=NULL;
	
	TT->lchild=p11;
	
	ThreadNode *p22=(ThreadNode*)malloc(sizeof(ThreadNode));
	p22->data=3;
	p22->lchild=NULL;
	p22->rchild=NULL;
	
	TT->rchild=p22;
	
	CreateInThread(TT);
	
	printf("中序线索二叉树的逆中序序列为:\n");
	RevInOrder(TT);
	printf("\n");
	
	printf("中序线索二叉树的逆中序序列为:\n");
	InOrder3(TT);
	printf("\n");
	
	return 0;
}