平衡二叉排序树

#include<iostream>
using namespace std;

#define LH 1	//左高
#define EH 0	//等高
#define RH -1	//右高
typedef  int Status;

template<class U>
class BSTNode
{
public:
	template<class U> friend class BBSTree;
private:
	U key;	//关键字
	int bf;	//平衡因子
	BSTNode *lchild ,*rchild;
};

template<class U>
class BBSTree:public BSTNode<U>
{
public:
	void LL_Rotate(BSTNode<U> *&p);//LL型调整，即单向右旋平衡处理
	void RR_Rotate(BSTNode<U> *&p);//RR型调整，即单向左旋平衡处理
	//若在平衡的二叉排序树T中不存在和key相等的关键字的结点，则插入一个新的数据元素key
	//并返回1，否则返回0。若因插入而使二叉排序树失去平衡，则作平衡旋转处理，布尔变量
	//taller反映T长高与否
	Status InsertAVL(BSTNode<U> *&T,U key,bool &taller);
	void LeftBalance(BSTNode<U> *&T);//左旋转平衡处理
	void RightBalance(BSTNode<U> *&T);//右旋转平衡处理
	void PreOrderTraverse(BSTNode<U> *T);//前序遍历平衡二叉排序树
	void visit(U key);             //visit函数用于输出结点元素
};

template<class U>
void BBSTree<U>::LL_Rotate(BSTNode<U> *&p)
{//对以*p为根结点的二叉排序树作单向右旋平衡处理，处理之后*p指向新的根结点，
//即旋转之前左子树的根结点
	BSTNode<U> *lc=NULL;
	lc=p->lchild;	//lc指向左子树根结点
	p->lchild=lc->rchild;//lc的右子树挂在p的左子树上
	lc->rchild=p;	//结点p成为lc的右孩子
	p=lc;			//p指向新的根结点
}//LL_Rotate

template<class U>
void BBSTree<U>::RR_Rotate(BSTNode<U> *&p)
{//对以*p为根结点的二叉排序树作单向左旋平衡处理，处理之后*p指向新的根结点，
//即旋转之前右子树的根结点
	BSTNode<U> *lc=NULL;
	lc=p->rchild;	//lc指向右子树根结点
	p->rchild=lc->lchild;//lc的左子树挂在p的右子树
	lc->lchild=p;		//p成为lc的右孩子
	p=lc;			//p指向新的根结点
}//RR_Rotate

template<class U>
Status BBSTree<U>::InsertAVL(BSTNode<U> *&T,U key,bool &taller)
{
	if(!T)	//T不存在，插入结点为树的根结点，树长高，置taller变为true
	{
		T=new BSTNode<U>;
		T->key=key;
		T->bf=EH;		//只有一个根结点，平衡因子bf为0
		taller=true;	//树的深度加1
		T->lchild=NULL; T->rchild=NULL;
		return 1;
	}
	else
	{
		if(key==T->key)	//树中已存在和e有相同关键字的结点
			{taller=false; return 0;}	//则不再插入
		if(key<T->key)	//关键字key小于树根结点的关键字，在树的左子树中查找
		{
			if(!InsertAVL(T->lchild,key,taller))
				return 0;	//结点未插入
			if(taller)		//结点插入到T的左子树中，且左子树的深度增加
			{
				switch(T->bf)//检查T的平衡度
				{
				case LH:	//原本左子树高于右子树，现左子树深度+1，则平衡被打破，需做平衡处理
					LeftBalance(T); taller=false; break;
				case EH:	//原本左、右子树等高，现左子树深度+1，则根结点T的bf加1，T长高
					T->bf=LH; taller=true; break;
				case RH:	//原本左子树低于右子树，现左子树深度+1，则根结点T的bf变为0，T高度不变
					T->bf=EH; taller=false; break;
				}//switch
			}//if
		}//if
		else
		{
			if(!InsertAVL(T->rchild,key,taller))//右子树中未插入
				return 0;
			if(taller)
			{
				switch(T->bf)//检查T的平衡度
				{
				case LH:	//原本左子树高于右子树，现右子树深度+1，则根结点T的bf变为0，T高度不变
					T->bf=EH; taller=false; break;
				case EH:	//原本左、右子树等高，现右子树深度+1，则根结点T的bf加1，T长高
					T->bf=RH; taller=true; break;
				case RH:	//原本左子树低于右子树，现右子树深度+1，则平衡被打破，需做平衡处理
					RightBalance(T); taller=false; break;
				}//switch
			}//if
		}//else
	}//else
	return 1;
}//InsertAVL

template<class U>
void BBSTree<U>::LeftBalance(BSTNode<U> *&T)
{
	BSTNode<U> *lc=T->lchild,*rd=NULL;//lc指向T的左子树的根结点
	switch(lc->bf)					//检查T的左子树的平衡度，并作相应的平衡处理
	{
	case LH:	//左子树bf为1，新插入的结点在左孩子的左子树上进行LL型调整
		T->bf=EH;	lc->bf=EH;	//调整T和T的左子树的bf=0
		LL_Rotate(T);	break;
	case RH:	//左子树bf为-1，新插入的结点在左孩子的右子树上进行LR型调整
		rd=lc->rchild;	//rd指向T的左孩子的右子树根
		switch(rd->bf)	//修改T及其左孩子的平衡因子
		{
		case LH:
			T->bf=RH; lc->bf=EH;break;
		case EH:
			T->bf=EH; lc->bf=EH;break;
		case RH:
			T->bf=EH; lc->bf=LH;break;
		}//switch
		rd->bf=EH;
		RR_Rotate(T->lchild);//对T的左子树进行左旋平衡
		LL_Rotate(T);		//对T进行右旋平衡
	}//switch
}//LeftBalance

template<class U>
void BBSTree<U>::RightBalance(BSTNode<U> *&T)
{
	BSTNode<U> *lc=T->rchild ,*ld=NULL;//lc指向T的右子树的根结点
	switch(lc->bf)					//检查T的右子树的平衡度，并作相应的平衡处理
	{
	case RH:	//右子树bf为-1，新插入的结点在右孩子的右子树上进行RR型调整
		T->bf=EH;	lc->bf=EH;	//调整T和T的左子树的bf=0
		RR_Rotate(T);	break;
	case LH:	//右子树bf为1，新插入的结点在右孩子的左子树上进行LR型调整
		ld=lc->lchild;	//rd指向T的右孩子的左子树根
		switch(ld->bf)	//修改T及其右孩子的平衡因子
		{
		case LH:
			T->bf=EH; lc->bf=RH;break;
		case EH:
			T->bf=EH; lc->bf=EH;break;
		case RH:
			T->bf=LH; lc->bf=EH;break;
		}//switch
		ld->bf=EH;
		LL_Rotate(T->rchild);//对T的左子树进行左旋平衡
		RR_Rotate(T);		//对T进行右旋平衡
	}//switch
}//RightBalance

template<class U>
void BBSTree<U>::PreOrderTraverse(BSTNode<U> *T)
{
	if(T)   //平衡二叉排序树存在  
    {  
        visit(T->key);                  //访问根结点  
        PreOrderTraverse(T->lchild); //先序遍历左子树  
        PreOrderTraverse(T->rchild); //先序遍历右子树  
    }//if
}//PreOrderTraverse

template<class U>
void BBSTree<U>::visit(U key)
{
	cout<<key<<" ";
}//visit

void main()
{
	BBSTree<int> BBST;
	BSTNode<int> *T=NULL;
	int key;
	bool taller;
	while(cin>>key)
	{
		BBST.InsertAVL(T,key,taller);
	}//while
	BBST.PreOrderTraverse(T);
}//main