二叉树各种基础算法合集

三种方法创建二叉树，并对其进行四种遍历和求二叉树的高度，判断二叉树是否为完全二叉树
更新于20181120，github上有备份
代码：

#include <iostream>
#include <stdlib.h>
#define maxSize 1000 
using namespace std;
typedef struct BTNode{
	int data,h;
	struct BTNode *lchild,*rchild;
}BTNode;
typedef struct BTree{
	char c;
	struct BTree *lchild,*rchild;
}BTree;
//创建二叉树 （平衡二叉树法） 
//二叉树样式 
//      6
//   3     8
//2    4  7   9
bool create(BTNode *&T, char x){
	if(T==NULL){
		T = (BTNode*)malloc(sizeof(BTNode));
    	T->data = x;
		T->lchild=T->rchild=NULL;//生成结点
    	return true;
	}
	if(x<T->data)
    	create(T->lchild,x);//构造左子树
	else
		create(T->rchild,x);//构造右子树 
}
//先序遍历二叉树
void preOrder(BTNode *p){
	if(p!=NULL){
		cout<<p->data;
		preOrder(p->lchild);
		preOrder(p->rchild);
	}
}
//中序遍历二叉树
void midOrder(BTNode *p){
	if(p!=NULL){
		midOrder(p->lchild);
		cout<<p->data;
		midOrder(p->rchild);
	}
}
//后序遍历二叉树
void postOrder(BTNode *p){
	if(p!=NULL){
		cout<<p->data;
		postOrder(p->lchild);
		postOrder(p->rchild);
	}
}
//非递归求二叉树高度
void high(BTNode *p){
	BTNode *q[maxSize];
	int i=0,j=0,max=0;
	q[j++]=p;
	q[i]->h=1;
	while(i!=j){
		if(q[i]->h>max)
			max=q[i]->h;//记录遍历过程中的最大高度 
		if(q[i]->lchild!=NULL){
			q[j]=q[i]->lchild;
			q[j++]->h=q[i]->h+1;//子树的深度为父节点深度+1 
		}
		if(q[i]->rchild!=NULL){
			q[j]=q[i]->rchild;
			q[j++]->h=q[i]->h+1;//子树的深度为父节点深度+1 
		}
		i++;//模拟出队	
	} 
	cout<<max;
}	
//递归求二叉树高度
int high1(BTNode *p){
	if(p==NULL){
		return 0;
	} 
	int m=high1(p->lchild)+1;//左子树的高度 
	int n=high1(p->rchild)+1;//右子树的高度 
	return m>n?m:n; 
} 

//---------------------------------------------------------
//创建二叉树(先序输入法）
//输入：ABC##DE#G##F### 
//		  A
//		 /   
//		B     
//	   / \  
//	  C   D 
//	 /\	 / \
//	    E	F 
//	   / \ /\    
//	     G
//	       
BTree *create1(){
	char c;
	c=getchar();
	BTree *B;
	if(c=='#'){
		B=NULL;
	}else{
		B= (BTree*)malloc(sizeof(BTree));
		B->c=c;
		B->lchild=create1();
		B->rchild=create1(); 
	}	
	return B;
} 
//先序遍历二叉树(用于先序输入法创造的二叉树） 
void preOrder1(BTree *p){
	if(p!=NULL){
		cout<<p->c;
		preOrder1(p->lchild);
		preOrder1(p->rchild);
	}
}
//中序遍历二叉树(用于先序输入法创造的二叉树） 
void midOrder1(BTree *p){
	if(p!=NULL){
		midOrder1(p->lchild);
		cout<<p->c;
		midOrder1(p->rchild);
	}
}
//后序遍历二叉树(用于先序输入法创造的二叉树） 
void postOrder1(BTree *p){
	if(p!=NULL){
		postOrder1(p->lchild);
		postOrder1(p->rchild);
		cout<<p->c;
	}
}
//层次遍历
void level(BTree *b){
	BTree *q[maxSize];
	int i=0,j=0;
	q[j++]=b;
	while(i!=j){
		cout<<q[i]->c<<" ";
		if(q[i]->lchild!=NULL){
			q[j++]=q[i]->lchild;
		}
		if(q[i]->rchild!=NULL){
			q[j++]=q[i]->rchild;
		}
		i++;
	}	
} 
//判断二叉树是否为完全二叉树
bool isCompleteBTree(BTree *b){
	BTree *q[maxSize]={NULL};
	int i=0,j=0;
	q[j++]=b;
	while(i!=j){	
		if(q[i]){
			q[j++]=q[i]->lchild;
			q[j++]=q[i]->rchild;
		}else{
			while(i!=j){
				if(q[i+1]!=NULL)
					return false;
				i++;
			}
			return 1;
		}
		i++;
	}
	return 1;	
}
//递归求先序输入法创造的二叉树高度
int high2(BTree *p){
	if(p==NULL){
		return 0;
	} 
	int m=high2(p->lchild)+1;//左子树的高度 
	int n=high2(p->rchild)+1;//右子树的高度 
	return m>n?m:n; 
} 

