AVL树介绍和各操作实现图文详解

最新推荐文章于 2024-05-01 05:55:37 发布
最新推荐文章于 2024-05-01 05:55:37 发布
阅读量1k 收藏 5
点赞数 4
分类专栏： 笔记 文章标签： 数据结构 二叉树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53452010/article/details/117110125
版权

AVL树介绍和各操作实现图文详解

AVL树介绍

AVL(Adelson-Velskii 和Landis )树是带有平衡条件的二叉查找树。该条件便是其每个节点的左子树和右子树的高度最多相差1(空树的高度定义为-1)，其深度是O(log N)。
简而言之，一颗AVL树是其每个节点的左子树和右子树的高度最多相差1的二叉查找树。

在这里插入图片描述
如上图，左边的是AVL树而右边的不是AVL树，因为在树(2)中节点5左右子树的高度差超过了1。

AVL树的结构体如下：

#include<stdio.h>
#include<stdlib.h>
#define Maxsize 20

typedef struct AVLTREE
{
	int Data;//存放数据 
	int Height;//高度 
	struct AVLTREE *Leftchild;//左子树 
	struct AVLTREE *Rightchild;//右子树 
}*AVLTree;

节点的高度等于该节点左右孩子中的较大高度加一。

获取节点高度的代码：

//获取节点高度 
int GetHeight(AVLTree root)
{
   if(root==NULL)
	return -1;
   else
    return MaxHeight(GetHeight(root->Leftchild),GetHeight(root->Rightchild))+1;
}

AVL树的操作集

旋转

在不断往AVL树中添加新节点的过程中往往会导致AVL树“失衡”(即有节点左右子树的高度差超过了1)的出现，
在这里插入图片描述

如上图，新插入的节点7便导致了树的失衡，尽管节点4和节点5同时失衡，但我们只需对距离新节点最近的失衡节点5进行研究和处理，在这里我们将新插入的导致树失衡的节点7叫做“麻烦节点”，将距离麻烦节点最近的失衡节点5叫做“发现者”，接下来我们便将对插入过程中四种形式的“发现者”和“麻烦节点”进行讨论。

RR插入(左单旋)

就拿上面的那个例子来讲，它便是一个RR插入的情况
在这里插入图片描述
RR插入指“麻烦节点”是“发现者”右孩的右孩，即新插入的节点在离其最近的“失衡”节点的右儿子的右儿子处。
此时我们就只对“发现者”和其到“麻烦节点”路径上的节点做操作，先单独把它们拎出来，然后对它们进行左单旋
在这里插入图片描述
怎么理解这个过程呢。。。打个比方吧，你就想象一下这三个节点是三个长在一根树枝上的大苹果，你将这根树枝剪下来，然后又在节点6上打个结绑回树上去，这样子节点5和节点7在重力的作用下自然下垂，成为了节点6的左右孩子，让我们看看把“苹果绑回去后的效果”
在这里插入图片描述
这样就成功让失去平衡的树重新恢复平衡了。
但这只是RR插入中较为简单的一种情况，试着想想，左单旋过程中“发现者”顶替了右孩的左儿子节点的位置，那如果“发现者”的右孩有左儿子怎么办？右孩的左儿子何去何从？
虽然麻烦节点是发现者右孙子的右儿子，严格意义上来说叫RRR插入了，但通过左单旋的方法还是可以让其恢复平衡的

情况如上图，当发现者右孩的左儿子不为空时，我们旋转的同时只需要将右孩的左儿子变成发现者的右儿子就行了
在这里插入图片描述
总而言之，左单旋是个将发现者节点变成其右孩的左孩子节点，且让发现者的右孩代替发现者原本的位置的一个过程，在这个过程中，如果发现者右孩的左儿子不为空时，我们旋转的同时只需要将右孩的左儿子变成发现者的右儿子就行了。

PS:我们要注意左单旋过程中的顺序，在左单旋过程中，我们要先取得发现者的右孩，再将右孩的左儿子插入到发现者的右孩位置上，再将发现者插入到右孩的左儿子位置上，最后再返回右孩的位置让右孩代替原本发现者的位置。

RR插入(左单旋)的代码实现如下:

//RR插入(左单旋) 
AVLTree Right_Right_rotation(AVLTree root)
{
	AVLTree Right_Chlid;
	
	Right_Chlid=root->Rightchild;//先取出“发现者”的右孩 
	root->Rightchild=Right_Chlid->Leftchild;//再让“发现者”的右儿子指向其原本右孩的左儿子 
	Right_Chlid->Leftchild=root;//让其成为原本右孩的左儿子 
	
	root->Height=MaxHeight(GetHeight(root->Leftchild),GetHeight(root->Rightchild))+1;//更新原“发现者”的高度 
	Right_Chlid->Height=MaxHeight(GetHeight(Right_Chlid->Leftchild),GetHeight(Right_Chlid->Rightchild))+1;//更新原“发现者”右孩的高度 
	
	return Right_Chlid;//返回右孩，使其代替原本发现者的位置 
}

