AVL树的创建

最新推荐文章于 2023-05-15 22:00:53 发布

Sophia1010

最新推荐文章于 2023-05-15 22:00:53 发布

阅读量332

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/sophia1010/article/details/39121745

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

#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( );
}