AVL树的旋转操作

代码：

#include<iostream>
using namespace std;
#define LH +1 
#define EH 0 
#define RH -1 
#define NULL 0   
typedef struct BSTNode 
{  
int data;  
int bf;  
struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;  
void CreatBST(BSTree &T); 
void R_Rotate (BSTree &p); 
void L_Rotate(BSTree &p); 
void LeftBalance(BSTree &T); 
void RightBalance(BSTree &T);  
bool InsertAVL(BSTree &T,int e,bool &taller); 
bool SearchBST(BSTree &T, int key); 
void LeftBalance_div(BSTree &p, int &shorter); 
void RightBalance_div(BSTree &p, int &shorter);
void Delete(BSTree q, BSTree  &r, int &shorter); 
int DeleteAVL(BSTree &p, int x, int &shorter); 
void PrintBST(BSTree &T, int depth);   
void main() {
BSTree T; 
int sear, cmd, depth;  
char ch;  int shorter = 0;   
bool taller = false;  
T = (BSTree)malloc(sizeof(BSTNode)); 
T = NULL;  
while (1)
{

printf("****************平衡二叉树的操作菜单****************\n");
printf("                    1--创建\n");
printf("                    2--查找\n");
printf("                    3--插入\n");
printf("                    4--删除\n");
printf("                    5--退出\n");
printf("****************************************************\n");
printf("\n请选择操作的编号：\n");
scanf("%d", &cmd);  

switch (cmd)   {
case 1:   
CreatBST(T); break;   
case 2:    
printf("请输入您要查找的关键字：");     
scanf("%d", &sear);    
if (SearchBST(T, sear)) 
printf("关键字%d存在，查找成功!\n", sear);    
else printf("查找失败!\n");    
break;   
case 3:    
printf("请输入您要插入的关键字：");    
scanf("%d", &sear);    
InsertAVL(T, sear, taller); 
depth = 0;    
PrintBST(T, depth);   
break;
case 4:    
depth = 0;    
printf("请输入你要删除的关键字: ");   
scanf("%d", &sear);    
DeleteAVL(T, sear, shorter);    
PrintBST(T, depth);     
break;   
case 5:    
printf("结束!\n");   
break;   
default:    
printf("输入错误!\n");
}  

} 
printf("\n");
}
void CreatBST(BSTree &T) 
{
int depth;  int e;      
bool taller = false;  T = NULL;  
printf("\n请输入关键字(以-123结束建立平衡二叉树):");  
scanf("%d", &e);   
while (e != -123)  
{ 
InsertAVL(T, e, taller);   
printf("\n请输入关键字(以-123结束建立平衡二叉树):");   
scanf("%d", &e);   
taller = false; 
}  
depth = 0; 
printf("\n****************************************************\n"); 
printf("                 您创建的二叉树为\n");  
if (T)
PrintBST(T, depth);  
else   
printf("这是一棵空树!\n");
}
void R_Rotate(BSTree &p)    //对以*p为根的二叉排序树作右旋处理 
{  
BSTree lc; 
lc=p->lchild;  
p->lchild=lc->rchild; 
lc->rchild=p;  
p=lc; 
}   
void L_Rotate(BSTree &p)   //对以*p为根的二叉排序树作左旋处理 
{  
BSTree rc;  
rc=p->rchild;  
p->rchild=rc->lchild; 
rc->lchild=p;  
p=rc;
}  
void LeftBalance(BSTree &T)    //对以指针Ｔ所指结点为根的二叉树作左平衡旋转处理 
{  
BSTree lc,rd;  
lc=T->lchild;  
switch(lc->bf)  
{  
case LH:   
T->bf=lc->bf=EH;   
R_Rotate(T);   
break;  
case RH:   
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;  
}  
rd->bf=EH; 
L_Rotate(T->lchild);  
R_Rotate(T); 
} 
}
void RightBalance(BSTree &T)     //对以指针Ｔ所指结点为根的二叉树作右平衡旋转处理 
{  BSTree rc,ld; 
rc=T->rchild;  
switch(rc->bf)  
{  
case RH:  
T->bf=rc->bf=EH;   
L_Rotate(T);   
break;  
case LH:   
ld=rc->lchild;  
switch(ld->bf)   
{   
case RH:
T->bf=LH;rc->bf=EH;break;   
case EH:T->bf=rc->bf=EH;break;   
case LH:T->bf=EH;rc->bf=RH;break;  
}   
ld->bf=EH;   
R_Rotate(T->rchild);  
L_Rotate(T); 
} 
}   
bool InsertAVL(BSTree &T,int e,bool &taller)  //插入结点e 
{  if(!T)  
    {   
    T=new BSTNode;   
T->data=e;  
T->lchild=T->rchild=NULL;   
T->bf=EH;   
taller=true; 
    }  
    else
{   
if(e==T->data)   
{    
taller=false;    
printf("已存在相同关键字的结点!\n"); 
            return 0;   
}   
if (e<T->data)   
{ 
if (!InsertAVL(T->lchild, e, taller))     
return 0;    
if (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; 
          } 
}
       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;
           } 
  }  
} 
}
bool SearchBST(BSTree &T, int key)   //查找元素key是否在树Ｔ中 
{  
if(!T)   
return false;  
else if(key==T->data)   
return true;  
else if(key<T->data)   
return SearchBST(T->lchild,key);  
else   
return SearchBST(T->rchild,key); 
  }  
