二叉树之AVL树

已于 2022-03-10 10:20:27 修改
阅读量758 收藏 3
点赞数
分类专栏： 基本数据结构与算法（C语言版本） 文章标签： 数据结构 二叉树 AVL
于 2022-03-09 23:15:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrbone9/article/details/123389078
版权

今天来细说下 AVL 树，并结合图示代码来认识并掌握 AVL 树的创建，删除，体会下 AVL 特有的自平衡性。

目录：

AVL 概念

AVL 的旋转

AVL 树旋转实现

AVL 树代码实现（C语言）

测试实例

AVL 概念

AVL 也是二叉树的一种，所以符合所有二叉树应有的特性，以及遍历方法

与二叉树不同的是，AVL树是一颗平衡树：

节点 root，左子节点的高度 与 右子节点的高度，最大差值 = 1

下面看看 AVL 树的示例：

理论上来讲 root 节点深度 = 1，依次增加，这里相反是因为后续代码初始节点深度 = 1

 再来看看 非 AVL 树的示例，把上图的节点 6 去掉

可见针对 节点 5 来讲，左子树深度=3， 右子树深度=1，已经超过最大深度 1，所以不是 AVL 树

AVL 树的旋转

我们在操作树一定发生：添加或者删除节点，AVL 的状态可能会被破坏，基于不同形态的 非 AVL 树，我们有以下 四种姿态 需要通过旋转重回 AVL 形态

如果把AVL树（平衡树）看做一个人，左右子节点就是左右手提的东西

左手重或者右手重就会失去平衡，失去平衡的原因就是姿态

比如：LR，左子节点深度过大，且是因为左子节点下的右子节点（多余）造成的

形态一：LL 树 （Left-Left）

节点 6 的左右不平衡，原因是

1. Left 节点 4 更重

2.  造成节点 4 更重的原因是 4 的 Left 节点 3 还有子节点

形态二：RR 树 （Right-Right）

节点 3 的左右不平衡，原因是

1. Right 节点 6 更重

2.  造成节点 6 更重的原因是 8 的 Right 节点 8 还有子节点

形态三：LR 树 （Left-Right）

节点 8 的左右不平衡，原因是

1. Left 节点 4 更重

2.  造成节点 4 更重的原因是 4 的 Right 节点 5 还有子节点

形态四：RL 树 （Right-Left）

节点 3 的左右不平衡，原因是

1. Right 节点 8 更重

2.  造成节点 8 更重的原因是 8 的 Left 节点 5 还有子节点

AVL 树旋转实现

形态一：LL 树旋转 

既然左手 K1 重了，那么左手 K1 就当脑袋，脑壳 K2 顺势变成右手，这样占用了 新脑袋的右手，原本 K1 的右手就只能丢给 K2 的左手

/* LL Rotation AVL Tree 
** Parameters:
**		root - avl tree
**
		k2						k1
	k1		c	-LL->		a		k2
  a    b				  d	       b   c
d  
*/
PNode ll_rotation(PNode k2)
{
	PNode k1;
	
	k1 = k2->left;
	k2->left = k1->right;
	k1->right = k2;
	
	k2->deep = MAX( DEEP(k2->left), DEEP(k2->right) ) + 1;
	k1->deep = MAX( DEEP(k1->left), k2->deep ) + 1;
	
	return k1;
}

形态二：RR 树旋转  

 既然右手 K2 重了，那么右手 K2 就当脑袋，脑壳 K1 顺势变成左手，这样占用了 新脑袋的左手，原本 K2 的左手就只能丢给 K1 的右手

/* RR Rotation AVL Tree 
** Parameters:
**		root - avl tree
**
		k1						k2
	a		k2	 -RR->		k1		c
		  b    c		  a   b		  d
				 d
*/
PNode rr_rotation(PNode k1)
{
	PNode k2;
	
	k2 = k1->right;
	k1->right = k2->left;
	k2->left = k1;
	
	k1->deep = MAX( DEEP(k1->left), DEEP(k1->right) ) + 1;
	k2->deep = MAX( DEEP(k2->right), k1->deep ) + 1;
	
	return k2;
}

形态三：LR 树旋转

需经过两次变化，RR + LL ，按照右到左（LR）名字

