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

#define  Ok 1
#define  Error 0
#define max 20
#define Status int 
#define LH 1
#define EH 0
#define RH -1
typedef struct Btree{
	Btree *lchild;
	Btree *rchild;
	int   data;
	int bf;//用来记录该节点所处的状态0,1或-1
}Btree,*Bitree;//平衡二叉树节点的结构体
/*Btree *creattree(Bitree &b)//用来创建二叉树的，但是算法中有从根节点创建的语句，所以这一步就省略了
{
	int ch1;
	scanf("%d",&ch1);
	if(ch1==0)
		b=NULL;
	else
	{
		b=(Btree*)malloc(sizeof(Btree));
		if(!b)  exit(1);
		b->data=ch1;
		printf("请输入%d的左节点",b->data);
		b->lchild=creattree(b->lchild);
		printf("请输入%d的右节点",b->data);
		b->rchild=creattree(b->rchild);
	}
	return b;
}*/
Status inital(Bitree &b)//初始化树
{
	b=(Btree*)malloc(sizeof(Btree));//不先初始化给树一个地址的话，在主函数里b是传递不进去的，会报错
	b=NULL;
	return 1;
}
bool  EQ(int i,int j)
{
   if(i==j)
	   return 1;
   else 
	   return 0;
}
bool LT(int i,int j)
{
	if(i<j)
		return 1;
	else 
		return 0;
}
void R_Rotate(Bitree &p)//单项右旋处理
{
	Bitree lc;
	lc=p->lchild; //需要将p与他的左孩子节点旋转
	p->lchild=lc->rchild;//将左孩子的右节点给根节点做左孩子节点
	lc->rchild=p;//让根节点做它以前左孩子结点的右孩子节点
	p=lc;//转换根节点
}
void L_Rotate(Bitree &p)//单项左旋处理
{
	Bitree lc;
	lc=p->rchild; //道理同上
	p->rchild=lc->lchild;
	lc->lchild=p;
	p=lc;
}
void leftBalance(Bitree &t)//当以t为根节点已经左子树比右子树多1个高度的情况下再向左子树叶子节点插入一个节点
{
	Bitree lc,rd;
	lc=t->lchild;
	switch(lc->bf){//查看插入后t的左孩子的状态
	case LH://如果插入后左子树比右子树高
		t->bf=lc->bf=EH;//重置t和他左子树的状态
		R_Rotate(t);//进行单向右旋处理
		break;
	case RH://如果插入后右子树比左子树高，须进行双旋处理
		rd=lc->rchild;
		switch(rd->bf)//这一步得根据分析的图来进行旋转后的赋值
		{
	   case LH:
		   t->bf=RH; lc->bf=EH;
		break;
	   case RH:
		   t->bf=EH; lc->bf=LH;
		   break;
	   case EH:
		   t->bf=lc->bf=EH;
		   break;
		}
		break;
		rd->bf=EH;
	   L_Rotate(t->lchild);//先对t的左孩子节点做单向做平衡处理
	   R_Rotate(t);//再对t做单向右平衡处理
	}
}
void RightBalance(Bitree &t)//当以t为根节点已经右子树比左子树多1个高度的情况下再向右子树叶子节点插入一个节点
{
	Bitree rc,ld;
	rc=t->rchild;
	switch(rc->bf)
	{
	case RH:
		rc->bf=t->bf=EH;
		L_Rotate(t);
		break;               //同上
	case LH:
		ld=rc->lchild;
		switch(ld->bf)
		{
		case RH:  t->bf=LH; rc->bf=EH;
			break;
		case LH:   t->bf=EH; rc->bf=RH;
			break;
		case EH:   t->bf=rc->bf=EH;
			break;
		}
		ld->bf=EH;
		R_Rotate(t->rchild);
		L_Rotate(t);
		break;
	}
}
Status InsertAVL(Bitree &t,int e,bool &taller)//插入平衡二叉树的节点函数
{
	if(!t){                              //插入节点成功
	  t=(Bitree)malloc(sizeof(Btree));
	  t->data=e;  t->lchild=t->rchild=NULL; 
	  t->bf=EH;   taller=true;
	}
	else {
		if(EQ(e,t->data))   //如果插入的节点在树中已经是存在的了，那么不用查了，
		{taller=false; return 0;}
		if(LT(e,t->data))//如果插入的节点是在左子树中
		{
			if(!InsertAVL(t->lchild,e,taller))  return 0;//一直递归到要插入的叶子节点的位置
			if(taller)//如果成功插入一个叶子节点，需要看它是否符合平衡二叉树要求，再修改
			{
				switch(t->bf)
				{
				case LH://如果它的父节点在插入前就是左子树比右子树大的话
					leftBalance(t);  taller=false;  //当以t为根节点已经左子树比右子树多1个高度的情况下再向左子树叶子节点插入一个节点
					break;
				case EH://如果它的父节点在插入前就是左子树与右子树高度相等时
					t->bf=LH;  taller=true; //记录父节点左子树比右子树高1
					break;
				case RH://如果它的父节点在插入前就是左子树比右子树小1的话
					t->bf=EH;  taller=false;//此时父节点左右子树相等
					break;
				}
			}
		}
	    else {  //当插入的节点在右子树的话。。。。。道理同上
				if(!InsertAVL(t->rchild,e,taller))  return 0;
				if(taller)
				{
					switch(t->bf)
					{
					case LH:
						t->bf=EH;  taller=false;
						break;
					case EH:
						t->bf=RH; taller =true;
						break;
					case RH:
						RightBalance(t);  taller=false;
						break;
					}
				}
			}
	}
	return 1;
}
Status Showtree(Bitree t)
{
	if(t)
	{
		if(Showtree(t->lchild))
		{
			printf("%d\n",t->data);
			if(Showtree(t->rchild))
				return Ok;
		}
	}
	else return Ok;
}
void main()
{
	Bitree t;
	int e;  bool taller;
	/*printf("请输入根节点");
	creattree(t);*/
   inital(t); 
	printf("请输入要插入的节点(输入0结束)");
	scanf("%d",&e);
	while(e!=0)
	{
	 InsertAVL(t,e,taller);
	 scanf("%d",&e);
	}
	printf("平衡二叉树的中序序列为：\n");
	Showtree(t);
	getchar();
	getchar();
}
//算法分析：1.平衡二叉树的要求：(1)它的左右子树都是平衡二叉树(2)它的左右子树的深度只差的绝对值不超过1
           //2.在平衡二叉树上进行查找过程和排序树相同，进行比较的关键字个数不超过树的深度
          //3.进行查找的时间复杂度为O(logn)