//------------------------------------------
//通过先序和中序构造二叉链表
//目标二叉树
//		  A
//		 /   
//		B     
//	   / \  
//	  C   D 
//	 /\	 / \
//	    E	F 
//	   / \ /\    
//	     G
//先序a[]={ABCDEGF};
//中序b[]={CBEGDFA};
BTree* create2(char a[],int l1,int h1,char b[],int l2,int h2){
//l1,h1为第一个数组第一结点和最后一个结点，l2,h2为第二个数组第一个结点和最后一个结点 
	BTree *root;//根结点 
	int i=l2;//记录每趟递归中数组a的第一个数在原数组中的位置  
	root= (BTree*)malloc(sizeof(BTree));
	root->c=a[l1];
	while(b[i]!=a[l1]) i++;//cout<<i<<endl;//用于计算两边左子树和右子树长度
	int llen=i-l2;//cout<<"llen:"<<llen<<endl;//左子树长度 
	int rlen=h2-i;//cout<<"rlen:"<<rlen<<endl;//右子树长度
	if(llen)
		root->lchild=create2(a,l1+1,l1+llen,b,l2,l2+llen-1);
		//递归左子树 
	else
		root->lchild=NULL;
	if(rlen)
		root->rchild=create2(a,h1-rlen+1,h1,b,h2-rlen+1,h2);
		//递归右子树 
	else
	    root->rchild=NULL;
	return root;
} 
int main()
{
	int a[]={6,3,8,2,4,7,9,1};
	char m[]={' ','A','B','C','D','E','G','F'};
	char n[]={' ','C','B','E','G','D','F','A'};
	char m1[]={' ','A','B','D','E','C','F','G'};
	char n1[]={' ','D','B','E','A','F','C','G'};
	struct BTNode *p=NULL;
	cout<<"平衡二叉法创建二叉树："<<endl;
	for(int i = 0;i<8;i++)
		create(p,a[i]);
	cout<<"先序遍历：";
	preOrder(p);
	cout<<endl<<"中序遍历：";
	midOrder(p);
	cout<<endl<<"后序遍历：";
	postOrder(p);
	cout<<endl<<"非递归求二叉树高度：";
	high(p);
	cout<<endl<<"递归求二叉树高度：";
	cout<<high1(p);
	
	cout<<endl<<"---------------------------------------"; 
	cout<<endl<<"先序输入法创建二叉树：";
	//输入：ABC##DE#G##F###  可直接复制到控制台 
	BTree *b=create1();
	cout<<"先序遍历："; 
	preOrder1(b);
	cout<<endl<<"中序遍历："; 
	midOrder1(b);
	cout<<endl<<"后序遍历："; 
	postOrder1(b);
	cout<<endl<<"层次遍历：";
	level(b); 
	cout<<endl<<"二叉树高度："; 
	cout<<high2(b);
	 
	cout<<endl<<"---------------------------------------";
	cout<<endl<<"通过先序和中序创建二叉树：";
	BTree *r=NULL; 
	r=create2(m,1,7,n,1,7);
	cout<<endl<<"先序遍历："; 
	preOrder1(r);
	cout<<endl<<"中序遍历："; 
	midOrder1(r);
	cout<<endl<<"后序遍历："; 
	postOrder1(r);
	cout<<endl<<"层次遍历：";
	level(r); 
	cout<<endl<<"二叉树高度："; 
	cout<<high2(r);
	cout<<endl<<"二叉树是否为完全二叉树(1表示真，0表示否):";
	cout<<isCompleteBTree(r); 
	//创建一棵完全二叉树测试 
	BTree *r1=NULL; 
	r1=create2(m1,1,7,n1,1,7);
	cout<<endl<<"二叉树是否为完全二叉树(1表示真，0表示否):";
	cout<<isCompleteBTree(r1); 
	
	cout<<endl<<"---------------------------------------";
	
}

测试结果