LL插入(右单旋)

LL插入(右单旋)是RR插入(左单旋)的一个镜像操作，只要将上面RR插入(左单旋)的一些操作反过来就行，主要是对“发现者”及其左孩的一个操作。例子如下图
在这里插入图片描述
如图所示，当麻烦节点是在发现者左孩的左孩的位置上时，就叫做LL插入，为使其恢复平衡，我们对其进行右单旋操作
在这里插入图片描述
当然，我们进行右单旋的过程中同时也要注意发现者左孩的右儿子是否为空，
在这里插入图片描述
若左孩的右儿子不为空则将其插入到发现者左孩的位置上。

PS:其实我们不用判断左孩的右儿子是否为空，不管它是否为空，直接将其插入到发现者左孩的位置上就行
总而言之，右单旋就是个把发现者变成其左孩的右儿子，其左孩的右儿子变成发现者左儿子，并返回发现者原本的左孩的地址使其代替发现者在树上原本的位置的一个过程。

LL插入(右单旋)的代码实现如下:

//LL插入（右单旋） 
AVLTree Left_Left_rotation(AVLTree root)
{
	AVLTree Left_Chlid;
	Left_Chlid=root->Leftchild;//先取出“发现者”的左孩
	root->Leftchild=Left_Chlid->Rightchild;//再让“发现者”的左儿子指向其原本左孩的右儿子 
	Left_Chlid->Rightchild=root;//让其成为原本左孩的右儿子 
	
	root->Height=MaxHeight(GetHeight(root->Leftchild),GetHeight(root->Rightchild))+1;//更新原“发现者”的高度 
	Left_Chlid->Height=MaxHeight(GetHeight(Left_Chlid->Leftchild),GetHeight(Left_Chlid->Rightchild))+1;//更新原“发现者”左孩的高度 
	
	return Left_Chlid;//返回左孩，使其代替原本发现者的位置 
}

RL插入(右左双旋)

让我们再回到开头的那个例子，若是当时麻烦节点不是发现者右孩的右儿子，而是右孩的左儿子，那该怎么办
在这里插入图片描述
当麻烦节点是发现者节点右孩的左儿子时，该情况叫做RL插入，我们要对发现者进行右左双旋操作(其实右单旋是对发现者右孩的动作，左单旋才是对发现者的动作)，该操作顺序如下在这里插入图片描述先对发现者节点的右孩进行右单旋，这样子这棵树就变成了RR插入的情况

在这里插入图片描述
既然变成了RR插入的情况，那就再对发现者进行左单旋操作

在这里插入图片描述
通过以上两个步骤，我们成功地让RL插入情况先失衡的树重获平衡！
在这里插入图片描述
总而言之，右左双旋，就是先对发现者的右孩进行右单旋，再对其发现者进行左单旋的一个过程。
PS:由于左右单旋的代码我们前面都打完了，所以双旋操作的代码反而更简单。。

RL插入(右左双旋)的代码实现如下:

/*RL插入(右左双旋)*/ 
AVLTree Right_Left_rotation(AVLTree root)
{
	root->Rightchild=Left_Left_rotation(root->Rightchild);//先对其右孩进行右单旋 
	
	return Right_Right_rotation(root);//再对发现者进行左单旋 
}

LR插入(左右双旋)

最后，我们来讲讲LR插入，LR插入是指麻烦节点在发现者左孩的右儿子的位置上，如下图
在这里插入图片描述
针对于这种情况，其实要进行的操作与RL插入的操作大同小异，先对发现者的左孩进行左单旋，使其变成LL插入情况
在这里插入图片描述
最后对发现者进行右单旋
在这里插入图片描述
LR插入情况下的失衡就这样被我们通过左右双旋恢复平衡。
在这里插入图片描述
总而言之，左右双旋，就是先对发现者的左孩进行左单旋，再对发现者进行右单旋的操作过程。

LR插入(左右双旋)的代码实现如下:

/*LR插入（左右双旋）*/ 
AVLTree Left_Right_rotation(AVLTree root)
{
	root->Leftchild=Right_Right_rotation(root->Leftchild);//先对左儿子进行左单旋 
	
	return Left_Left_rotation(root);//在对发现者进行右单旋 
}

插入

AVL树插入一个节点过程和二叉搜索树的插入过程是差不多的，只是比二叉搜索树多了平衡条件而已，所以在写插入代码时我们可以适当模仿二叉搜索树的插入写法。
由于咱AVL树对树深度的严格控制(O(log N)),所以咱在这里可以大胆使用递归算法。

插入的代码实现如下：

