二叉树的遍历及线索二叉树

标签：数据结构   二叉树   遍历   线索   递归   

"."代表空树，程序分别以先序、中序和后序的方式递归遍历二叉树，再以中序非递归的方式遍历二叉树，并以中序递归方式输出叶子结点并统计叶子结点的个数。最后将二叉树线索化并中序遍历线索二叉树。

#include "stdio.h"
#include "stdlib.h"
typedef struct bithrnode
{
	char data;
	int ltag,rtag;
	struct bithrnode *lchild,*rchild;
}BithrNODE;

int link=0;
int thread=1;
int N0=0;
BithrNODE *pre;

BithrNODE *BithrCreat()
{
	char x;
	BithrNODE *p=NULL;
	scanf("%c",&x);
	if(x=='.')
		return NULL;
	p=(BithrNODE *)malloc(sizeof(BithrNODE));
	p->data=x;
	p->ltag=p->rtag=link;
	p->lchild=BithrCreat();
	p->rchild=BithrCreat();
	return p;
}

void Visit(char ch)
{
	printf("%c ",ch);
}

void  PreOrder(BithrNODE *root) 
/*先序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/
{
	if (root!=NULL)
	{
		Visit(root->data);  /*访问根结点*/
		PreOrder(root->lchild);  /*先序遍历左子树*/
		PreOrder(root->rchild);  /*先序遍历右子树*/
	}
}

void InOrder(BithrNODE * root)
/*中序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/
{
	if(root!=NULL)
	{
		InOrder(root->lchild);   /*中序遍历左子树*/
		Visit(root->data);   /*访问根结点*/
		InOrder(root->rchild);   /*中序遍历右子树*/
	}
}

void PostOrder(BithrNODE * root)
/*后序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/
{
	if(root!=NULL)
	{
		PostOrder(root->lchild);   /*后序遍历左子树*/
		PostOrder(root->rchild);   /*后序遍历右子树*/
		Visit(root->data);   /*访问根结点*/
	}
}

void PreLeaf(BithrNODE * root)
/*前序遍历的叶子结点输出*/
{
	if(root!=NULL)
	{
		if(root->lchild==NULL&&root->rchild==NULL)
		{
			Visit(root->data);
			N0++;
		}
		PreLeaf(root->lchild);
		PreLeaf(root->rchild);
	}
}

void inorder1(BithrNODE * t)
{
	BithrNODE * s[32];	// s是指针数组，数组中元素为二叉树节点的指针
	int top = -1;
	while (t!=NULL || top != -1)
	{
		// 压栈直到左子树为空
		while (t != NULL)
		{
			s[++top] = t;
			t = t->lchild;
		}
		if (top != -1)
		{
			t = s[top--];	// 出栈
			Visit(t->data);
			t = t->rchild;	// 指向该节点的右孩子，回到while循环压栈
		}
	}
}

void InThreading(BithrNODE *a)
{
	if(a)
	{
		InThreading(a->lchild);
		if(!a->lchild)
		{
			a->ltag=thread;
			a->lchild=pre;
		}
		if(!pre->rchild)
		{
			pre->rtag=thread;
			pre->rchild=a;
		}
		pre=a;
		InThreading(a->rchild);
	}
}

BithrNODE *InOrderThreading(BithrNODE *a)
{
	BithrNODE *h=(BithrNODE *)malloc(sizeof(BithrNODE ));
	if(!h)
		exit(-1);
	h->ltag=link;
	h->rtag=thread;
	h->rchild=h;
	if(!a) 
		h->lchild=h;
	else
	{
		h->lchild=a;
		pre=h;
		InThreading(a);
		pre->rtag=thread;
		pre->rchild=h;
		h->rchild=pre;
	}
	return h;
}

void InOrderTraverse(BithrNODE *a)
{
	BithrNODE *p=a->lchild;
	while(p!=a)
	{
		while(p->ltag==link)
			p=p->lchild;
		Visit(p->data);
		while(p->rtag==thread&&p->rchild!=a)
		{
			p=p->rchild;
			Visit(p->data);
		}
		p=p->rchild;
	}
}

int main()
{
	BithrNODE *a=BithrCreat();
	printf("先序遍历二叉树: ");
	PreOrder(a);
	printf("\n中序遍历二叉树: ");
	InOrder(a);
	printf("\n后序遍历二叉树: ");
	PostOrder(a);
	printf("\n叶子结点: ");
	PreLeaf(a);
	printf("\n叶子结点个数: ");
	printf("%d",N0);
	printf("\n中序非递归遍历: ");
	inorder1(a);
	printf("\n中序线索化二叉树，中序遍历所建立的线索二叉树: ");
	a=InOrderThreading(a);
	InOrderTraverse(a);
	printf("\n");
	return 0;
}

二叉树的遍历及线索二叉树

标签：数据结构   二叉树   遍历   线索   递归   

原文地址：http://blog.csdn.net/jackeriss/article/details/40725067