/* LR Rotation AVL Tree 
** Parameters:
**		root - avl tree
**
		k3						k3						k2
	k1		d	--RR->		k2		d		--LL->	 k1     k3
  a	  k2				  k1   c				   a   b   c   d
     b  c				a    b
*/
PNode lr_rotation(PNode k3)
{
	PNode k1, k2;
	
	k1 = k3->left;
	k2 = rr_rotation(k1);
	k3->left = k2;
	
	k2 = ll_rotation(k3);
	
	return k2;
}

形态四：RL 树旋转

 需经过两次变化，LL+RR ，按照右到左（RL）名字

/* LR Rotation AVL Tree 
** Parameters:
**		root - avl tree
**
		k3						k3						k2
	k1		d	--RR->		k2		d		--LL->	 k1     k3
  a	  k2				  k1   c				   a   b   c   d
     b  c				a    b
*/
PNode lr_rotation(PNode k3)
{
	PNode k1, k2;
	
	k1 = k3->left;
	k2 = rr_rotation(k1);
	k3->left = k2;
	
	k2 = ll_rotation(k3);
	
	return k2;
}

AVL 树代码实现

有个限定：

1. 左子节点值 < root 节点值 < 右子节点值

2. 不存在相同节点值

数据结构

typedef struct AVLTreeNode{
	int val;
	int deep;
	struct AVLTreeNode *left;
	struct AVLTreeNode *right;
}Node, *PNode;

 获取树深

#define DEEP(node) ( node == NULL ? 0 : node->deep )

/* Get AVL Tree's Deep
** Parameters:
**		root - avl tree
** Note: Deep incream from leaf(1) to root
**
*/
int avltree_get_deep(PNode root)
{
	return DEEP(root);
}

获取树的最小值的节点

/* Get AVL Tree's Minimum Val Node
** Parameters:
**		root - avl tree
*/
PNode avltree_get_min(PNode root)
{
	if(root == NULL)
		return NULL;
	
	while(root->left)
		root = root->left;
	
	return root;
}

 获取树的最大值的节点 

/* Get AVL Tree's Minimum Val Node
** Parameters:
**		root - avl tree
*/
PNode avltree_get_min(PNode root)
{
	if(root == NULL)
		return NULL;
	
	while(root->left)
		root = root->left;
	
	return root;
}

 创建树的节点

/* Create AVL Tree Node
** Parameters:
**		val - val
**		left - left child
**		right - right child
*/
PNode avltree_create_node(int val, PNode left, PNode right)
{
	PNode newNode = (PNode)malloc(sizeof(Node));
	if(newNode == NULL)
		return NULL;
	
	newNode->val = val;
	newNode->deep = 1;
	newNode->left = left;
	newNode->right = right;
	
	return newNode;
}

查找树的节点 

/* Search Node of AVL Tree
** Parameters:
**		root - avl tree
**		val - node's val
*/
PNode avltree_search_node(PNode root, int val)
{
	if(root == NULL || root->val == val)
		return root;
		
	if(val < root->val)
		return avltree_search_node(root->left, val);
	else
		return avltree_search_node(root->right, val);
}

 插入节点到树，如果没有根节点则创建根节点

/* Insert New Node to AVL Tree
** Parameters:
**		root - avl tree
**		val - node to insert
*/
PNode avltree_insert_node(PNode root, int val)
{
	if(root == NULL)	
	{
		root = avltree_create_node(val, NULL, NULL);
		if(root == NULL)
			return NULL;
	}
	else if(val < root->val)
	{
		root->left = avltree_insert_node(root->left, val);
		
		if( ( DEEP(root->left) - DEEP(root->right) ) == 2 )
		{
			if(val < root->left->val)
			{
				printf("do ll...val=%d\n", val);
				root = ll_rotation(root);
			}
			else
			{
				printf("do lr...val=%d\n", val);
				root = lr_rotation(root);
			}
		}
	}
	else if(val > root->val)
	{
		root->right = avltree_insert_node(root->right, val);
		
		if( ( DEEP(root->right) - DEEP(root->left) ) == 2 )
		{
			if(val > root->right->val)
			{
				printf("do rr...val=%d\n", val);
				root = rr_rotation(root);
			}
			else
			{
				printf("do rl...val=%d\n", val);
				root = rl_rotation(root);
			}
		}
	}
	else
		printf("insert %d fails, val exsits.\n", val);
	
	root->deep = MAX( DEEP(root->left), DEEP(root->right) ) + 1;
	
	return root;
}

 删除指定值得节点

