本文解决的问题：

随机产生20个树，构建平衡二叉排序树。

实现代码如下：

#include<stdio.h>
#include<stdlib.h>

#define EH 0            /*等高*/
#define LH 1            /*左高*/
#define RH -1            /*右高*/
typedef struct btnode
{
    int data;
	int BF;
    struct btnode *lchild,*rchild;
}Btnode,*bitree;
int insert_avl_left(bitree *broot,int key,bool *taller);
int insert_avl(bitree *broot,int key,bool *taller);
int avl_left_balance(bitree *broot);
int avl_right_balance(bitree *broot);
int insert_avl_right(bitree *broot,int key,bool *taller);
//右单旋转,解决左左
int avl_left_balance_ll(bitree *broot)
{
	bitree t;
	/*
	int temp=(*broot)->data;
	t=(bitree)malloc(sizeof(btnode));
	t->data=temp;
	(*broot)->data=(*broot)->lchild->data;
	(*broot)->lchild=(*broot)->lchild->lchild;
	(*broot)->rchild=t;
	*/
	t=(*broot)->lchild;
	(*broot)->lchild=NULL;
	if(t->rchild != NULL)
	{
		(*broot)->lchild=t->rchild;
	}
	t->rchild=(*broot);
	(*broot)=t;
	(*broot)->BF=EH;
	(*broot)->lchild->BF=EH;
	return 0;
}
//左右旋转，解决左右
int avl_left_balance_lr(bitree *broot)
{
	bitree t;
	/*
	int temp=(*broot)->lchild->data;
	t=(bitree)malloc(sizeof(btnode));
	t->data=temp;
	(*broot)->lchild->data=(*broot)->lchild->rchild->data;
	(*broot)->lchild->lchild=t;
	*/
	switch((*broot)->lchild->rchild->BF)
	{
		case LH:
			{
				(*broot)->BF=RH;
				(*broot)->lchild->BF=EH;
				(*broot)->lchild->rchild->BF=EH;
				break;
			}
		case EH:
			{
				(*broot)->BF=EH;
				(*broot)->lchild->BF=EH;
				(*broot)->lchild->rchild->BF=EH;
				break;
			}
		case RH:
			{
				(*broot)->BF=EH;
				(*broot)->lchild->BF=LH;
				(*broot)->lchild->rchild->BF=EH;
				break;
			}
	}
	t=(*broot)->lchild;
	(*broot)->lchild=(*broot)->lchild->rchild;
	t->rchild=t->rchild->lchild;
	(*broot)->lchild->lchild=t;
	avl_left_balance_ll(broot);
	return 0;
}

//左单，解决右右
int avl_left_balance_rr(bitree *broot)
{
	bitree t;
	/*
	int temp=broot->data;
	t=(bitree)malloc(sizeof(btnode));
	t->data=temp;
	broot->data=broot->rchild->data;
	broot->rchild=broot->rchild->rchild;
	broot->lchild=t;
	*/
	t=(*broot)->rchild;
	(*broot)->rchild=NULL;
	if(t->lchild != NULL)
	{
		(*broot)->rchild=t->lchild;
	}
	t->lchild=(*broot);
	(*broot)=t;
	(*broot)->BF=EH;
	(*broot)->lchild->BF=EH;
	return 0;
}
//右左旋转，解决右子树插入左侧
int avl_left_balance_rl(bitree *broot)
{
	bitree t;
	/*
	int temp=broot->rchild->data;
	t=(bitree)malloc(sizeof(btnode));
	t->data=temp;
	broot->rchild->data=broot->rchild->lchild->data;
	broot->rchild->rchild=t;
	*/
	switch((*broot)->rchild->lchild->BF)
	{
		case LH:
			{
				(*broot)->BF=EH;
				(*broot)->rchild->BF=RH;
				(*broot)->rchild->lchild->BF=EH;
				break;
			}
		case EH:
			{
				(*broot)->BF=EH;
				(*broot)->rchild->BF=EH;
				(*broot)->rchild->lchild->BF=EH;
				break;
			}
		case RH:
			{
				(*broot)->BF=LH;
				(*broot)->rchild->BF=EH;
				(*broot)->rchild->lchild->BF=EH;
				break;
			}
	}
	t=(*broot)->rchild;
	(*broot)->rchild=(*broot)->rchild->lchild;
	t->lchild=NULL;
	(*broot)->rchild->rchild=t;
	avl_left_balance_rr(broot);
	return 0;
}

