用递归和非递归算法实现先序、中序、后序遍历二叉树

#include<iostream>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct StackNode
{
	BiTNode  *data;
	struct StackNode *next; 
} StackNode,*LinkStack;

typedef struct StackNode1
{
	char   data;
	struct StackNode1 *next; 
} StackNode1,*LinkStack1; 

void InitStack(LinkStack &S)  //构造一个空栈 
{
	S=NULL;
//	printf("\t\t\t空栈创建成功\n"); 
}
void InitStack1(LinkStack1 &S)  //构造一个空栈 
{
	S=NULL;
//	printf("\t\t\t空栈创建成功\n"); 
}
void Push(LinkStack &S,BiTNode *e)      //入栈 
{
	 StackNode *p;
     p= new StackNode;	
	 //p=(StackNode *)malloc(sizeof(StackNode));  //生成新节点 
     p->data=e;
	 p->next=S;
	 S=p; 
}
void Push1(LinkStack1 &S,char e)      //入栈 
{
	 StackNode1 *p;
     p= new StackNode1;	
	 //p=(StackNode *)malloc(sizeof(StackNode));  //生成新节点 
     p->data=e;
	 p->next=S;
	 S=p; 
}
 
BiTNode *Pop(LinkStack &S)  //出栈 
{
	BiTNode *e; 
	StackNode *p;
	if(S==NULL) 
	{
		printf("栈为空"); 
	}   
	e=S->data;
	p=S;
	S=S->next;
	delete p;
	return e;
}
char Pop1(LinkStack1 &S)  //出栈 
{
	char e; 
	StackNode1 *p;
	if(S==NULL) 
	{
		printf("栈为空"); 
	}   
	e=S->data;
	p=S;
	S=S->next;
	delete p;
	return e;
}
void PreOrderTraverse(BiTree T)   //先序 
{
	if(T)  						//二叉树非空 
	{        
		 cout<<T->data;	         	//访问根节点 
		PreOrderTraverse(T->lchild);	//先序遍历左子树 		
		PreOrderTraverse(T->rchild);	//先序遍历右子树 
					
	}
}
void InOrderTraverse(BiTree T) 
{
	if(T)  						//二叉树非空 
	{
		InOrderTraverse(T->lchild);	//中序遍历左子树 
		cout<<T->data;					//访问根节点 
		InOrderTraverse(T->rchild);	//中序遍历右子树 
	}
}
void PostOrderTraverse(BiTree T)  	//后序 
{
	if(T)  						//二叉树非空 
	{
		PostOrderTraverse(T->lchild);	//后序遍历左子树 
		PostOrderTraverse(T->rchild);	//后序遍历右子树
		cout<<T->data;					//访问根节点  
	}
}

void CreateBiTree(BiTree &T)
{
	//按先序依次输入二叉树中结点的值，创建二叉链表表示的的二叉树
	char ch;
	cin>>ch;  
	if(ch=='#') T=NULL;
	else 
	{
       T=new BiTNode;
       T->data=ch;
       CreateBiTree(T->lchild);
       CreateBiTree(T->rchild);
	}
} 
void  PreOrderTraverse_Stack(BiTree T)	//先序非递归 
{
	LinkStack S;
	BiTNode *p,*q;
	InitStack(S); 
	p=T;
	while(p||S)
	{
		if(p)
		{
			cout<<p->data; 
			Push(S,p);
			p=p->lchild;
		}
		else 
		{
		  q=Pop(S);
		  p=q->rchild;	
		}
	}	
}
void  InOrderTraverse_Stack(BiTree T)	//中序非递归 
{
	LinkStack S;
	BiTNode *p,*q;
	InitStack(S); 
	p=T;
	while(p||S)
	{
		if(p)
		{
			Push(S,p);
			p=p->lchild;
		}
		else 
		{
		  q=Pop(S);
		  cout<<q->data;
		  p=q->rchild;	
		}
	}	
}
void  PostOrderTraverse_Stack(BiTree T)	//后序非递归 
{
	LinkStack1 S1;
	LinkStack S;
	BiTNode *p,*q;
	char a;
	InitStack(S); 
	InitStack1(S1);
	p=T;
	while(p||S)
	{
		if(p)
		{
			Push1(S1,p->data); 
			Push(S,p);
			p=p->rchild;
		}
		else 
		{
		  q=Pop(S);
		  p=q->lchild;	
		}
	}	
	while(S1)
	{
		a=Pop1(S1);
		cout<<a;
	}
}
main()
{
	int n;
	BiTree T;
	cout<<"请输入您的选择，输入0通过递归算法遍历二叉树，输入1通过非递归算法遍历二叉树。" <<endl; 
	cin>>n;
	switch(n)
	{
	case 0: 
	cout<<"请以先序遍历顺序输入结点的值，并用#表示空"<<endl; 
	CreateBiTree(T);
	cout<<"先序遍历：";
	PreOrderTraverse(T); 
	cout<<endl;
	cout<<"中序遍历：";
	InOrderTraverse(T); 
	cout<<endl;
	cout<<"后序遍历："; 
	PostOrderTraverse(T);
	break;
	case 1:
	cout<<"请以先序遍历顺序输入结点的值，并用#表示空"<<endl; 
	CreateBiTree(T);
	cout<<"非递归先序遍历：";
	PreOrderTraverse_Stack(T); 
	cout<<endl;
	cout<<"非递归中序遍历：";
	InOrderTraverse_Stack(T); 
	cout<<endl;
	cout<<"非递归后序遍历："; 
	PostOrderTraverse_Stack(T);
	break;	
	}
}