/* Delete Node of AVL Tree
** Parameters:
**		root - avl tree
**		val - node's val
*/
PNode avltree_delete_node_by_val(PNode root, int val)
{
	PNode node;
	
	node = avltree_search_node(root, val);
	
	if(node)
	{
		printf("find node, val=%d\n", node->val); 
		avltree_delete_node(root, node);
	}
	else
		printf("not find val:%d\n", val);
		 
	return root;
}

 删除指定节点

/* Delete Node of AVL Tree
** Parameters:
**		root - avl tree
**		node - node to delete
*/
PNode avltree_delete_node(PNode root, PNode node)
{
	if(root == NULL || node == NULL)
		return NULL;
		
	if(node->val < root->val)	// left side
	{
		root->left = avltree_delete_node(root->left, node);
		if(DEEP(root->right) - DEEP(root->left) == 2)
		{
			PNode r = root->right;
			if(DEEP(r->left) > DEEP(r->right))
				root = rl_rotation(root);
			else
				root = rr_rotation(root);
		}
	}
	else if(node->val > root->val) // right side
	{
		root->right = avltree_delete_node(root->right, node);
		if(DEEP(root->left) - DEEP(root->right) == 2)
		{
			PNode l = root->left;
			if(DEEP(l->left) > DEEP(l->right))
				root = ll_rotation(root);
			else
				root = lr_rotation(root);
		}
	}
	else // find
	{
		if(root->left && root->right)
		{
			if(DEEP(root->left) > DEEP(root->right))
			{
				// 1. find max node in left side
				// 2. set max node val to root
				// 3. delete max node
				PNode maxNode = avltree_get_max(root->left);
				root->val = maxNode->val;
				root->left = avltree_delete_node(root->left, maxNode);
			}
			else
			{
				// 1. find min node in right side
				// 2. set min node val to root
				// 3. delete min node
				PNode minNode = avltree_get_min(root->right);
				root->val = minNode->val;
				root->right = avltree_delete_node(root->right, minNode);
			}
		}
		else
		{
			PNode tmp = root;
			root = root->left ? root->left : root->right;
			free(tmp);
		}
	}
	
	return root;
}

销毁树 

/* Destory AVL Tree
** Parameters:
**		root - avl tree
*/
void avltree_destory(PNode root)
{
	if(root == NULL)
		return;
	
	if(root->left)
		avltree_destory(root->left);
	if(root->right)
		avltree_destory(root->right);
	
	printf("free %d\n", root->val);
	free(root);
}

测试实例