/*插入数据*/
AVLTree Insert(AVLTree root,int x)
{
	AVLTree Tree=root;//获取节点地址 
	if(root==NULL) //当其传入的是零指针时说明找到了合适的位置 
	{
		Tree=(AVLTree)malloc(sizeof(struct AVLTREE));
		Tree->Data=x;
		Tree->Height=0;
		Tree->Leftchild=Tree->Rightchild=NULL;
	} 
	else //还未找到合适的位置时 
	{
		if(x<Tree->Data)//当要插入的数据比当前节点的值要小，便将其插入到左子树 
		{
			Tree->Leftchild=Insert(Tree->Leftchild,x);//将其插入到左子树中 
			if(GetHeight(Tree->Leftchild)-GetHeight(Tree->Rightchild)==2)//如果插入完成后此节点为“发现者”（左右子树相差刚好为2的节点） 
			{
				if(x<Tree->Leftchild->Data)//要插入的数据比其左儿子小的话说明“麻烦节点”（新插入的导致平衡被破坏的节点） 在其左儿子的左边 
					Tree=Left_Left_rotation(Tree);//左左（LL）插入，对其进行右单旋 
			    else
			    	Tree=Left_Right_rotation(Tree);	//左右（LR）插入，对此节点进行左右双旋	
			}	 	
		}
		else if(x==Tree->Data)//当要插入的数据和当前节点的值一样时 
			printf("数值重复！！\n");
		else if(x>Tree->Data)//当要插入的数据比当前节点的数据大时，将其插入到右子树中 
		{
			Tree->Rightchild=Insert(Tree->Rightchild,x);//将其插入到右子树中 
			if(GetHeight(Tree->Rightchild)-GetHeight(Tree->Leftchild)==2)//若插入完成后该节点为“发现者” 
			{
				if(x>Tree->Rightchild->Data) //要插入数据比“发现者”右儿子大则“麻烦节点”在其右儿子右边 
					Tree=Right_Right_rotation(Tree);//右右（RR）插入则对此节点进行左单旋 
				else
					Tree=Right_Left_rotation(Tree);//右左插入则进行左右双旋 
			}
		}	
	}
	Tree->Height=MaxHeight(GetHeight(Tree->Leftchild),GetHeight(Tree->Rightchild))+1;//插入完成或平衡完毕后更新途径节点们的高度 
	    return Tree;
}

为了帮助理解这段递归代码，诸位试着想象一下，把一整棵AVL树看成一个巨大的纸箱，这个大纸箱(根节点)里放着两个较小的纸箱(左右孩子)，每个纸箱能且最多能装两个更小的纸箱，纸箱都有属于自己的值，你要拿你想放入的纸箱上的数值和你打开的纸箱上的数值进行比较，你的数值更小则放在纸箱的左侧，数值更大则放在纸箱的右侧，如果相应的位置上已经有了纸箱，你就打开该纸箱，继续比较，直到找到了适合你的纸箱的空位为止，然后你就将你的纸箱放到该位置上(插入)。当你放下你的纸箱后你又需要将前面打开的纸箱一个个从里到外关上，在关闭的过程中你还要检查一下箱子里的两个箱子中存放了最多箱子的箱子之间差距会不会大于1个，如果大于1则对箱子更多的那个箱子进行处理(旋转)。
在这里插入图片描述

删除

AVL树的删除操作与二叉搜索树的删除操作也差不多，拿要删除的值和节点的值进行比较，比节点的小就往左子树上删，比节点大就往右子树删，大小一样就删掉，若果直到节点变成NULL都还没完成删除的话，那就说明该目标不在树上。
要删的目标节点有4种形态(加上不在树上的其实有5种)，没有儿子的叶节点，只有左儿子或只有右儿子的，又或是左右儿子都有的节点
在这里插入图片描述
像上面的这样只有1个或没有儿子的节点的删除非常简单，直接删除加返回那个“独生子女”就可以了，但如果我们要删除像下面这样左右儿子都有的节点就有点麻烦了
在这里插入图片描述
上图的节点7可谓是“交通要塞”，贸然删除整棵树都会失衡，而且很难再次恢复，所以我们不能用删除的方式来对它进行操作，看看它的子树里，有没有可以代替它的节点？嗯，答案是肯定的，6和8就不错，看，它们多合适
在这里插入图片描述

6和8分别是目标节点左子树的最大节点和右子树的最小节点
在这里插入图片描述
所以这两个都可以用来替代目标节点，我们这里随便选用右子树的最小值来代替目标节点。
所以我们要有一个获得最小节点的函数，

获得最小节点的函数如下：

*获取最小节点*/ 
AVLTree GetMin(AVLTree root)
{
	if(root->Leftchild!=NULL)//若其左儿子不为NULL则一直往左边递归 
	return GetMin(root->Leftchild);
	else
	return root;
}

