C++实现遍历二叉树的各种遍历操作| 函数模板拿走不送（带解释）！

C++实现遍历二叉树和简单操作

C++代码如下：

#include<iostream> 
#include<queue>    
#include<stack>

using namespace std;

typedef int Status;                   // Status 相当于 int 
typedef char TElemType;               //TElemType 相当于 char


typedef struct BiTNode{
	TElemType data;                   //结点数据域 
	struct BiTNode *lchild,*rchild;   //左右孩子指针 
}BiTNode,*BiTree;

Status PreOrderTraverse(BiTree T)   //递归先序遍历   
{
    if(T==NULL) return 1;          //空二叉树
    else{
         cout << T->data;             //访问根结点 
	     PreOrderTraverse(T->lchild); //先序遍历左子树 
	     PreOrderTraverse(T->rchild); //先序遍历右子树
	    } 
}	

Status InOrderTraverse(BiTree T)    //递归中序遍历  
{
    if(T==NULL) return 1;
    else{
	     InOrderTraverse(T->lchild); //中序遍历左子树 
	     cout << T->data;            //访问根结点 
	     InOrderTraverse(T->rchild); //中序遍历右子树
	    } 
}


Status PostOrderTraverse(BiTree T)  //递归后序遍历 
{
    if(T==NULL) return 1;
    else{
	     PostOrderTraverse(T->lchild); //后序遍历左子树 
	     PostOrderTraverse(T->rchild); //后序遍历右子树
	     cout << T->data;  //访问根结点
	    } 
}	


void InOrderTraverse1(BiTree T)   //非递归中序遍历 
{

	BiTree p; p=T;
	stack<BiTree> s; 
	while(p!=NULL|| !s.empty())
	{
		while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout << p->data;
            s.pop();
            p=p->rchild;
        }
	} // while 
}	

void PreOrderTraverse1(BiTree T)   //非递归先序遍历 
{
    BiTree p;p=T;
    stack<BiTree> s;
    s.push(T);
    while(!s.empty())
    {
        p=s.top();//p为空时相当于栈空
        s.pop();
        if(p!=NULL)
        {
            cout << p->data;
            s.push(p->rchild);//先压右孩子结点，再压左孩子结点
            s.push(p->lchild);
        }
    }
} 
void PostOrderTraverse1(BiTree T)  //非递归后序遍历 
{
    BiTree p;p = T;
    BiTree q=NULL;
    stack<BiTree>s;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        p=s.top();
        if(p->rchild == NULL || p->rchild == q)      
        {      
            cout<<p->data;      
            q = p;      
            s.pop();      
            p = NULL;      
        }      
        else    
            p = p->rchild;      // 否则访问右孩子    
    } 
}

Status Copy(BiTree T,BiTree &NewT)   //复制二叉树 
{
 	if(T==NULL)   //如果是空树，递归结束 
 	{
 		NewT=NULL;
 		return 1;
	}
	else
	{
		NewT=new BiTNode;
		NewT->data=T->data;  //复制根结点 
		Copy(T->lchild,NewT->lchild); //递归复制左子树 
		Copy(T->rchild,NewT->rchild); //递归复制右子树 
	}
} 

int Depth(BiTree T)     //计算二叉树深度 
{
	int m,n;
	if(T==NULL) return 0;   //空树，深度为0，递归结束 
	else
	{
		m=Depth(T->lchild); //递归计算左子树的深度记为m 
		n=Depth(T->rchild); //递归计算右子树的深度记为n 
		if(m>n) return (m+1);//二叉树的深度为m与n的较大者加1 
		else return (n+1);
	}
 } 

int NodeCount(BiTree T)      //统计二叉树中的结点个数 
{
	if(T==NULL) return 0;  //空树，则结点个数为0，递归结束 
	else 
		return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
	//结点个数为左子树的结点个数+右子树的结点个数+1 
 } 
 
int LeadCount(BiTree T)       //计算二叉树叶子结点数 
{
	if(T==NULL) return 0; //如果是空树返回0 
	if(T->lchild==NULL && T->rchild==NULL)
	  return 1;           //如果是叶子结点返回1 
	else
	  return LeadCount(T->lchild)+LeadCount(T->rchild);  
 } 



void CreateBiTree(BiTree &T)  //二叉树的建立 
{
	char ch;
	cin >> ch;
	if(ch=='#') T=NULL; //递归结束，建空树 
	else                //递归创建二叉树
	{
		T=new BiTNode;  //生成根结点 
		//或T=(BiTNode*)malloc(sizeof(BiTNode));
		T->data = ch;   //根结点数据域置为ch 
		CreateBiTree(T->lchild); //递归创建左子树 
		CreateBiTree(T->rchild); //递归创建右子树 
	}
 } //CreateBiTree



int main()
{
	BiTree T;
	BiTree NewT;//空的二叉树用于复制
		
//	cout << "-------简单实现二叉树-------" << endl;
	cout <<  "请按照先序顺序输入每个结点："; 
	CreateBiTree(T); cout << endl;
	
	cout <<"非递归先序遍历：" <<endl;	
	PreOrderTraverse1(T);
	cout << endl <<"递归先序遍历：" <<endl;	
	if(PreOrderTraverse(T))    //先序 
		cout <<  "  先序遍历成功" << endl << endl; 
		
	cout <<"非递归中序遍历：" <<endl;
	InOrderTraverse1(T);
	cout << endl <<"递归中序遍历：" <<endl;
	if(InOrderTraverse(T))    //中序 
		cout <<  "  中序遍历成功" << endl << endl; 
	
	
	cout <<"非递归后序遍历：" <<endl;
	PostOrderTraverse1(T);	 
	cout << endl <<"递归后序遍历：" <<endl;	
	if(PostOrderTraverse(T))    //后序 
		cout <<  "  后序遍历成功" << endl << endl; 
	
	
	cout <<"复制二叉树..."<<endl;
	if(Copy(T,NewT)) cout << "复制成功" << endl << endl; 
	
	int x;
	cout <<"计算二叉树的深度:";
	x=Depth(T); 
	cout << x << endl << endl;
	
	cout <<"二叉树中结点的个数:";
	x=NodeCount(T);
	cout << x << endl << endl; 
	
	cout <<"二叉树叶子结点数:";
    x=LeadCount(T); 
    cout << x << endl;

	
	
	return 0;
}

---

下面加运行结果：
我们输入的是这个二叉树，看下结果

我们按照先序顺序输入：ABC##DE#G##F###