二叉树创建、遍历的递归和非递归实现

#include <stack>
#include <queue>
#include <iostream>
#include <cstdlib>
using namespace std;

typedef char TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//递归方式创建二叉树
void CreateBiTree(BiTree* T)
{
	TElemType ch;
	cin>>ch;
	if(ch=='#')
		*T = NULL;
	else
	{
		*T = (BiTree)malloc(sizeof(BiTNode));
		if(!*T)
			cout<<"malloc error!"<<endl;
		(*T)->data = ch;
		CreateBiTree(&(*T)->lchild);
		CreateBiTree(&(*T)->rchild);
	}
}

//非递归方式创建二叉树
void CreateBiTreeByCircle(BiTree* T,const char* p)
{
	stack<BiTNode*> stak;
	while(1)
	{
		TElemType ch = *p++;;
		//cin>>ch;
		if(ch=='#')
		{
			*T = NULL;
			if(stak.empty())
				break;
			else
			{
				BiTNode *s = stak.top();
				T = &s->rchild;
				stak.pop();
			}
		}
		else
		{
			*T = (BiTNode*)malloc(sizeof(BiTNode));
			if(!*T)
				cout<<"malloc error!"<<endl;
			(*T)->data = ch;
			stak.push(*T);
			T = &(*T)->lchild;
		}
	}
}

//递归前序遍历
void preOrderBiTree(BiTree T)
{
	if(NULL==T)
		return;
	cout<<T->data;
	preOrderBiTree(T->lchild);
	preOrderBiTree(T->rchild);
}

//非递归前序遍历
void preOrderBiTreeByCircle(BiTree T)
{
	stack<BiTNode*> stak;
	while(T!=NULL || !stak.empty())
	{
		while(T!=NULL)
		{
			cout<<T->data;
			stak.push(T);
			T = T->lchild;
		}
		if(!stak.empty())
		{
			T = stak.top();
			T = T->rchild;
			stak.pop();
		}
	}
}

//递归中序遍历
void midOrderBiTree(BiTree T)
{
	if(NULL==T)
		return;
	midOrderBiTree(T->lchild);
	cout<<T->data;
	midOrderBiTree(T->rchild);
}

//非递归中序遍历
void midOrderBiTreeByCircle(BiTree T)
{
	stack<BiTNode*> stak;
	while(T!=NULL || !stak.empty())
	{
		while(T!=NULL)
		{
			stak.push(T);
			T = T->lchild;
		}
		if(!stak.empty())
		{
			T = stak.top();
			cout<<T->data;
			stak.pop();
			T = T->rchild;
		}
	}
}

//递归后序遍历
void postOrderBiTree(BiTree T)
{
	if(NULL==T)
		return;
	postOrderBiTree(T->lchild);
	postOrderBiTree(T->rchild);
	cout<<T->data;
}

//非递归后序遍历
void postOrderBiTreeByCircle(BiTree T)
{
	stack<BiTNode*> stak;
	queue<BiTNode*> que;
	while(T!=NULL || !stak.empty())
	{
		while(T!=NULL)
		{
			stak.push(T);
			T = T->lchild;
		}
		BiTNode *s;
		BiTNode *pre = NULL;
		do{
			s = stak.top();
			if(s->rchild==NULL || s->rchild==pre)
			{
				cout<<s->data;
				pre = s;//保存前面一次遍历到的节点
				stak.pop();
			}
			else
				T = s->rchild;
		}while(!T && !stak.empty());
	}
}

//非递归层序遍历
void levelOrderBiTree(BiTree T)
{
	queue<BiTNode*> que;
	que.push(T);
	while(!que.empty())
	{
		BiTNode *s = que.front();
		que.pop();
		cout<<s->data;
		if(s->lchild!=NULL)
			que.push(s->lchild);
		if(s->rchild!=NULL)
			que.push(s->rchild);
	}
}

//测试函数
int main()
{
	char* p = "ABDH#K###E##CFI###G#J##";//扩展二叉树的前序遍历（只能针对前序遍历创建二叉树）
	BiTree biTree;
	CreateBiTreeByCircle(&biTree,p);
	preOrderBiTreeByCircle(biTree);
	cout<<endl;
	midOrderBiTreeByCircle(biTree);
	cout<<endl;
	postOrderBiTreeByCircle(biTree);
	cout<<endl;
	levelOrderBiTree(biTree);
}

结果：