二叉树三种（前序中序后序）遍历方式（递归版和非递归版）

递归遍历二叉树比较容易理解，就直接按照遍历方式的定义来做就行了。关键是非递归遍历二叉树。

先说一下递归遍历二叉树，三种序列遍历方式的大致结构是一样的，都是先递归遍历左子树，再递归遍历右子树，区别就在于访问节点的顺序不同，先序遍历是先访问根节点再访问左子树和右子树，所以是在一开始就输出节点值，而中序遍历是先访问左子树再访问根节点最后访问右子树，也就是说在递归遍历完当前节点左子树后进行当前节点值输出，而后序遍历是访问完当前节点左子树和右子树后再进行当前节点值的输出。

而非递归遍历二叉树的实现过程的大体框架也是一样的，与递归遍历的区别就体现在非递归遍历需要我们去用栈来辅助实现，由于递归可以帮我们省去许多细节，而在非递归访问二叉树的实现中就需要单独处理每一个细节了。先看前序遍历，当我们遍历到一个节点时就应该将其输出，所以我们在一开始先输出节点值，再把当前节点存入栈，然后访问左子树，当左子树为空时再取出栈顶元素，此时栈顶元素就是当前元素的父节点（哪一种遍历方式都一样），然后再访问右子树，这就是前序遍历的非递归实现过程，而中序遍历的非递归实现过程也是一样的，只是我们输出节点值的代码不是放在一开始，而是在左子树为空即将访问右子树时进行节点值的输出，其他就与前序遍历的方法是一样的了。最后说一下后序遍历，这个就比较复杂了，我们是先访问左子树和右子树最后才输出根节点的值，所以我们遍历到一个左子树已被访问的节点时，右子树有几种可能的情况，第一种是无右子树，那么直接进行当前节点值的输出即可，第二种情况是有右子树且未被访问，那么这个时候我们就要去访问右子树，最后一种情况就是有右子树且已被访问，那么这个时候就是直接输出当前节点值了，当前节点没有右子树的情况非常容易判断，关键就是在当前节点有右子树的情况下如何判断右子树是否已经被访问过，这个问题在递归访问过程中是不需要考虑的，因为递归完右子树就说明右子树已被访问，但是在非递归访问中就不得不开一个变量记录上一个访问的节点，因为是最后访问右子树，所以如果当前节点的右子树被访问，那么上一个被访问的点一定是当前节点右子树的根节点，利用这一点我们就可以区分当前节点的右子树是否已被访问。

递归版代码（由于具有较高的相似性，所以我就写成了一个函数）

void traverse(BiTree T,int op)
{
	if(T==NULL) return ;
	if(op==1)//先序遍历 
	{
		printf("%c",T->data);
		traverse(T->lchild,op);
		traverse(T->rchild,op);
	}
	else if(op==2)//中序遍历
	{
		traverse(T->lchild,op);
		printf("%c",T->data);
		traverse(T->rchild,op);
	}
	else//后序遍历 
	{
		traverse(T->lchild,op);
		traverse(T->rchild,op);
		printf("%c",T->data);
	}
}

非递归版

前序遍历：

void traverse_qian(BiTree T)//前序遍历
{
	stack s;
	while(T||!s.empty())
	{
		if(T!=NULL)
		{
			printf("%c",T->data);//先序遍历先输出根节点 
			s.push(T);
			T=T->lchild;//先遍历左子树 
		}
		else
		{
			T=s.top();//栈顶元素是该点的父节点 
			s.pop();
			T=T->rchild;//再遍历右子树 
		}
	}
}

中序遍历：

void traverse_zhong(BiTree T)//中序遍历 
{
	stack s;
	while(T||!s.empty())
	{
		if(T!=NULL)
		{
			s.push(T);
			T=T->lchild;//先遍历左子树 
		}
		else
		{
			T=s.top();//栈顶元素是该点的父节点 
			s.pop();
			printf("%c",T->data);//中序遍历是当左子树节点全部遍历后再输出 
			T=T->rchild;//再遍历右子树 
		}
	}
}

后序遍历：

void traverse_hou(BiTree T)//后序遍历
{
	BiTree last=NULL;//上次访问过的点 
	stack s;
	while(T||!s.empty())
	{
		if(T!=NULL)
		{
			s.push(T);
			T=T->lchild;//先遍历左子树 
		}
		else
		{
			T=s.top();
			if(T->rchild!=NULL&&T->rchild!=last)//右子树存在并且未访问过就遍历右子树,右子树根节点若是被访问过也是在当前节点的上一个节点访问的 
			{
				T=T->rchild;//访问右子树
				s.push(T);
				T=T->lchild;
			}
			else//如果右子树不存在或者已经被放问过就直接输出父亲节点并回溯即可 
			{
				s.pop();
				printf("%c",T->data);
				last=T;
				T=NULL;
			}
		}
	}
}

加上一个层次遍历：