int main(void)
{
	int i;
	int len;
	int nodes[] ={3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
	len = sizeof(nodes) / sizeof(nodes[0]);
	
	PNode root = NULL;
	for(i=0; i<len; i++)
	{
		root = avltree_insert_node(root, nodes[i]);
	}
	
	printf("\npreorder:\n");
	preorder(root);
	
	printf("\ninorder:\n");
	inorder(root);
	
	printf("\npreorder:\n");
	postorder(root);
	
	printf("\nroot's deep: %d\n", DEEP(root));
	printf("\nminimum: %d\n", avltree_get_min(root)->val);
	printf("\nmaxmum: %d\n", avltree_get_max(root)->val);

	printf("-----------delete node start-------\n");
	avltree_delete_node_by_val(root, 12);
	printf("\npreorder:\n");
	preorder(root);
	printf("\n");
	
	avltree_delete_node_by_val(root, 2);
	printf("\npreorder:\n");
	preorder(root);
	printf("\n");
	
	printf("-----------delete node end-------\n");
	
	
	printf("\ndesotry avl tree\n");
	avltree_destory(root);
	
	return 0;
}

构建完成的树：

 

 执行结果：

do ll...val=1
do rr...val=5
do rr...val=6
do rr...val=7
do rl...val=15
do rl...val=14
do rr...val=13
do ll...val=12
do ll...val=11
do ll...val=10
do lr...val=9

preorder:
val=7, deep=5
val=4, deep=3
val=2, deep=2
val=1, deep=1
val=3, deep=1
val=6, deep=2
val=5, deep=1
val=13, deep=4
val=11, deep=3
val=9, deep=2
val=8, deep=1
val=10, deep=1
val=12, deep=1
val=15, deep=2
val=14, deep=1
val=16, deep=1

inorder:
val=1, deep=1
val=2, deep=2
val=3, deep=1
val=4, deep=3
val=5, deep=1
val=6, deep=2
val=7, deep=5
val=8, deep=1
val=9, deep=2
val=10, deep=1
val=11, deep=3
val=12, deep=1
val=13, deep=4
val=14, deep=1
val=15, deep=2
val=16, deep=1

preorder:
val=1, deep=1
val=3, deep=1
val=2, deep=2
val=5, deep=1
val=6, deep=2
val=4, deep=3
val=8, deep=1
val=10, deep=1
val=9, deep=2
val=12, deep=1
val=11, deep=3
val=14, deep=1
val=16, deep=1
val=15, deep=2
val=13, deep=4
val=7, deep=5

root's deep: 5

minimum: 1

maxmum: 16
-----------delete node start-------
find node, val=12

preorder:
val=7, deep=5
val=4, deep=3
val=2, deep=2
val=1, deep=1
val=3, deep=1
val=6, deep=2
val=5, deep=1
val=13, deep=4
val=10, deep=3
val=9, deep=2
val=8, deep=1
val=11, deep=1
val=15, deep=2
val=14, deep=1
val=16, deep=1

find node, val=2

preorder:
val=7, deep=5
val=4, deep=3
val=3, deep=2
val=1, deep=1
val=6, deep=2
val=5, deep=1
val=13, deep=4
val=10, deep=3
val=9, deep=2
val=8, deep=1
val=11, deep=1
val=15, deep=2
val=14, deep=1
val=16, deep=1

-----------delete node end-------

desotry avl tree
free 1
free 3
free 5
free 6
free 4
free 8
free 9
free 11
free 10
free 14
free 16
free 15
free 13
free 7

小结

总算是描述完成（其实还没有，依据示例进行构建的过程留给用心的朋友自行画图，看看结果是否符合预期，这样才能加深 AVL 几种姿态的转变的理解），对照代码和图示应该对 AVL 树有了新的认识

早期在工作项目中有看到基于 AVL 树的实现，当时一头雾水，现在是时候重温了

更多数据结构详解

mrbone9
关注
专栏目录
5分钟了解二叉树之AVL树.doc
07-12
AVL树是自平衡二叉查找树的一种，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。它是最早被发明的自平衡树，其核心特性是任何节点的左右子树高度差不超过1，确保了树的平衡性，从而提高了查找...
数据结构:AVL树详解(平衡二叉树)
机会是给有准备的人
11-11 4400
假如以 parent 为根的子树不平衡，即 parent 的平衡因子为2或者-2，分以下情况考虑parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
数据结构 —— 图解AVL树(平衡二叉树)
热门推荐
猎人在吃肉
07-28 4万+
文章目录1、AVL树(平衡二叉树)的定义1.1、平衡因子2、AVL树的作用：3、AVL树的基本操作3.1、插入—— 左左型的右旋：3.1.1、右旋的具体步骤：3.1.2、右旋的动画演示：3.1.3、右旋示例：3.2、插入——右右型的左旋：3.2.1、左旋的具体步骤：3.2.2、动画演示：3.2.3、左旋举例：3.3、插入——左右型的左右旋 ( 即先左后右)：3.3.1、左右旋的两次旋转步骤：3.3...
二叉平衡树之AVL树
最新发布
2301_79937517的博客
08-31 714
若向平衡二叉树中插入一个节点后破坏了平衡二叉树的平衡性，首先从根节点到该新插入节点的路径之逆向根节点方向找到第一个失去平衡的节点，然后以该失衡节点和它相邻的刚查找过的两个节点构成调整子树，使之成为新的平衡子树。故需进行两次旋转操作（先顺时针，后逆时针），即先将A结点的右孩子C的左子树的根结点D向右上旋转提升到C结点的位置，然后再把该D结点向左上旋转提升到A结点的位置。注意：对于AVL树的插入，因为它是要结合AVL树的旋转的，所以在本文中，AVL树的插入和AVL树的旋转合起来才是完整的插入过程。
AVL树（动图详解）
2021dragon的博客
12-02 2万+
AVL树（C++实现）
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
平衡二叉树（AVL）详解
H_Q_Li的博客
04-04 4134
平衡二叉树（AVL） 1、为什么会出现平衡二叉树 平衡二叉树（Balanced Binary Tree），又称AVL树，指的是左子树上的所有节点的值都比根节点的值小，而右子树上的所有节点的值都比根节点的值大，且左子树与右子树的高度差最大为1。 平衡二叉树性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 知道了平衡二叉树的概念之后，我们来聊聊为什么会...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
使用Java实现平衡二叉树(AVL树)
08-03
这段 Java 代码实现了一个 AVL 树（平衡二叉搜索树）的数据结构。 **类和内部类**： * `AVLTree`：主类，包含 AVL 树的操作方法和属性。 * `TreeNode`：内部类，代表 AVL 树的节点，包含节点值、左右子树指针、父...
js代码-二叉树-AVL树
07-14
它是最早被提出的自平衡二叉树数据结构之一。AVL树的主要特性是任何节点的两个子树的高度最大差别不超过1，这保证了树的平衡性，从而确保了搜索、插入和删除等操作的时间复杂度为O(log n)。 在JS中实现AVL树，我们...
【数据结构基础】树 - 平衡二叉树(AVL)
DeveloperFire的博客
02-01 4040
平衡二叉树（Balanced Binary Tree）具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于一个递归的数列，可以参考Fibonacci数列，1是根节点，F(n-1)是左子树的节点数量，F(n-2)是右子树的节点数量。
算法：二叉平衡树（AVL树）
OceanStar的博客
10-07 7357
平衡二叉树定义 平衡二叉树 全称叫做 平衡二叉搜索（排序）树，简称 AVL树。英文：Balanced Binary Tree （BBT），注：二叉查找树(BST) AVL 什么意思？AVL 是大学教授 G.M. Adelson-Velsky 和 E.M. Landis 名称的缩写，他们提出的平衡二叉树的概念，为了纪念他们，将 平衡二叉树 称为 AVL树。 AVL树本质上是一颗二叉查找树，但是它又具有以下特点： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 左右两个子树 也都是一棵平衡二叉树。
数据结构——AVL树详解
rab1211764820的博客
03-28 2782
AVL树的模拟实现 AVL树的插入、旋转、删除、查找 AVL树的验证 AVL树的平衡因子
AVL树（平衡二叉搜索树）
langk_的博客
09-03 3654
带你手撕AVL树，左单旋，右单旋，左右双旋，右左双旋
数据结构-AVL树（平衡二叉树）
m0_61433144的博客
08-11 1040
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
平衡二叉树(AVL树)
weixin_61898526的博客
05-17 551
平衡二叉树：是一种二叉排序树，其中每一个结点的左子树和右子树的高度差至多等于1 平衡因子：二叉树上结点的左子树深度减去右子树深度的值(因为是平衡二叉树，所以平衡因子的值只可能是-1、0、1) 最小不平衡子树：在插入结点时，距离插入结点最近的，且平衡因子的绝对值大于1的结点为根的子树 ...
AVL树（平衡二叉树）的底层原理以及实现
荣耀与梦想来日方长
03-11 1406
前言 Wiki:在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是{\displaystyle O(\log {n})} 。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL 树得名于它的发明者G. M. Adelson-Velsky和Evgenii Landis，他们在1962年的论文《An algorithm for the org...
二叉搜索树（AVL树）
k5426244的博客
08-10 365
节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。带有平衡因子1、0或-1的节点被认为是平衡的。带有平衡因子-2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。// 该节点的左孩子// 该节点的右孩子// 该节点的双亲// 该节点所保存的数据int _bf;// balance factor // 该节点的平衡因子, _kv(kv), _bf(0){}public://插入//遍历。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值