二叉树的基本操作

1.二叉树的建立

2.二叉树的前序遍历的递归形式

3.二叉树的前序遍历的非递归形式

4.二叉树的中序遍历的递归形式

5.二叉树的中序遍历的非递归形式

6.二叉树的后序遍历的递归形式

7.二叉树的后序遍历的非递归形式

8.二叉树的深度

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

using namespace std;

const int MAXSIZE=100;

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

/* 构造空二叉树T */
void InitBiTree(BiTree *T){ 
	*T=NULL;
}

/* #表示空树，构造二叉链表表示二叉树T。 */
void CreateBiTree(BiTree *T)
{ 
    	char ch; 
		cin>>ch;
		if(ch=='#') 
			*T=NULL;
		else
		{
			*T=(BiTree)new(BiTNode);
			if(!*T)
				return;
			(*T)->data=ch; /* 生成根结点 */
			CreateBiTree(&(*T)->lchild); /* 构造左子树 */
			CreateBiTree(&(*T)->rchild); /* 构造右子树 */
		}	
 }



/* 前序递归遍历*/
void PreOrderTraverse(BiTree T)
{ 
	if(T==NULL)
		return;
	cout<<(T->data)<<" ";/* 显示结点数据，可以更改为其它对结点操作 */
	PreOrderTraverse(T->lchild); /* 再先序遍历左子树 */
	PreOrderTraverse(T->rchild); /* 最后先序遍历右子树 */
}
/*非递归前序遍历*/ 
void PreOrderTraverse2(BiTree T){
	stack<BiTree> s;
	BiTree p;//p是遍历指针
	p=T;
	//栈不空或者p不空的时候循环 
	while(p||!s.empty()){
		if(p!=NULL){
			//存入栈 
			s.push(p);
			//访问根结点 
			cout<<(p->data)<<" ";
			//遍历左子树
			p=p->lchild; 
		}
		else{
			//退栈
			p=s.top();
			s.pop(); 
			p=p->rchild;
		}
	} 
}

/* 中序递归遍历T */
void InOrderTraverse(BiTree T)
{ 
	if(T==NULL)
		return;
	InOrderTraverse(T->lchild); /* 再中序遍历左子树 */
	cout<<(T->data)<<" ";/* 显示结点数据，可以更改为其它对结点操作 */
	InOrderTraverse(T->rchild); /* 最后中序遍历右子树 */
}

/*非递归实现中序遍历*/
 void InOrderTraverse2(BiTree T){
	stack<BiTree> s;
	BiTree p;//p是遍历指针
	p=T;
	//栈不空或者p不空的时候循环 
	while(p||!s.empty()){
		if(p!=NULL){
			//存入栈 
			s.push(p);
			//遍历左子树
			p=p->lchild; 
		}
		else{
			p=s.top();
			//访问左结点 
			cout<<(p->data)<<" ";
			//退栈
			s.pop(); 
			//访问右子树 
			p=p->rchild;
		}
	}	
}


/*后序递归遍历 */
void PostOrderTraverse(BiTree T)
{ 
	if(T==NULL)
		return;
	PostOrderTraverse(T->lchild); /* 再后序遍历左子树 */
	PostOrderTraverse(T->rchild); /* 最后序遍历右子树 */
	cout<<(T->data)<<" ";/* 显示结点数据，可以更改为其它对结点操作 */
}

/*后序遍历(非递归)  */
typedef struct BiTNodePost{  
    BiTree biTree;  
    char tag;  
}BiTNodePost,*BiTreePost;  

void PostOrderTraverse2(BiTree T){
	stack<BiTreePost> s;
	BiTree p;
	BiTreePost BT;
	p=T;
	//栈不空或者p不空时循环
	while(p != NULL || !s.empty()){
		//遍历左子树
		while(p){
			BT=(BiTreePost)new(BiTNodePost);
			BT->biTree=p;
			//访问过左子树 
			BT->tag='L';
			s.push(BT); 
			p=p->lchild;
		} 
		//左右子树访问完毕访问根节点
		while(!s.empty() && (s.top())->tag == 'R'){
			BT = s.top();
			//退栈
			s.pop();
			BT->biTree;
		    cout<<(BT->biTree->data)<<" ";
		}
		//遍历右子树
		if(!s.empty()){
			BT = s.top();
			//访问过右子树
			BT->tag = 'R';
			p = BT->biTree;
			p = p->rchild;
		}
	}
} 

void LevelTraverse(BiTree T){
	BiTree p;
	p=T;
	queue<BiTree> q;
	//根结点入队 
	q.push(p);
	//队列不空循环 
	while(!q.empty()){
		//取出队头
		p=q.front();
		cout<<p->data<<" ";
		q.pop();
		if(p->lchild){
			q.push(p->lchild);
		}
		if(p->rchild){
			q.push(p->rchild);
		}
	}
}

/*求二叉树的深度*/
int DepthTree(BiTree T){
	int left=1,right=1;
	if(T==NULL)
		return 0;
	left+=DepthTree(T->lchild);
	right+=DepthTree(T->rchild);
	return left>right?left:right;
} 

/* 初始条件: 二叉树T存在。操作结果: 销毁二叉树T */
void DestroyBiTree(BiTree *T)
{ 
	if(*T) 
	{
		if((*T)->lchild) /* 有左孩子 */
			DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
		if((*T)->rchild) /* 有右孩子 */
			DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
		delete(*T); /* 释放根结点 */
		*T=NULL; /* 空指针赋0 */
	}
}


int main(){
	BiTree T;
	InitBiTree(&T);
	CreateBiTree(&T);
	cout<<"先序遍历："<<endl; 
	PreOrderTraverse(T);
	cout<<endl;
	cout<<"非递归先序遍历："<<endl; 
	PreOrderTraverse2(T);
	cout<<endl;
	cout<<"中序遍历："<<endl; 
	InOrderTraverse(T);
	cout<<endl;
	cout<<"非递归中序遍历："<<endl; 
	InOrderTraverse2(T);
	cout<<endl;
	cout<<"后序遍历："<<endl; 
	PostOrderTraverse(T);
	cout<<endl;
	cout<<"非递归后序遍历："<<endl; 
	PostOrderTraverse2(T);
	cout<<endl;
	cout<<"层次遍历："<<endl; 
	LevelTraverse(T);
	cout<<endl;
	cout<<"树的深度："<<DepthTree(T)<<endl;
	return 0;
} 

输入ABDH#K###E##CFI###G#J##

先序遍历ABDHKECFIGJ

中序遍历HKDBEAIFCGJ

后序遍历KHDEBIFJGCA

层次遍历ABCDEFGHIJK

深度5

代码运行结果