#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define LH +1
#define EH 0
#define RH -1
typedef int Status;
typedef int ElemType;
typedef struct BSTNode{
ElemType data;
int bf;
struct BSTNode *lchild ,*rchild;
} BSTNode,* BSTree;
Status SearchBST(BSTree T,ElemType e);
void R_Rotate(BSTree &p);
void L_Rotate(BSTree &p);
void LeftBalance(BSTree &T);
void RightBalance(BSTree &T);
Status InsertAVL(BSTree &T,ElemType e,int &taller);
void DELeftBalance(BSTree &T);
void DERightBalance(BSTree &T);
Status Delete(BSTree &T,int &shorter);
Status DeleteAVL(BSTree &T,ElemType e,int &shorter);
void PrintBSTree(BSTree &T,int lev);
Status SearchBST(BSTree T,ElemType e){
if(!T){
return FALSE;
}
else if(e == T->data ){
return TRUE;
}
else if (e < T->data){
return SearchBST(T->lchild,e);
}
else{
return SearchBST(T->rchild,e);
}
}
void R_Rotate(BSTree &p){
BSTree lc;
lc = p->lchild;
p->lchild = lc->rchild;
lc->rchild = p;
p = lc;
}
void L_Rotate(BSTree &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 LH: T->bf=RH; rc->bf=EH;
break;
case EH: T->bf=rc->bf=EH;
break;
case RH: T->bf = EH; rc->bf=LH;
break;
}
ld->bf=EH;
R_Rotate(T->rchild);
L_Rotate(T);
}
}
Status InsertAVL(BSTree &T,ElemType e,int &taller){
if(!T){
T= (BSTree) malloc (sizeof(BSTNode));
T->data = e;
T->lchild = T->rchild = NULL;
T->bf = EH;
taller = 1;
}
else{
if(e == T->data){
taller = 0;
printf("请插入不同的数值\n");
return ERROR;
}
if(e < T->data){
if(!InsertAVL(T->lchild,e,taller))
return ERROR;
if(taller)
switch(T->bf){
case LH:
LeftBalance(T);
taller = 0;
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 ERROR;
}
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;
}
void DELeftBalance(BSTree &T){
BSTree lc,rd;
lc=T->lchild;
switch(lc->bf){
case LH:
T->bf = EH;
R_Rotate(T);
break;
case EH:
T->bf = EH;
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 DERightBalance(BSTree &T)
{
BSTree rc,ld;
rc=T->rchild;
switch(rc->bf){
case RH:
T->bf= EH;
L_Rotate(T);
break;
case EH:
T->bf= EH;
L_Rotate(T);
break;
case LH:
ld=rc->lchild;
switch(ld->bf){
case LH: T->bf=RH; rc->bf=EH;
break;
case EH: T->bf=rc->bf=EH;
break;
case RH: T->bf = EH; rc->bf=LH;
break;
}
ld->bf=EH;
R_Rotate(T->rchild);
L_Rotate(T);
}
}
void SDelete(BSTree &T,BSTree &q,BSTree &s,int &shorter){
if(s->rchild){
SDelete(T,s,s->rchild,shorter);
if(shorter)
switch(s->bf){
case EH:
s->bf = LH;
shorter = 0;
break;
case RH:
s->bf = EH;
shorter = 1;
break;
case LH:
DELeftBalance(s);
shorter = 0;
break;
}
return;
}
T->data = s->data;
if(q != T)
q->rchild = s->lchild;
else
q->lchild = s->lchild;
shorter = 1;
}
Status Delete(BSTree &T,int &shorter){
BSTree q;
if(!T->rchild){
q = T;
T = T->lchild;
free(q);
shorter = 1;
}
else if(!T->lchild){
q = T;
T= T->rchild;
free(q);
shorter = 1;
}
else{
SDelete(T,T,T->lchild,shorter);
if(shorter)
switch(T->bf){
case EH:
T->bf = RH;
shorter = 0;
break;
case LH:
T->bf = EH;
shorter = 1;
break;
case RH:
DERightBalance(T);
shorter = 0;
break;
}
}
return TRUE;
}
Status DeleteAVL(BSTree &T,ElemType e,int &shorter){
int sign = 0;
if (!T){
return sign;
}
else{
if(e == T->data){
sign = Delete(T,shorter);
return sign;
}
else if(e < T->data){
sign = DeleteAVL(T->lchild,e,shorter);
if(shorter)
switch(T->bf){
case EH:
T->bf = RH;
shorter = 0;
break;
case LH:
T->bf = EH;
shorter = 1;
break;
case RH:
DERightBalance(T);
shorter = 0;
break;
}
return sign;
}
else{
sign = DeleteAVL(T->rchild,e,shorter);
if(shorter)
switch(T->bf){
case EH:
T->bf = LH;
shorter = 0;
break;
case RH:
T->bf = EH;
break;
case LH:
DELeftBalance(T);
shorter = 0;
break;
}
return sign;
}
}
}
void CreatBSTree(BSTree &T){
FILE *fp;
if((fp=fopen("a.txt", "r"))==NULL)
{
printf("can't open the file!\n");
exit(0);
}
int e,taller = 0;
while(feof(fp)==0){
fscanf(fp,"%d",&e);
InsertAVL(T,e,taller) ;
}
printf("构建成功,输入任意字符返回\n");
getchar();
getchar();
fclose(fp);
}
void PrintBSTree(BSTree &T,int lev){
int i;
if(T->rchild)
PrintBSTree(T->rchild,lev+1);
for(i = 0;i < lev;i++)
printf(" ");
printf("%d\n",T->data);
if(T->lchild)
PrintBSTree(T->lchild,lev+1);
}
void main(){
BSTree T1 = NULL;
int cho,taller,e,k;
taller = 0;
k = 0;
while(1){
printf(" 平衡二叉树操作的演示\n");
printf("******************************************************************************/n");
printf(" 平衡二叉树显示区 \n");
printf("T1树\n");
if(!T1 )
printf(" 当前为空树\n");
else{
PrintBSTree(T1,1);
}
printf("******************************************************************************\n");
printf("T1操作:1.创建 2.插入 3.查找 4.删除 \n");
printf("0.退出\n");
printf("******************************************************************************\n");
printf("输入你要进行的操作:");
scanf("%d",&cho);
switch(cho){
case 1:
CreatBSTree(T1);
break;
case 2:
printf("请输入要插入关键字的值");
scanf("%d",&e);
InsertAVL(T1,e,taller) ;
break;
case 3:
printf("请输入要查找关键字的值");
scanf("%d",&e);
if(SearchBST(T1,e))
printf("查找成功!\n");
else
printf("查找失败!\n");
printf("按任意键返回");
getchar();
getchar();
break;
case 4:
printf("请输入要删除关键字的值");
scanf("%d",&e);
if(DeleteAVL(T1,e,k))
printf("删除成功!\n");
else
printf("删除失败!\n");
printf("按任意键返回");
getchar();
getchar();
break;
case 0:
exit(0);
}
}
}
#include<iostream>
#include<fstream>
#include<malloc.h>
using namespace std;
#define LH 1
#define EH 0
#define RH -1
typedef struct TreeNode
{
int m_nValue;
int BF;
TreeNode *lchild;
TreeNode *rchild;
}*PBSTree;
class AVLTree
{
protected:
int len;
int BF;
TreeNode *lc,*rd;
PBSTree rc,ld;
TreeNode *p;
PBSTree q;
public:
PBSTree root;
AVLTree()
{
PBSTree root=NULL;
};
~AVLTree() {};
void Instree(PBSTree root,int m_nValue);
void PreTraver(PBSTree root);
void InorderTra(PBSTree root);
void RR_Rotate(PBSTree r);
int GetHeight(PBSTree root);
int GetBF(PBSTree root);
void LL_Rotate(PBSTree r);
void RL_Rotate(PBSTree r);
void LR_Rotate(PBSTree r);
void LeftBalance(PBSTree T);
void RightBalance(PBSTree T);
bool FindNode(PBSTree T,int e);
void DELeftBalance(PBSTree T);
void DERightBalance(PBSTree T);
void SDelete(PBSTree T,PBSTree q,PBSTree s,int shorter);
int Delete(PBSTree T,int shorter);
int DeleteAVL(PBSTree T,int e,int shorter);
};
int Max(int a,int b)
{
if(a>b)return a;
else return b;
}
int AVLTree::GetHeight(PBSTree root)
{
if(root==NULL)len=0;
else
{
len=Max(GetHeight(root->lchild),GetHeight(root->rchild))+1;
}
return len;
}
void AVLTree::InorderTra(PBSTree root)
{
if(root->lchild)
InorderTra(root->lchild);
printf("%d ",root->m_nValue);
if(root->rchild)
InorderTra(root->rchild);
}
int AVLTree::GetBF(PBSTree root)
{
BF=GetHeight(root->lchild)-GetHeight(root->rchild);
return BF;
}
void AVLTree::Instree(PBSTree root,int m_nValue)
{
if(root==NULL)
{
root=(TreeNode*)malloc(sizeof(TreeNode));
root->m_nValue=m_nValue;
root->lchild=NULL;
root->rchild=NULL;
root->BF=EH;
}
else if(m_nValue<root->m_nValue)
{
Instree(root->lchild,m_nValue);
switch(root->BF)
{
case LH:
LeftBalance(root);
break;
case EH:
root->BF=LH;
break;
case RH:
root->BF=EH;
}
}
else if(m_nValue>root->m_nValue)
{
Instree(root->rchild,m_nValue);
switch(root->BF)
{
case LH:
root->BF=EH;
break;
case EH:
root->BF=RH;
break;
case RH:
RightBalance(root);
}
}
}
void AVLTree::PreTraver(PBSTree root)
{
if(root)
{
cout.width(3);
cout<<root->m_nValue;
}
if(root->lchild)
PreTraver(root->lchild);
if(root->rchild)
PreTraver(root->rchild);
}
void AVLTree::LL_Rotate(PBSTree r)
{
p=r->rchild;
r->rchild=p->lchild;
p->lchild=r;
r=p;
}
void AVLTree::RR_Rotate(PBSTree r)
{
p=r->lchild;
r->lchild=p->rchild;
p->rchild=r;
r=p;
}
void AVLTree::RL_Rotate(PBSTree r)
{
p=r->rchild;
RR_Rotate(p);
r->rchild=p;
LL_Rotate(r);
}
void AVLTree::LR_Rotate(PBSTree r)
{
p=r->lchild;
LL_Rotate(p);
r->lchild=p;
RR_Rotate(r);
}
void AVLTree::LeftBalance(PBSTree T)
{
lc=T->lchild;
switch(lc->BF)
{
case LH:
RR_Rotate(T);
T->BF=lc->BF=EH;
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;
}
rd->BF=EH;
LL_Rotate(T->lchild);
RR_Rotate(T);
}
}
void AVLTree::RightBalance(PBSTree T)
{
rc=T->rchild;
switch(rc->BF)
{
case RH:
T->BF=rc->BF=EH;
LL_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;
}
ld->BF=EH;
RR_Rotate(T->rchild);
LL_Rotate(T);
}
}
bool AVLTree::FindNode(PBSTree T,int e)
{
if(!T)
{
return 0;
}
else if(e == T->m_nValue )
{
return 1;
}
else if (e < T->m_nValue)
{
return FindNode(T->lchild,e);
}
else
{
return FindNode(T->rchild,e);
}
}
void AVLTree::DELeftBalance(PBSTree T)
{
lc=T->lchild;
switch(lc->BF)
{
case LH:
T->BF= EH;
RR_Rotate(T);
break;
case EH:
T->BF = EH;
lc->BF= EH;
RR_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;
LL_Rotate(T->lchild);
RR_Rotate(T);
}
}
void AVLTree::DERightBalance(PBSTree T)
{
rc=T->rchild;
switch(rc->BF)
{
case RH:
T->BF= EH;
LL_Rotate(T);
break;
case EH:
T->BF= EH;
LL_Rotate(T);
break;
case LH:
ld=rc->lchild;
switch(ld->BF)
{
case LH:
T->BF=RH;
rc->BF=EH;
break;
case EH:
T->BF=rc->BF=EH;
break;
case RH:
T->BF = EH;
rc->BF=LH;
break;
}
ld->BF=EH;
RR_Rotate(T->rchild);
LL_Rotate(T);
}
}
void AVLTree::SDelete(PBSTree T,PBSTree q,PBSTree s,int shorter)
{
if(s->rchild)
{
SDelete(T,s,s->rchild,shorter);
if(shorter)
switch(s->BF)
{
case EH:
s->BF = LH;
shorter = 0;
break;
case RH:
s->BF = EH;
shorter = 1;
break;
case LH:
DELeftBalance(s);
shorter = 0;
break;
}
return;
}
T->m_nValue = s->m_nValue;
if(q != T)
q->rchild = s->lchild;
else
q->lchild = s->lchild;
shorter = 1;
}
int AVLTree::Delete(PBSTree T,int shorter)
{
if(!T->rchild)
{
q = T;
T = T->lchild;
free(q);
shorter = 1;
}
else if(!T->lchild)
{
q = T;
T= T->rchild;
free(q);
shorter = 1;
}
else
{
SDelete(T,T,T->lchild,shorter);
if(shorter)
switch(T->BF)
{
case EH:
T->BF = RH;
shorter = 0;
break;
case LH:
T->BF = EH;
shorter = 1;
break;
case RH:
DERightBalance(T);
shorter = 0;
break;
}
}
return 1;
}
int AVLTree::DeleteAVL(PBSTree T,int e,int shorter)
{
int sign = 0;
if (!T)
{
return sign;
}
else
{
if(e == T->m_nValue)
{
sign = Delete(T,shorter);
return sign;
}
else if(e < T->m_nValue)
{
sign = DeleteAVL(T->lchild,e,shorter);
if(shorter)
switch(T->BF)
{
case EH:
T->BF = RH;
shorter = 0;
break;
case LH:
T->BF = EH;
shorter = 1;
break;
case RH:
DERightBalance(T);
shorter = 0;
break;
}
return sign;
}
else
{
sign = DeleteAVL(T->rchild,e,shorter);
if(shorter)
switch(T->BF)
{
case EH:
T->BF = LH;
shorter = 0;
break;
case RH:
T->BF = EH;
break;
case LH:
DELeftBalance(T);
shorter = 0;
break;
}
return sign;
}
}
}
int main()
{
AVLTree AVL=AVLTree();
AVL.root=NULL;
int taller,e,k;
char cho;
taller = 0;
k = 0;
while(1)
{
printf("操作:1.创建 2.插入 3.查找 4.删除 5.遍历 0.退出\n");
printf("输入你要进行的操作:");
scanf("%c",&cho);
switch(cho)
{
case '1':
{
FILE *fp;
if((fp=fopen("te.txt", "r"))==NULL)
{
printf("文件打开失败\n");
exit(0);
}
int e = 0;
while(feof(fp)==0)
{
fscanf(fp,"%d",&e);
AVL.Instree(AVL.root,e);
}
AVL.InorderTra(AVL.root);
printf("\n");
}
getchar();
break;
case '2':
{
printf("请输入要插入关键字的值");
scanf("%d",&e);
AVL.Instree(AVL.root,e);
AVL.InorderTra(AVL.root);
printf("\n");
}
getchar();
break;
case '3':
{
printf("请输入要查找关键字的值");
scanf("%d",&e);
if(AVL.FindNode(AVL.root,9))
printf("\n找到\n");
else
printf("\n没有找到\n");
AVL.InorderTra(AVL.root);
printf("\n");
getchar();
}
break;
case '4':
printf("请输入要删除关键字的值");
scanf("%d",&e);
if(AVL.DeleteAVL(AVL.root,e,k))
printf("删除成功!\n");
else
printf("删除失败!\n");
getchar();
break;
case '5':
printf("中序遍历:");
AVL.InorderTra(AVL.root);
printf("\n");
printf("前序遍历:");
AVL.PreTraver(AVL.root);
printf("\n");
getchar();
break;
case '0':
exit(0);
}
}
return 1;
}