//对左子树失衡进行处理
int avl_left_balance(bitree *broot)
{
	bitree t=(*broot)->lchild;
	switch(t->BF){
		case LH://LL型
			return avl_left_balance_ll(broot);
		case RH://LR型
			return avl_left_balance_lr(broot);
	}
	return 0;
}
//对右子树失衡进行处理
int avl_right_balance(bitree *broot)
{
	bitree t=(*broot)->rchild;
	switch(t->BF){
		case LH://RL型
			return avl_left_balance_rl(broot);
		case RH://RR型
			return avl_left_balance_rr(broot);
	}
	return 0;
}
//查找新结点插入的子树
int insert_avl(bitree *broot,int key,bool *taller)
{
	if(key<(*broot)->data)
	{
		//进入左子树操作
		insert_avl_left(broot,key,taller);
		return 0;
	}else
	{
		//进入右子树操作
		insert_avl_right(broot,key,taller);
		return 0;
	}
}

//插入结点，判断平衡
int insert_avl_left(bitree *broot,int key,bool *taller)
{
	if((*broot)->lchild == NULL)
	{
		//如果当前节点的左子树为空，则直接插入
		bitree add;
		add=(bitree)malloc(sizeof(btnode));
		add->BF=EH;
		add->data=key;
		add->lchild=NULL;
		add->rchild=NULL;
		(*broot)->lchild=add;
		(*taller)=true;
	}else{
		insert_avl(&((*broot)->lchild),key,taller);
	}
	if((*taller) == false)
	{
		return 0;
	}
	switch((*broot)->BF){
		case EH:
			{
				(*broot)->BF=LH;
				(*taller)=true;
				return 0;
			}
		case LH:
			{//左高，插入左，失衡
				avl_left_balance(broot);
				(*taller)=false;
				return 0;
			}
		case RH:
			{//右高，插入左，均衡
				(*broot)->BF=EH;
				(*taller)=false;
				return 0;
			}
	}
	return 0;
}

int insert_avl_right(bitree *broot,int key,bool *taller)
{
	if((*broot)->rchild == NULL)
	{
		//如果当前节点的左子树为空，则直接插入
		bitree add;
		add=(bitree)malloc(sizeof(btnode));
		add->BF=EH;
		add->data=key;
		add->lchild=NULL;
		add->rchild=NULL;
		(*broot)->rchild=add;
		(*taller)=true;
	}else{
		insert_avl(&((*broot)->rchild),key,taller);
	}
	if((*taller) == false)
	{
		return 0;
	}
	switch((*broot)->BF){
		case EH:
			{
				(*broot)->BF=RH;
				(*taller)=true;
				return 0;
			}
		case LH:
			{//左高，插入右，均衡
				(*broot)->BF=EH;
				(*taller)=false;
				return 0;
			}
		case RH:
			{//右高，插入右，失衡
				avl_right_balance(broot);
				(*taller)=false;
				return 0;
			}
	}
	return 0;
}

//插入新的结点
int creat_avl(bitree *broot,int key)
{
	bool taller=false;
	if((*broot)->data == NULL)
	{
		(*broot)->data=key;
		(*broot)->BF=EH;
		(*broot)->lchild=NULL;
		(*broot)->rchild;
		return 0;
	}else{
		return insert_avl(broot,key,&taller);
	}
}

void preErgodic_recu(bitree root)
{
	if(root)
	{
		printf("%d ",root->data);
		preErgodic_recu(root->lchild);
		preErgodic_recu(root->rchild);
	}
}


int main(){
	bitree broot;
	int i;
	broot=(bitree)malloc(sizeof(btnode));
	broot->BF=EH;
	broot->data=NULL;
	broot->lchild=NULL;
	broot->rchild=NULL;
	//int a[20]={52,28,45,29,36,35,51,46,47,100,75,59,63,72,68,73,85,76,98,92};
	int a[]={52,28,45,29,36,35,51,46,47,100,75,59,63,72,68,73,85,76,98,92};
	for(i=0;i<20;i++)
	{
		creat_avl(&broot,a[i]);
	}
	preErgodic_recu(broot);
	return 0;
}

如有疑问，请及时提出，谢谢！

———————————————————————————————————————————