void LeftBalance_div(BSTree &p, int &shorter)     //删除结点时左平衡旋转处理 
 {  
BSTree  p1,p2;  
if(p->bf==1)   
{ 
p->bf=0; shorter=1; 
}  
else if(p->bf==0)  
{ 
p->bf=-1; shorter=0;
}  
else    
{   p1=p->rchild;   
   if(p1->bf==0)   
  {    
   L_Rotate(p);    p1->bf=1; p->bf=-1; shorter=0;        
  }   
else if(p1->bf==-1)         
   {   
 L_Rotate(p);             
 p1->bf=p->bf=0; shorter=1;         
   }   
else          
{    
p2=p1->lchild;    
p1->lchild=p2->rchild; 
p2->rchild=p1; 
p->rchild=p2->lchild; 
p2->lchild=p;    
if(p2->bf==0)    
 { 
p->bf=0; p1->bf=0; 
 }    
else if(p2->bf==-1)    
{ 
p->bf=1;p1->bf=0; 
}    
else     
{ 
p->bf=0;p1->bf=-1;
}             
p2->bf=0; p=p2; shorter=1;   
}  
} 
} 
void RightBalance_div(BSTree &p, int &shorter)    //删除结点时右平衡旋转处理 
{  
BSTree  p1,p2;  
if(p->bf==-1)  
{
p->bf=0; shorter=1; 
}     
else if(p->bf==0) 
   {
p->bf = 1; shorter = 0;
   }
else     
{
p1 = p->lchild;         
if (p1->bf == 0)         
{ 
R_Rotate(p);             
p1->bf = -1; p->bf = 1; shorter = 0;
} 
else if (p1->bf == 1)        
{ 
R_Rotate(p);             
p1->bf = p->bf = 0; 
shorter = 1; 
} 
else         
{ 
p2 = p1->rchild;             
p1->rchild = p2->lchild;
p2->lchild = p1; 
p->lchild = p2->rchild; 
p2->rchild = p;             
if (p2->bf == 0)              
{ 
p->bf = 0; p1->bf = 0;
} 
else if (p2->bf == 1)             
{ 
p->bf = -1; p1->bf = 0; 
} 
else               
{ 
p->bf = 0; p1->bf = 1;
}             
p2->bf = 0; p = p2; shorter = 1; 
} 
} 
}
void Delete(BSTree q, BSTree  &r, int &shorter)         //删除结点 
{  
if(r->rchild==NULL)     
{   
q->data=r->data; 
q=r;         
r=r->lchild; 
free(q);         
shorter=1;  
}     
else      
{    
Delete(q,r->rchild,shorter);         
if(shorter==1)    
RightBalance_div(r,shorter);  
} 
}
int DeleteAVL(BSTree &p, int x, int &shorter)      //平衡二叉树的删除操作 
{  
int k;     BSTree q;      
if(p==NULL)  
{ 
printf("不存在要删除的关键字!\n"); return 0;
}     
else if(x<p->data)     
{    
k=DeleteAVL(p->lchild,x,shorter);         
if(shorter==1)    
LeftBalance_div(p,shorter);   
return k;  
}  
else if(x>p->data)     
{   
k=DeleteAVL(p->rchild,x,shorter);   
if(shorter==1)    
RightBalance_div(p,shorter);   
return k; 
}  
else  
{   
q=p;   
if(p->rchild==NULL)    
{ p=p->lchild; free(q); shorter=1;
}         
else if(p->lchild==NULL)  
{ p=p->rchild; free(q); shorter=1;
}         
else         
{    
Delete(q,q->lchild,shorter);    
if(shorter==1)    
LeftBalance_div(p,shorter);    
p=q;    
}         
return 1; 
} 
}
void PrintBST(BSTree &T, int depth) 
{
int i;   
if (T->rchild)    
PrintBST(T->rchild, depth + 1);   
for (i = 1; i <= depth; i++)
printf("       ");   
printf("%d\n", T->data);   
if (T->lchild)    
PrintBST(T->lchild, depth + 1);
}