void level_order(BiTree T)//层次遍历 
{
	BiTree q[1003];
	int front=0,tail=0;
	q[tail++]=T;
	while(front!=tail)
	{
		BiTree tt=q[front++];
		printf("%c",tt->data);
		if(tt->lchild) q[tail++]=tt->lchild;
		if(tt->rchild) q[tail++]=tt->rchild;
	}
	cout<

再加上一个功能实现某节点到根节点的路径：

void findpass(BiTree T,char s,int &flag)
{
	if(T==NULL) return ;
	if(T->data==s)
	{
		printf("%c",T->data);
		flag=1;
		return ;
	}
	findpass(T->lchild,s,flag);
	if(flag)
	{
		printf("->%c",T->data);
		return ;
	}
	findpass(T->rchild,s,flag);
	if(flag)
	{
		printf("->%c",T->data);
		return ;
	}
}

最后再附上完整代码（建树是按照前序遍历的，注意一定要先建树）：

#include
#include
#include
#include
#include
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateTree(BiTree &T)
{
	char ch;
	scanf("%c",&ch);
	if(ch=='#')
		T=NULL;
	else
	{
		T=(BiTNode*)malloc(sizeof(BiTNode));
		T->data=ch;
		CreateTree(T->lchild);
		CreateTree(T->rchild);
	}
}
void traverse_qian(BiTree T)//前序遍历
{
	stack s;
	while(T||!s.empty())
	{
		if(T!=NULL)
		{
			printf("%c",T->data);//先序遍历先输出根节点 
			s.push(T);
			T=T->lchild;//先遍历左子树 
		}
		else
		{
			T=s.top();//栈顶元素是该点的父节点 
			s.pop();
			T=T->rchild;//再遍历右子树 
		}
	}
}
void traverse_zhong(BiTree T)//中序遍历 
{
	stack s;
	while(T||!s.empty())
	{
		if(T!=NULL)
		{
			s.push(T);
			T=T->lchild;//先遍历左子树 
		}
		else
		{
			T=s.top();//栈顶元素是该点的父节点 
			s.pop();
			printf("%c",T->data);//中序遍历是当左子树节点全部遍历后再输出 
			T=T->rchild;//再遍历右子树 
		}
	}
}
void traverse_hou(BiTree T)//后序遍历
{
	BiTree last=NULL;//上次访问过的点 
	stack s;
	while(T||!s.empty())
	{
		if(T!=NULL)
		{
			s.push(T);
			T=T->lchild;//先遍历左子树 
		}
		else
		{
			T=s.top();
			if(T->rchild!=NULL&&T->rchild!=last)//右子树存在并且未访问过就遍历右子树,右子树根节点若是被访问过也是在当前节点的上一个节点访问的 
			{
				T=T->rchild;//访问右子树
				s.push(T);
				T=T->lchild;
			}
			else//如果右子树不存在或者已经被放问过就直接输出父亲节点并回溯即可 
			{
				s.pop();
				printf("%c",T->data);
				last=T;
				T=NULL;
			}
		}
	}
}
void destory(BiTree &T)
{
	if(T==NULL) return ;
	destory(T->lchild);
	destory(T->rchild);
	T->lchild=T->rchild=NULL;
	free(T);
}
void level_order(BiTree T)//层次遍历 
{
	BiTree q[1003];
	int front=0,tail=0;
	q[tail++]=T;
	while(front!=tail)
	{
		BiTree tt=q[front++];
		printf("%c",tt->data);
		if(tt->lchild) q[tail++]=tt->lchild;
		if(tt->rchild) q[tail++]=tt->rchild;
	}
	cout<data==s)
	{
		printf("%c",T->data);
		flag=1;
		return ;
	}
	findpass(T->lchild,s,flag);
	if(flag)
	{
		printf("->%c",T->data);
		return ;
	}
	findpass(T->rchild,s,flag);
	if(flag)
	{
		printf("->%c",T->data);
		return ;
	}
}
void show()
{
	puts("*******************************************");
	printf("1. 建立二叉树存储结构\n");
	printf("2. 求二叉树的前序遍历\n");
	printf("3. 求二叉树的中序遍历\n");
	printf("4. 求二叉树的后序遍历\n");
	printf("5. 求二叉树的层次遍历\n");
	printf("6. 求指定结点的路径\n");
	printf("7. 退出系统\n");
	puts("*******************************************");
	printf("请输入您的命令:");
} 
void menu(BiTree T)
{
	while(true)
	{
		show();
		int op;
		cin>>op;
		switch(op)
		{
			case 1:
				printf("请输入待建树的先序遍历顺序(节点为空用#代替):");
				getchar();
				CreateTree(T);
				break;
			case 2:
				printf("前序遍历顺序：");
				traverse_qian(T);
				break;
			case 3:
				printf("中序遍历顺序：");
				traverse_zhong(T);
				break;
			case 4:
				printf("后序遍历顺序：");
				traverse_hou(T);
				break;
			case 5:
				printf("层次遍历顺序：");
				level_order(T);
				break;
			case 6:
				{
					int flag=0;
					char s[5];
					printf("请输入结点:");
					scanf("%s",s);
					findpass(T,s[0],flag);
					break;
				}
			case 7:
				printf("成功退出系统！");
				exit(0);
			default:
				printf("命令有误！"); 
		}
		puts("");
		system("pause");
		system("cls");
	}
}
//ABD##EHJ##KL##M#N###CF##G#I##
int main()
{
	BiTree tree;
	menu(tree);
	destory(tree);
	return 0;
}