平衡二叉树

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

#define LH (1)
#define EH (0)
#define RH (-1)

typedef struct BSTNode {
	int key;
	int bf;
	struct BSTNode * lchild, * rchild;
} BSTNode, * BSTree;

// 右旋处理
void R_Rotate(BSTree &p) {
	// 对*p为根的二叉排序树做右旋处理，即旋转之后p指向新的树根节点，即旋转处理之前左孩子树的根节点。
	BSTree lc = p->lchild;
	p->lchild = lc->rchild;
	lc->rchild = p;
	p = lc;
} // R_Rotate

// 左旋处理
void L_Rotate(BSTree &p) {
	// 对*p为根的二叉树做左旋处理
	BSTree rc = p->rchild;
	p->rchild = rc->lchild;
	rc->lchild = p;
	p = rc;
} // L_Rotate

int Compare(int key1, int key2) {
	if(key1 > key2)
		return LH;
	else if(key1 == key2) 
		return EH;
	return RH;
}

void LeftBalance(BSTree &T)
{
	// 对指针T所指节点的二叉树左左旋平衡处理，算法结束指针T指向"新"的节点
	BSTree lc = T->lchild;
	switch(lc->bf) 
	{
	case LH:
		T->bf = lc->bf = EH;
		R_Rotate(T);
		break;
	case RH:
		BSTree rd = lc->rchild;
		switch(rd->bf) 
		{
		case LH:
			T->bf = RH; lc->bf = EH;	break;
		case EH:
			T->bf = lc->bf = EH;		break;					// 该标签不会调用
		case RH:
			T->bf = EH; lc->bf = LH;	break;
			break;
		}
		rd->bf = EH;
		L_Rotate(T->lchild);
		R_Rotate(T);
		break;
	} // switch(lc->bf)

} // LeftBalance

void RightBalance(BSTree &T) 
{
	BSTree rc = T->rchild;
	BSTree rd = rc->lchild;
	switch(rc->bf)
	{
	case LH:
		
		switch(rd->bf)
		{
			case LH: T->bf = EH; rc->bf = RH;	break;
			case EH: T->bf = rc->bf = EH;		break;			// 该标签不会调用
			case RH: T->bf = LH; rc->bf = EH;	break;
		}
		rd->bf = EH;
		R_Rotate(T->rchild);
		L_Rotate(T);
		break;

	case RH:
		T->bf = rc->bf = EH;
		L_Rotate(T);
		break;
	}
}

bool Insert(BSTree &T, int key, bool &taller) {
	// 插入节点为1，否则返回0，若因插入而使二叉树失去平衡，则做平衡旋转，taller反应T是否长高
	// child表示旋转之后子树的根节点

	if( !T ) 
	{
		T = (BSTree) malloc(sizeof(BSTNode));
		T->key = key;
		T->rchild = T->lchild = NULL;
		T->bf = EH;										//	标识插入节点为等高
		taller = true;									//	插入之后高度增加
	} // if(!T))
	else 
	{
		if(EH == Compare(T->key, key)) 
		{
			taller = true;
			return false;
		} 
		
		if(LH == Compare(T->key, key))
		{
			if(!Insert(T->lchild, key, taller)) 
				return 0;								// 未插入返回

			if(true == taller) 
			{
				switch(T->bf) 
				{
					// 在该处做左旋处理
					case LH: 
						LeftBalance(T); taller = false; 
						break;
					case  EH:
						T->bf = LH; taller = true; 
						break;
					case RH:
						T->bf = EH; taller = false;
						break;
				} // switch(T->bf)
			} // if(true == taller)
		} 
		else 
		{
			if(!Insert(T->rchild, key, taller)) 
				return 0;								// 未插入数据

			if(true == 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;
				}
			}
		} // else

	} // else (!T)

} // Insert

void Print(BSTree &T) 
{
	if(T) 
	{
			printf("%d ", T->key);
		Print(T->lchild);
	
		Print(T->rchild);
	}
}

void main() {
	BSTree T = NULL;
	bool taller = false;
	Insert(T, 13, taller);
	Insert(T, 24, taller);
	Insert(T, 37, taller);
	Insert(T, 90, taller);
	Insert(T, 53, taller);
	Insert(T, 60, taller);
	Insert(T, 40, taller);
	Insert(T, 50, taller);
	Print(T);
	system("pause");
}