二叉树遍历的递归和非递归实现（C语言）

/*
 * Description:
 *           二叉搜索树的相关操作（创建，插入节点，前、中、后序递归和非递归遍历二叉树）
 * Author  :FinL
 * Language: C
 * Date    : 2010-08-29
 */

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

typedef struct Node{
	int data;
	Node *leftchild;
	Node *rightchild;
}Node;


/*
 初始化一棵二叉树排序树。
*/
void InitBinaryTree(Node**root,int elem)
{
	*root=(Node*)malloc(sizeof(Node));
	if(!(*root))
	{
		printf("Memory allocation for root failed.\n");
		return;
	}
	(*root)->data=elem;
	(*root)->leftchild=NULL;
	(*root)->rightchild=NULL;
}

/*
 向二叉树排序树中插入结点。
*/
void InsertNode(Node *root,int elem)
{
	Node *newnode=NULL;
	Node *p=root,*last_p=NULL;

	newnode=(Node*)malloc(sizeof(Node));
	if(!newnode)
	{
		printf("Memory allocation for newnode failed.\n");
		return;
	}
	newnode->data=elem;
	newnode->leftchild=NULL;
	newnode->rightchild=NULL;

	while(NULL!=p)
	{
		last_p=p;
		if(newnode->data<p->data)
		{
			p=p->leftchild;
		}
		else if(newnode->data>p->data)
		{
			p=p->rightchild;
		}
		else
		{
			printf("Node to be inserted has existed.\n");
			free(newnode);
			return;
		}
	}
	p=last_p;
	if(newnode->data<p->data)
	{
		p->leftchild=newnode;
	}
	else
	{
		p->rightchild=newnode;
	}
}

/*
 创建一棵二叉树排序树。
*/
void CreatBinarySearchTree(Node **root,int data[],int num)
{
	int i;

	for(i=0;i<num;i++)
	{
		if(NULL==*root)
		{
			InitBinaryTree(root,data[i]);
		}
		else
		{
			InsertNode(*root,data[i]);
		}
	}
}


/*
 前序遍历二叉树，递归方法。
*/
void PreOrderRec(Node *root)
{
	if(NULL!=root)
	{
		printf("%d  ",root->data);
		PreOrderRec(root->leftchild);
		PreOrderRec(root->rightchild);
	}
}


/*
 前序遍历二叉树，非递归方法。
*/
void PreOrderNoRec(Node *root)
{
	Node *p=root;
	Node *stack[30];
	int num=0;
	while(NULL!=p||num>0)
	{
		while(NULL!=p)
		{
			printf("%d  ",p->data);
			stack[num++]=p;
			p=p->leftchild;
		}
		num--;
		p=stack[num];
		p=p->rightchild;
	}
	printf("\n");
}


/*
 中序遍历二叉树，递归方法。
*/
void InOrderRec(Node *root)
{
	if(NULL!=root)
	{
		InOrderRec(root->leftchild);
		printf("%d  ",root->data);
		InOrderRec(root->rightchild);
	}
}

/*
 中序遍历二叉树，非递归方法，使用栈。
*/
void InOrderNoRec(Node *root)
{
	Node *p=root;
	int num=0;
	Node *stack[30];
	while(NULL!=p||num>0)
	{
		while(NULL!=p)
		{
			stack[num++]=p;
			p=p->leftchild;
		}
		num--;
		p=stack[num];
		printf("%d  ",p->data);
		p=p->rightchild;
	}
	printf("\n");
}

/*
 后序遍历二叉树，递归方法。
*/
void PostOrderRec(Node *root)
{
	if(NULL!=root)
	{
		PostOrderRec(root->leftchild);
		PostOrderRec(root->rightchild);
		printf("%d  ",root->data);
	}
}

/*
 后序遍历二叉树，非递归方法。
*/
void PostOrderNoRec(Node *root)
{
	Node *p=root;
	Node *stack[30];
	int num=0;
	Node *have_visited=NULL;

	while(NULL!=p||num>0)
	{
		while(NULL!=p)
		{
			stack[num++]=p;
			p=p->leftchild;		
		}
		p=stack[num-1];
		if(NULL==p->rightchild||have_visited==p->rightchild)
		{
			printf("%d  ",p->data);
			num--;
			have_visited=p;
			p=NULL;
		}
		else
		{
			p=p->rightchild;
		}
	}
	printf("\n");
}

int main()
{
	Node *root=NULL;
	int num=0;
	int data[]={5,2,4,0,0,5,0,0,3,6,8,0,10,0,7,0,9};
	num=sizeof(data)/sizeof(int);

	CreatBinarySearchTree(&root,data,num);

	printf("This is Preorder traversal.\n");
	PreOrderNoRec(root);
	PreOrderRec(root);
	printf("\n");

	printf("This is Inorder traversal.\n");
	InOrderNoRec(root);
	InOrderRec(root);
	printf("\n");

	printf("This is Postorder traversal.\n");
	PostOrderNoRec(root);
	PostOrderRec(root);
	printf("\n");

	return 0;

}