pat 1066 二叉平衡树求根节点

给出插入顺序，求二叉平衡树的根节点值

用以前写的模板直接套用即可了。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<stack>
#include<vector>
#include<queue>
#include<string>
#include<map>
using namespace std;
#define INF 99999999
#define M 1000
#define LH +1
#define EH 0
#define RH -1
#define TRUE 1
#define FALSE 0

typedef struct BST
{
	int data;
	int bf;
	struct BST *lchild,*rchild;
}BSTNode;

BSTNode *root;

void R_Rotate(BSTNode * &p)
{
	BSTNode * lc;
	lc=p->lchild;
	p->lchild=lc->rchild;
	lc->rchild=p;
	p=lc;
}

void L_Rotate(BSTNode * &p)
{
	BSTNode *rc;
	rc=p->rchild;
	p->rchild=rc->lchild;
	rc->lchild=p;
	p=rc;
}
void LeftBalance(BSTNode * &T)
{
	BSTNode *lc;
	BSTNode *rd;
	lc=T->lchild;
	switch(lc->bf)
	{
		case LH:   //左子树高，说明插在了左边，直接右旋即可
			T->bf=lc->bf=EH;
			R_Rotate(T);break;
		case RH:   //右子树高，说明插在了左子树的右边，要做2次旋转
			rd=lc->rchild;
			switch(rd->bf)
			{
				case LH:  //插在了右子树的左子树上，那么旋转后。。详情见P235页
					T->bf=RH;lc->bf=EH;break;
				case EH:  //这个情况不可能
					T->bf=lc->bf=EH;break;
				case RH:
					T->bf=EH;lc->bf=LH;break;
			}
			rd->bf=EH;
			L_Rotate(T->lchild);
			R_Rotate(T);
	}
}

void RightBalance(BSTNode * &T)
{
	BSTNode *rc;
	BSTNode *ld;
	rc=T->rchild;
	switch(rc->bf)
	{
		case RH:   //右子树高，说明插在了右边，直接左旋即可
			T->bf=rc->bf=EH;
			L_Rotate(T);break;
		case LH:   //左子树高，说明插在了右子树的做边，要做2次旋转
			ld=rc->lchild;
			switch(ld->bf)
			{
				case LH:  //插在了左子树的左子树上，那么旋转后。。详情见P235页
					T->bf=EH;rc->bf=RH;break;
				case EH:  //这个情况不可能
					T->bf=rc->bf=EH;break;
				case RH:
					T->bf=LH;rc->bf=EH;break;
			}
			ld->bf=EH;
			R_Rotate(T->rchild);
			L_Rotate(T);break;
	}
}


int  InsertAVL(BSTNode * &T,int e,int &taller)
{
	if(T==NULL)
	{
		T=new BSTNode;
		T->data=e;
		T->lchild=T->rchild=NULL;
		T->bf=0;
		taller=TRUE;
		return 1;
	}
	else
	{
		if(e==T->data)
		{
			taller=FALSE;
			return 0;
		}
		if(e<T->data)
		{
			
			if(InsertAVL(T->lchild,e,taller)==0)
				return 0;//未插入
			if(taller==TRUE)   //插入成功后，发现左子树长高了
				switch(T->bf)
				{
					case LH: //原本T的左子树比右子树多1，现在在左边插入了一个，所以肯定多2，要左平衡，平衡后相等		
						LeftBalance(T);taller=FALSE;break;
					case EH:   //原本相等，现在左边插入了一个，肯定左子树比右边多1,树也变高了
						T->bf=LH;taller=TRUE;break;
					case RH:  //原本右边多1，现在相等
						T->bf=EH;taller=FALSE;break;
				}
		}
		else
		{
			if(InsertAVL(T->rchild,e,taller)==0)
				return 0;//未插入
			//printf("here");
			if(taller==TRUE)   //插入成功后，发现右子树长高了
				switch(T->bf)
				{
					case LH: //原本T的左子树比右子树多1，现在在右边插入了一个，所以相等		
						T->bf=EH;taller=FALSE;break;
					case EH:   //原本相等，现在右边插入了一个，肯定右子树比左边多1,树也变高了
						T->bf=RH;taller=TRUE;break;
					case RH:  //原本右边多1，现在右边插入，肯定变2，树也变高了，平衡后相等
						RightBalance(T);taller=FALSE;break;
				}
		}
		return 1;
	}
}

int main()
{
	int i,data,n;
	cin>>n;
	BSTNode *T=NULL;
	int taller;
	for(i=0;i<n;i++)
	{
		scanf("%d",&data);
		InsertAVL(T,data,taller);
	}
	cout<<T->data<<endl;
}