删除的代码实现如下：

/*删除节点*/
AVLTree Delete(AVLTree root,int x)
{
	AVLTree MinTree;//存放右儿子的最小子树 
	if(!root) printf("未找到该数据！\n"); 
	
	if(x<root->Data)//目标数据比当前节点小就往其左子树删除 
		root->Leftchild=Delete(root->Leftchild,x); 
	else if(x>root->Data)//目标数据比当前节点大就往其右子树删除 
	    root->Rightchild=Delete(root->Rightchild,x);
	else if(root->Leftchild&&root->Rightchild)//找到了要删除的节点 ，且其既有左儿子又有右儿子 
	{
		MinTree=GetMin(root->Rightchild);//获得该节点右子树的的最小值 
		root->Data=MinTree->Data;//把该节点的数据替换为右子树的的最小值
		root->Rightchild=Delete(root->Rightchild,root->Data);//再删除右子树的最小值 
	}
	else//找到了要删除的节点 ，其左右儿子不完整 
	{
		MinTree=root;//先存放一下该节点的位置 
		if(!root->Leftchild)//如果其左节点为NULL，则其用右儿子替代 
		root=root->Rightchild;
		else if(!root->Rightchild)//如果其右儿子为空，则其用左儿子替代 
		root=root->Leftchild;
		free(MinTree);//释放旧节点 
	}
	return root;
}

遍历

遍历方式有四种，前中后和层序遍历，在这四种遍历方式中我们主要讲讲难一点层序遍历
什么是层序遍历？层次遍历就是逐层地，从左至右地遍历二叉树。
在这里插入图片描述
那我们如何让一层一层的二叉树按顺序排成一个串串呢？
在这里插入图片描述
没错，我们可以用队列！
步骤如下图
在这里插入图片描述
我们先创建个循环队列，现将根节点放入队列中，每出队一个节点，我们就将这个节点的非空左右儿子按顺序入队，如此一来，我们就实现了层次遍历！

层次遍历代码实现如下：

/*层次遍历AVL树*/ 
void LevelTree(AVLTree root)
{
	AVLTree Queue[Maxsize],Tree;//一个存放左右儿子的队列 
	int rear=0,front=0;//初始化队列头和队列尾 
	if(root!=NULL)//若根节点不为NULL则先将根节点存入队列中 
		Queue[++rear]=root;
		
		while(front!=rear)//当头尾相同时说明队列空了 
		{
			front=(front+1)%Maxsize;//先让队列头指向要出队的节点 
			Tree=Queue[front];//取出要出队的节点 
			printf("%d ",Tree->Data);//输出其值 
			
			/*将其左右儿子按顺序放入队列*/ 
			if(Tree->Leftchild!=NULL)//先放入左儿子 
			{
				rear=(rear+1)%Maxsize;//队尾后移一位 
			    Queue[rear]=Tree->Leftchild;//放入队列 
			}
			if(Tree->Rightchild!=NULL)//后放入右儿子 
			{
				rear=(rear+1)%Maxsize;//队尾后移一位
			    Queue[rear]=Tree->Rightchild;//放入队列 	
			}
		}
}

前中后序遍历代码如下：

/*前序遍历*/
void PreOrder(AVLTree root)
{
	if(!root) return;//若为空树则退出 
	else
	{
		printf("%d ",root->Data);
		PreOrder(root->Leftchild);
    	PreOrder(root->Rightchild);
	}
}

/*中序遍历*/ 
void InOrder(AVLTree root)
{
	if(!root) return;//若为空树则退出 
	else
	{
		InOrder(root->Leftchild); 
		printf("%d ",root->Data);
    	InOrder(root->Rightchild);
	}
}

