#include<iostream.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<stack>
#define TRUE 1
#define FALSE 0
#define LH -1
#define EH 0
#define RH 1
class AVLTree
{
protected:
struct AvltNode
{
int data;
int bf;
struct AvltNode *leftchild,*rightchild;
};
private:
AvltNode *root;
static AvltNode *BuyNode()
{
AvltNode *s=(AvltNode*)malloc(sizeof(AvltNode));
assert(s!=NULL);
memset(s,0,sizeof(AvltNode));
return s;
}
static void FreeNode(AvltNode *ptr)
{
free(ptr);
ptr=NULL;
}
static void LRotate(AvltNode **ptr)
{
AvltNode *s;
s=(*ptr)->rightchild;
(*ptr)->rightchild=s->leftchild;
s->leftchild=(*ptr);
*ptr=s;
}
static void RRotate(AvltNode **ptr)
{
AvltNode *s;
s=(*ptr)->leftchild;
(*ptr)->leftchild=s->rightchild;
s->rightchild=(*ptr);
*ptr=s;
}
static void LeftBalance(AvltNode **T)
{
AvltNode *L,*Lr;
L=(*T)->leftchild;
switch(L->bf)
{
case LH:
(*T)->bf=L->bf=EH;
RRotate(T);
break;
case RH:
Lr=L->rightchild;
switch(Lr->bf)
{
case LH:
(*T)->bf=RH;
L->bf=EH;
break;
case EH:
(*T)->bf=L->bf=EH;
break;
case RH:
(*T)->bf=EH;
L->bf=LH;
break;
}
Lr->bf=EH;
LRotate(&(*T)->leftchild);
RRotate(T);
}
}
static void RightBalance(AvltNode **T)
{
AvltNode *R,*Rl;
R=(*T)->rightchild;
switch(R->bf)
{
case RH:
(*T)->bf=R->bf=EH;
LRotate(T);
break;
case LH:
Rl=R->leftchild;
switch(Rl->bf)
{
case RH:
(*T)->bf=LH;
R->bf=EH;
break;
case EH:
(*T)->bf=R->bf=EH;
break;
case LH:
(*T)->bf=EH;
R->bf=RH;
break;
}
Rl->bf=EH;
RRotate(&(*T)->rightchild);
LRotate(T);
}
}
static bool InsertAVL(AvltNode **T,int e,bool* taller)
{
if((*T)==NULL)
{
*T=(AvltNode *)malloc(sizeof(AvltNode));
(*T)->data=e;
(*T)->leftchild=(*T)->rightchild=NULL;
(*T)->bf=EH;
(*taller)=TRUE;
}
else
{
if(e==(*T)->data)
{
*taller=FALSE;
return FALSE;
}
if(e<(*T)->data)
{
if(!InsertAVL(&(*T)->leftchild,e,taller))
{
return FALSE;
}
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;
}
}
}
if(e==(*T)->data)
{
*taller=FALSE;
return FALSE;
}
else
{
if(!InsertAVL(&(*T)->rightchild,e,taller))
{
return FALSE;
}
if(*taller)
{
switch((*T)->bf)
{
case RH:
RightBalance(T);
*taller=FALSE;
break;
case EH:
(*T)->bf=LH;
*taller=TRUE;
break;
case LH:
(*T)->bf=EH;
*taller=FALSE;
break;
}
}
}
}
return TRUE;
}
static void PreOrder(AvltNode *ptr)
{
std::stack<AvltNode *> st;
while(ptr!=NULL||!st.empty())
{
if(ptr!=NULL)
{
cout<<ptr->data<<" ";
st.push(ptr);
ptr=ptr->leftchild;
}
else
{
ptr=st.top();
st.pop();
ptr=ptr->rightchild;
}
}
}
public:
AVLTree():root(NULL)
{
}
AVLTree(int *arr,int len):root(NULL)
{
int i=0;
bool taller=FALSE;
while(len--)
{
InsertAVL(&root,arr[i++],&taller);
}
}
void PreOrder()
{
PreOrder(root);
}
};
void main()
{
int arr[]={1,2,3,4,5,66,7,8,9,23};
int len=sizeof(arr)/sizeof(arr[0]);
AVLTree mytree(arr,len);
mytree.PreOrder( );
}
AVL树的创建
最新推荐文章于 2023-12-03 22:10:08 发布