/*后序遍历*/
void PostOrder(AVLTree root)
{
	if(!root) return;//若为空树则退出 
	else
	{
		PostOrder(root->Leftchild);
   	    PostOrder(root->Rightchild);
   	    printf("%d ",root->Data);
	}
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#define Maxsize 20

typedef struct AVLTREE
{
	int Data;//存放数据 
	int Height;//高度 
	struct AVLTREE *Leftchild;//左子树 
	struct AVLTREE *Rightchild;//右子树 
}*AVLTree;


/*菜单*/ 
void Menu(void);
/*层序遍历树*/
void LevelTree(AVLTree root);
/*插入数据*/
AVLTree Insert(AVLTree root,int x);
/*删除数据*/
AVLTree Delete(AVLTree root,int x);
/*寻找最小值*/
AVLTree GetMin(AVLTree root);
/*右单旋*/
AVLTree Left_Left_rotation(AVLTree root);
/*左单旋*/
AVLTree Right_Right_rotation(AVLTree root);
/*左右双旋*/ 
AVLTree Left_Right_rotation(AVLTree root);
/*右左双旋*/ 
AVLTree Right_Left_rotation(AVLTree root);
/*先序遍历*/ 
void PreOrder(AVLTree root);
/*中序遍历*/
void InOrder(AVLTree root);
/*后序遍历*/
void PostOrder(AVLTree root);
/*比较树的高度*/
int MaxHeight(int Left,int Right);
/*得到树的高度*/
int GetHeight(AVLTree root);


int main(void)
{
	AVLTree root=NULL;
	int tragger;
	int data=0;
	
	while(1)
	{
		Menu();
		scanf("%d",&tragger);
		
		switch(tragger)
		{
			case 1:
				    printf("请输入数据（输入-1结束）：\n");
					scanf("%d",&data);
					while(data!=-1)
					{
						root=Insert(root,data); 
						printf("请输入数据（输入-1结束）：\n");
						scanf("%d",&data);	
					}
					break;
			case 2:  printf("层序遍历:");
				     LevelTree(root);
				     break;
				     
			case 3: printf("前序遍历:");
			        PreOrder(root);
			          break;
			case 4: printf("中序遍历:");
					InOrder(root);
			        break;
			case 5: printf("后序遍历:");
					 PostOrder(root);
			        break;
			case 6:  printf("请输入要删除的数据：\n");
			          scanf("%d",&data);
			          root=Delete(root,data);
			          break;
			case 0:
				    return 0;
		}
	}

	return 0;
}

void Menu(void)
{
	printf("\n///");
	printf("\n// 1.插入数据：              //");
	printf("\n// 2.层序遍历二叉树：        //");
    printf("\n// 3.前序遍历二叉树：        //");
    printf("\n// 4.中序遍历二叉树：        //");
    printf("\n// 5.后序遍历二叉树：        //");
    printf("\n// 6.删除数据：              //");
	printf("\n// 0.退出：                  //");
    printf("\n/\n");
	
}

/*插入数据*/
AVLTree Insert(AVLTree root,int x)
{
	AVLTree Tree=root;//获取节点地址 
	if(root==NULL) //当其传入的是零指针时说明找到了合适的位置 
	{
		Tree=(AVLTree)malloc(sizeof(struct AVLTREE));
		Tree->Data=x;
		Tree->Height=0;
		Tree->Leftchild=Tree->Rightchild=NULL;
	} 
	else //还未找到合适的位置时 
	{
		if(x<Tree->Data)//当要插入的数据比当前节点的值要小，便将其插入到左子树 
		{
			Tree->Leftchild=Insert(Tree->Leftchild,x);//将其插入到左子树中 
			if(GetHeight(Tree->Leftchild)-GetHeight(Tree->Rightchild)==2)//如果插入完成后此节点为“发现者”（左右子树相差刚好为2的节点） 
			{
				if(x<Tree->Leftchild->Data)//要插入的数据比其左儿子小的话说明“麻烦节点”（新插入的导致平衡被破坏的节点） 在其左儿子的左边 
					Tree=Left_Left_rotation(Tree);//左左（LL）插入，对其进行右单旋 
			    else
			    	Tree=Left_Right_rotation(Tree);	//左右（LR）插入，对此节点进行左右双旋	
			}	 	
		}
		else if(x==Tree->Data)//当要插入的数据和当前节点的值一样时 
			printf("数值重复！！\n");
		else if(x>Tree->Data)//当要插入的数据比当前节点的数据大时，将其插入到右子树中 
		{
			Tree->Rightchild=Insert(Tree->Rightchild,x);//将其插入到右子树中 
			if(GetHeight(Tree->Rightchild)-GetHeight(Tree->Leftchild)==2)//若插入完成后该节点为“发现者” 
			{
				if(x>Tree->Rightchild->Data) //要插入数据比“发现者”右儿子大则“麻烦节点”在其右儿子右边 
					Tree=Right_Right_rotation(Tree);//右右（RR）插入则对此节点进行左单旋 
				else
					Tree=Right_Left_rotation(Tree);//右左插入则进行左右双旋 
			}
		}	
	}
	Tree->Height=MaxHeight(GetHeight(Tree->Leftchild),GetHeight(Tree->Rightchild))+1;//插入完成或平衡完毕后更新途径节点们的高度 
	    return Tree;
}


/*层次遍历AVL树*/ 
void LevelTree(AVLTree root)
{
	AVLTree Queue[Maxsize],Tree;//一个存放左右儿子的队列 
	int rear=0,front=0;//初始化队列头和队列尾 
	if(root!=NULL)//若根节点不为NULL则先将根节点存入队列中 
		Queue[++rear]=root;
		
		while(front!=rear)//当头尾相同时说明队列空了 
		{
			front=(front+1)%Maxsize;//先让队列头指向要出队的节点 
			Tree=Queue[front];//取出要出队的节点 
			printf("%d ",Tree->Data);//输出其值 
			
			/*将其左右儿子按顺序放入队列*/ 
			if(Tree->Leftchild!=NULL)//先放入左儿子 
			{
				rear=(rear+1)%Maxsize;//队尾后移一位 
			    Queue[rear]=Tree->Leftchild;//放入队列 
			}
			if(Tree->Rightchild!=NULL)//后放入右儿子 
			{
				rear=(rear+1)%Maxsize;//队尾后移一位
			    Queue[rear]=Tree->Rightchild;//放入队列 	
			}
		}
	
}

//比较左右两个儿子的高度 
int MaxHeight(int Left,int Right)
{
	if(Left>Right)
	 return Left;
	else
	 return Right;
}

//获取节点高度 
int GetHeight(AVLTree root)
{
   if(root==NULL)
	return -1;
   else
    return MaxHeight(GetHeight(root->Leftchild),GetHeight(root->Rightchild))+1;
}

//LL插入（右单旋） 
AVLTree Left_Left_rotation(AVLTree root)
{
	AVLTree Left_Chlid;
	Left_Chlid=root->Leftchild;//先取出“发现者”的左孩 
	root->Leftchild=Left_Chlid->Rightchild;//再让“发现者”的左儿子指向其原本左孩的右儿子 
	Left_Chlid->Rightchild=root;//让其成为原本左儿子的右儿子 
	
	root->Height=MaxHeight(GetHeight(root->Leftchild),GetHeight(root->Rightchild))+1;//更新原“发现者”的高度 
	Left_Chlid->Height=MaxHeight(GetHeight(Left_Chlid->Leftchild),GetHeight(Left_Chlid->Rightchild))+1;//更新原“发现者”左孩的高度 
	
	return Left_Chlid;//返回左孩，使其代替原本发现者的位置 
}

//RR插入(左单旋) 
AVLTree Right_Right_rotation(AVLTree root)
{
	AVLTree Right_Chlid;
	
	Right_Chlid=root->Rightchild;//先取出“发现者”的右孩 
	root->Rightchild=Right_Chlid->Leftchild;//再让“发现者”的右儿子指向其原本右孩的左儿子 
	Right_Chlid->Leftchild=root;//让其成为原本右孩的左儿子 
	
	root->Height=MaxHeight(GetHeight(root->Leftchild),GetHeight(root->Rightchild))+1;//更新原“发现者”的高度 
	Right_Chlid->Height=MaxHeight(GetHeight(Right_Chlid->Leftchild),GetHeight(Right_Chlid->Rightchild))+1;//更新原“发现者”右孩的高度 
	
	return Right_Chlid;//返回右孩，使其代替原本发现者的位置 
}

/*LR插入（左右双旋）*/ 
AVLTree Left_Right_rotation(AVLTree root)
{
	root->Leftchild=Right_Right_rotation(root->Leftchild);//先对左孩进行左单旋 
	
	return Left_Left_rotation(root);//再对发现者进行右单旋 
}

/*RL插入(右左双旋)*/ 
AVLTree Right_Left_rotation(AVLTree root)
{
	root->Rightchild=Left_Left_rotation(root->Rightchild);//先对其右孩进行右单旋 
	
	return Right_Right_rotation(root);//再对发现者进行左单旋 
}

/*前序遍历*/
void PreOrder(AVLTree root)
{
	if(!root) return;//若为空树则退出 
	else
	{
		printf("%d ",root->Data);
		PreOrder(root->Leftchild);
    	PreOrder(root->Rightchild);
	}
}

/*中序遍历*/ 
void InOrder(AVLTree root)
{
	if(!root) return;//若为空树则退出 
	else
	{
		InOrder(root->Leftchild); 
		printf("%d ",root->Data);
    	InOrder(root->Rightchild);
	}
}

/*后序遍历*/
void PostOrder(AVLTree root)
{
	if(!root) return;//若为空树则退出 
	else
	{
		PostOrder(root->Leftchild);
   	    PostOrder(root->Rightchild);
   	    printf("%d ",root->Data);
	}
}

/*删除节点*/
AVLTree Delete(AVLTree root,int x)
{
	AVLTree MinTree;//存放右儿子的最小子树 
	if(!root) printf("未找到该数据！\n"); 
	
	if(x<root->Data)//目标数据比当前节点小就往其左子树删除 
		root->Leftchild=Delete(root->Leftchild,x); 
	else if(x>root->Data)//目标数据比当前节点大就往其右子树删除 
	    root->Rightchild=Delete(root->Rightchild,x);
	else if(root->Leftchild&&root->Rightchild)//找到了要删除的节点 ，且其既有左儿子又有右儿子 
	{
		MinTree=GetMin(root->Rightchild);//获得该节点右子树的的最小值 
		root->Data=MinTree->Data;//把该节点的数据替换为右子树的的最小值
		root->Rightchild=Delete(root->Rightchild,root->Data);//再删除右子树的最小值 
	}
	else//找到了要删除的节点 ，其左右儿子不完整 
	{
		MinTree=root;//先存放一下该节点的位置 
		if(!root->Leftchild)//如果其左节点为NULL，则其用右儿子替代 
		root=root->Rightchild;
		else if(!root->Rightchild)//如果其右儿子为空，则其用左儿子替代 
		root=root->Leftchild;
		free(MinTree);//释放旧节点 
	}
	return root;
}

/*获取最小节点*/ 
AVLTree GetMin(AVLTree root)
{
	if(root->Leftchild!=NULL)//若其左儿子不为NULL则一直往左边递归 
	return GetMin(root->Leftchild);
	else
	return root;
}

代码试验

接下来我们试验一下我们代码的可靠性
我先随便手撸了一棵树
在这里插入图片描述
然后我们按照“9 8 7 1 3 5 4 6 10 12 15 14 13 16 2 11” 的顺序插入到一棵树中
在这里插入图片描述
然后遍历一下它
在这里插入图片描述
遍历结果
层次遍历:7,3,12,1,5,9,14,2,4,6,8,10,13,15,11,16
前序遍历:7,3,1,2,5,4,6,12,9,8,10,11,14,13,15,16
中序遍历:1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16
后序遍历:2,1,4,6,5,3,8,11,10,9,13,16,15,14,12,7
yes!结果和我手撸的一样，通过！
接下来我们把牛的一批的节点12给删了，看看它的结果
在这里插入图片描述
yes！OK！
总体来说咱们的代码还是阔以的！！！

参考资料
《数据结构与算法分析C语言描述》[美] 马克·艾伦·维斯著 冯舜玺译 机械工业出版社
如果天空不死大哥的博客

碎碎念
我的天，咱这要不就一个多月不更新，一更就差点把我整个人更没了。
现在我极度疲惫，
懒得检查(ﾟ▽ﾟ*)
如有错误的地方，
还请赐教︿(￣︶￣)︿
看电影去啦~~
撒花。

枕绵
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AVL树及其基本操作
爱技术的小白
06-27 436
本文是介绍AVL树及其插入操作。 1 AVL简介 AVL树是一种特殊的BST树，特殊的地方在于，左右子树高度的绝对值不超过一，所以在构建AVL树的时候，需要调整，以保证平衡。AVL树的作用与BST树是一样的，主要用于快速查找。 2 树的结构 class Tree<T extends Comparable<T>> { private static final int MAX_HEIGHT_DIFFERENCE = 1; private Node<T> roo
【数据结构】AVL树（万字超详细 附动图）
Eristic0618的博客
04-23 1889
本篇文章围绕数据结构中的AVL树展开讲解，包含AVL树的插入、旋转、验证等内容，万字讲解搭配自制动图
数据结构--AVL树（全）
weixin_48560325的博客
05-01 8719
目录 什么是AVL树？ AVL树的特点及形成原因 二叉搜索树基本概念 二叉搜索的特点 二叉搜索树的优点及缺点 改进的二叉搜索树——AVL树 AVL树的定义 AVL树的特点 结点的平衡因子balance 构建一个AVL树 构建一个AVL树的节点 什么是AVL树？ AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 AVL树的特点及形成原因 AVL树本质.
【高阶数据结构】AVL树（动图详解）_avl tree
最新发布
2401_84447207的博客
05-01 765
此处我们定义成三叉链结构 ，方便后序的操作；也在每个节点引入了平衡因子（右子树高度-左子树高度），还需要实现一下构造函数，左右子树以及父节点都是空，再把平衡因子设置为0即可//定义三叉链//存储的键值对//平衡因子(balance factor)int _bf;//构造函数,\_kv(kv),\_bf(0){}注意：平衡因子不是必须的，只是我们实现高度平衡的一种方式，不用平衡因子也是可以实现的。
详解AVL树（平衡二叉树）
热门推荐
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
Golang 二叉平衡树
qq_39920531的博客
03-07 137
简单地撸了个AVL树练练手 package main import "fmt" type AVLNode struct { left *AVLNode right *AVLNode hight int data int } func (this *AVLNode)FindMaxData() int { if this == nil { return 0 } if th...
AVL树
HappyCode
05-30 285
AVL树 AVL树是平衡二叉搜索树，比普通二叉搜索树多了一个平衡功能； 当一个节点的左子树与右子树的高度差超过1时 ，就被认为是不平衡的。然后通过旋转二叉树维持平衡。 插入操作 左节点的左子树插入操作（单旋转）插入5号： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bq5KXbX4-1590828107599)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530155
数据结构之AVL树详解
12-26
本文介绍了AVL树的设计思想和基本操作。 2. 基本术语 有四种种情况可能导致二叉查找树不平衡，分别为： （1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2 （2）RR：...
基于Qt和Avl树实现登录系统【100013012】
07-19
通过实现这样一个登录系统，学生可以深入理解Qt的图形界面设计和Avl树的数据结构及其应用，同时锻炼到软件工程中的需求分析、设计、编码和测试等各个环节。 总结来说，这个项目结合了GUI开发和数据结构两大主题，...
用python实现AVL树、B树、红黑树的插入、查找和删除操作
10-16
总的来说，Python实现AVL树、B树和红黑树的插入、查找和删除操作，不仅可以加深对这些数据结构的理解，还能通过实际测试验证它们的性能。在实际应用中，选择哪种数据结构往往取决于具体需求，如内存限制、预期的数据...
红黑树和AVL树的实现
01-14
AVL树的平衡性比红黑树更强，因此在查找效率上通常优于红黑树，但插入和删除操作可能需要更多的旋转，导致更复杂的实现。红黑树的平衡要求相对较宽松，插入和删除操作的代价较低，且在实践中表现良好，是许多语言...
avl树实现hash表
12-29
3. AVL树操作：插入、删除和查找的实现，确保树的平衡性。 4. 冲突处理：当哈希值相同时，使用avl树进行键的比较和存储。 5. 测试用例：包含一组输入数据，用于验证avl树实现的哈希表功能是否正确。 这种结合avl树...
AVL树简介
小白的博客
02-24 1万+
一、AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是...
avl删除根节点图解_一文读懂平衡搜索树（AVL树）
weixin_42521949的博客
01-18 466
一、概念AVL树是由GM Adelson - Velsky 和 EM Landis 于1962年发明的。为了纪念其发明者，这树结构被命名为 AVL。AVL树可以定义为高度平衡二叉搜索树，其中每个结点与平衡因子相关联，该平衡因子通过从其左子树的子树中减去其右子树的高度来计算。如果每个结点的平衡因子在 -1 到 1 之间，则称树是平衡的，否则，树将是不平衡的并且需要平衡。平衡系数(K)= 高度(左(K...
avl树的c实现
一步一脚印
10-15 769
一.简介：一看到AVL树，首先联想到岛国动作片有木有，不过AVL树是得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis。 AVL树其实是平衡二叉树的限定版， 二.性质 （1）.不仅仅具有平衡二叉树的所有性质（注：平衡二叉树性质：左节点的值 （2）.每个节点左右子树高度的差最多为1。这是什么意思呢？给个例子大家就明白了 如：
二叉树、二叉搜索树、平衡二叉搜索树、AVL树、红黑树——树篇
Mrrr_Li的博客
12-17 316
本文主要回顾二叉树、二叉搜索树、平衡二叉搜索树、AVL树、B树、红黑树。包含具体的实现代码、部分方法的注释。 树间的继承关系： BinaryTree实现BinaryTreeInfo接口 BinarySearchTree继承BinaryTree BalanceBinarySearchTree继承BinarySearchTree AVLTree和RBTree继承BalanceBinarySearchTree 二叉树 ◼ 二叉树的特点 每个节点的度最大为 2（最多拥有 2 棵子树） 左子树和右子树是有顺序
数据结构（十九）——AVL搜索树及插入、删除操作详细图解
夜的第七章
07-26 1926
文章目录前言AVL树与AVL搜索树AVL搜索树各操作AVL搜索树的搜索(find)AVL搜索树的插入(insert)AVL搜索树的删除(erase) 前言 接着上一节的二叉搜索树，我们今天分析平衡搜索树的一种——AVL搜索树。在《数据结构、应用与算法》这本书中和课程PPT上都没有找到AVL搜索树的代码实现。在书的课程网站上也没找到相应代码。加上复习节奏紧凑，本篇文章暂时不涉及代码，专注于插入和删除操作的逻辑和伪代码，请谅解。 AVL树与AVL搜索树 为什么要学习AVL搜索树？ 请见这里的二叉搜索树部分。 A
AVL树的实现（图文详解）
AllenSquirrel
05-19 4144
AVL树的实现
avl删除根节点图解_图解数据结构树之AVL树
weixin_33181210的博客
01-16 481
AVL树(平衡二叉树)：AVL树本质上是一颗二叉查找树，但是它又具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为平衡二叉树。下面是平衡二叉树和非平衡二叉树对比的例图：平衡因子(bf)：结点的左子树的深度减去右子树的深度，那么显然-1<=bf<=1;AVL树的作用：我...
第五章：查找-2021-21
08-03
7. **AVL树的插入和删除**：插入操作可能导致不平衡，这时通过旋转操作（左旋和右旋）来调整树结构，如LL、RR和LR旋转。例如，章节中的插入示例展示了如何在AVL树中执行这些操作。 通过学习这些内容，学生将理解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值