手撕AVL树 (C++ 实现）

转x33g5p2x  于2022-06-29 转载在 其他  
字(10.6k)|赞(0)|评价(0)|浏览(453)

⏰1.AVL树的概念

之前提到的二叉搜索树效率为logN，但是当插入节点有序的时候效率退化为O(N)，这可就很致命了。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：
当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树是具有以下特点的二叉搜索树：

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

⏰2.AVL树实现思路

🎄结点的定义

因为涉及到了大量的平衡因子调节，所以需要保存父节点的指针，选择用三叉链的结构。

  1. template<class K, class V>
  2. struct AVLTreeNode
  3. {
  4.     AVLTreeNode(const pair<K,V>& kv)
  5. 		:_left(nullptr)
  6. 		,_right(nullptr)
  7. 		,_parent(nullptr)
  8. 		,_kv(kv)
  9. 		,_bf(0)
  10. 	{}
  11. 	AVLTreeNode<K, V>* _left;//该结点的左孩子
  12. 	AVLTreeNode<K, V>* _right;//该结点的右孩子
  13. 	AVLTreeNode<K, V>* _parent;//该结点的双亲
  14. 	pair<K, V> _kv;
  15. 	int _bf;//该结点的平衡因子
  16. };

🎄AVL树的查找

AVL树的查找跟搜索树一样
1.若为空树，返回空
2.key值比当前结点的key值大就到右边找
3.key值比当前结点的key值大就到左边找
4.key值和当前结点的key值相等或者没找到返回false

  1. Node* Find(const K& key)
  2. {
  3. 	//根据二叉搜索树的性质，从根节点出发，比根节点大则查找右子树，比根节点小则查找左子树
  4. 	Node* cur = _root;
  6. 	while (cur)
  7. 	{
  8. 		//比根节点大则查找右子树
  9. 		if (key > cur->_kv.first)
  10. 		{
  11. 			cur = cur->_right;
  12. 		}
  13. 		//比根节点小则查找左子树
  14. 		else if (key < cur->_kv.first)
  15. 		{
  16. 			cur = cur->_left;
  17. 		}
  18. 		//相同则返回
  19. 		else
  20. 		{
  21. 			return cur;
  22. 		}
  23. 	}
  25. 	//遍历完则说明查找不到，返回false
  26. 	return nullptr;
  27. }

🎄AVL树的平衡因子

**平衡因子，其实就是左右子树的高度差。AVL树通过控制高度差不超过1，来实现平衡。**当插入一个新的结点它祖先的平衡因子都会收到影响。

平衡因子的更新规则：
1.新增结点在parent的右边，平衡因子++
2.新增结点在parent的左边，平衡因子- -

例如：

右子树插入一个90，根节点平衡因子+1

每更新完一个结点的平衡因子后，都需要进行判断：
1.parent的平衡因子等于1或者-1则继续往上更新
2.parent的平衡因子等于0，则停止更新
3.parent的平衡因子等于2或者-2，说明已经不平衡了需要进行旋转处理

分析：

1.parent更新后的平衡因子为1或-1，则说明在parent的右边或者左边新增了结点，从而影响了parent的父亲结点所以要继续往上更新平衡因子。
2.parent更新后的平衡因子为0，1或-1经过++或- -变成0，说明新增结点在parent高的一侧使得parent的左右子树一样高，不会影响parent的父亲结点，就不用往上更新平衡因子。
3.parent更新后的平衡因子为2或-2，parent的左右子树差的绝对值大于1，已经不满足AVL树，需要旋转处理。

🎄AVL树的旋转(important!!!)

旋转分为四种情景，简单点总结的话就是如果节点呈直线则单旋，折线则双旋，下面一一分析。

📕右单旋

具象图：

具象图情况太多，上面就举一个例子便于理解，下面用抽象图概括：

需要注意的细节：
1.subLR可能为空
2.先把30的右给60的左，在让60整棵树左30的右子树。因为是三叉链实现的，所以还要注意修改动的结点的父亲结点
3.60可能是子树，也有可能是单独的树

右旋的步骤:

  1. 让不平衡的结点parent的左子树变为其原本左子树subL的右节点subLR
  2. 让parent变为subL的右子树
  3. 调整新的父节点subL与祖父节点的关系，并调整旋转后的平衡因子
  1. //右旋
  2. void RotateR(Node* parent)
  3. {
  4.     //步骤1  让不平衡的结点parent的左子树变为其原本左子树subL的右节点subLR
  5. 	Node* subL = parent->_left;
  6. 	Node* subLR = subL->_right;
  7. 	parent->_left = subLR;
  8. 	//如果subLR存在，则让他的父节点指向parent。
  9. 	if (subLR)
  10. 	{
  11. 		subLR->_parent = parent;
  12. 	}
  13.     
  14.     //步骤2 让parent变为subL的右子树
  15. 	subL->_right = parent;
  16.     
  17.     //步骤3 调整新的父节点subL与祖父节点的关系，并调整旋转后的平衡因子
  18. 	Node* ppNode = parent->_parent;//保存原本的祖父节点
  19. 	parent->_parent = subL;//更新parent的父节点
  21. 	//两种情况
  22. 	//如果parent为根节点，则让subL成为新的根节点
  23. 	if (parent == _root)
  24. 	{
  25. 		_root = subL;
  26. 		subL->_parent = nullptr;
  27. 	}
  28. 	//如果不是根节点，则改变subL与其祖父节点的指向关系
  29. 	else
  30. 	{
  31. 		if (ppNode->_left == parent)
  32. 		{
  33. 			ppNode->_left = subL;
  34. 		}
  35. 		else
  36. 		{
  37. 			ppNode->_right = subL;
  38. 		}
  39. 		subL->_parent = ppNode;
  40. 	}
  42. 	//左旋完成后平衡，平衡因子归零。
  43. 	subL->_bf = parent->_bf = 0;
  44. }

📕左旋

左旋的思路和右旋一样，只是将顺序翻了过来。
当右边不平衡，并且节点呈直线时（右节点的右边偏重），说明需要左旋处理。

具象图

抽象图

左旋的步骤：

  1. 让不平衡的结点parent的右子树变为其原本右子树subR的左节点subRL
  2. 让parent变为subR的左子树
  3. 调整新的父节点subR与祖父节点的关系，并调整旋转后的平衡因子
  1. //左旋
  2. void RotateL(Node* parent)
  3. {
  4. 	Node* subR = parent->_right;
  5. 	Node* subRL = subR->_left;
  7. 	parent->_right = subRL;
  9. 	if (subRL)
  10. 	{
  11. 		subRL->_parent = parent;
  12. 	}
  14. 	subR->_left = parent;
  15. 	Node* ppNode = parent->_parent;
  16. 	parent->_parent = subR;
  18. 	if (parent == _root)
  19. 	{
  20. 		_root = subR;
  21. 		subR->_parent = nullptr;
  22. 	}
  23. 	else
  24. 	{
  25. 		if (ppNode->_left == parent)
  26. 		{
  27. 			ppNode->_left = subR;
  28. 		}
  29. 		else
  30. 		{
  31. 			ppNode->_right = subR;
  32. 		}
  34. 		subR->_parent = ppNode;
  35. 	}
  37. 	subR->_bf = parent->_bf = 0;
  38. }

📕右左双旋

分类讨论

情况1：新增节点在C

情况2：新增节点在b

情况3：本身就是新增节点

右左双旋的步骤：
1.首先因为不平衡那个方向的子树的反方向偏重，呈折现状态，所以需要对其右旋转，让树恢复到直线状态
2.直线状态时就和一开始的单旋思路一样，按照单旋处理
3.调节平衡因子，根据subRL一开始的平衡因子进行调节，有两种情况，为-1时subR结束后为1，为1时parent结束后为-1。

总结上面的情况：需记录subRL的平衡因子，保存subR，subRL。根据subRL的平衡因子在更新其他需要更新的平衡因子

情况一：当subRL的平衡因子=1时，subR,subRL,parent的平衡因子分别是0，0，-1
情况二：当subRL的平衡因子=-1时，subR,subRL,parent的平衡因子分别是1，0，0
情况三：当subRL的平衡因子=0时，subR,subRL,parent的平衡因子的都是0

  1. //右左双旋
  2. void RotateRL(Node* parent)
  3. {
  4. 	Node* subR = parent->_right;
  5. 	Node* subRL = subR->_left;
  6. 	//这里需要保存subRL的平衡因子，来调节旋转完后的平衡因子
  7. 	int bf = subRL->_bf;
  9. 	//先右单旋将折线结构转换为直线结构，也就是前面单旋就可以解决的问题。
  10. 	RotateR(subR);
  11. 	//然后再左单旋即可
  12. 	RotateL(parent);
  14. 	//根据subRL的bf来调节旋转后的平衡因子
  15. 	if (bf == 1)
  16. 	{
  17. 		parent->_bf = -1;
  18. 		subR->_bf = 0;
  19. 		subRL->_bf = 0;
  20. 	}
  21. 	else if (bf == -1)
  22. 	{
  23. 		parent->_bf = 0;
  24. 		subR->_bf = 1;
  25. 		subRL->_bf = 0;
  26. 	}
  27. 	else
  28. 	{
  29. 		parent->_bf = 0;
  30. 		subR->_bf = 0;
  31. 		subRL->_bf = 0;
  32. 	}
  33. }

📕左右双旋

与右左类似，图片不再细化了，读者可以尝试自己画画。

总结平衡因子的变化：根据subLR的平衡因子在更新其他需要更新的平衡因子
1.当subLR的平衡因子=1时，subL,subLR,parent的平衡因子分别是-1,0.0;
2.当subLR的平衡因子=-1时，subL,subLRL,parent的平衡因子分别是0,0,1;
3.当subLR的平衡因子=0时，subL,subLR,parent的平衡因子的都是0

  1. //左右双旋
  2. void RotateLR(Node* parent)
  3. {
  4. 	Node* subL = parent->_left;
  5. 	Node* subLR = subL->_right;
  7. 	int bf = subLR->_bf;
  9. 	RotateL(subL);
  10. 	RotateR(parent);
  12. 	if (bf == 1)
  13. 	{
  14. 		parent->_bf = 0;
  15. 		subL->_bf = -1;
  16. 		subLR->_bf = 0;
  17. 	}
  18. 	else if (bf == -1)
  19. 	{
  20. 		parent->_bf = 1;
  21. 		subL->_bf = 0;
  22. 		subLR->_bf = 0;
  23. 	}
  24. 	else
  25. 	{
  26. 		parent->_bf = 0;
  27. 		subL->_bf = 0;
  28. 		subLR->_bf = 0;
  29. 	}
  30. }

🎄AVL树的插入

插入分为三个步骤

  1. 按照二叉搜索树的规则找到合适的位置插入
  2. 更新插入后的平衡因子
  3. 根据平衡因子来选择是否进行旋转调节。

有了前面旋转的基础，这里直接复用代码就行，具体步骤也写在注释里

  1. bool insert(const pair<K, V>& kv)
  2. {	//树为空，new一个新节点
  3.     if (_root == nullptr)
  4.     {
  5.         _root = new Node(kv);
  6.         return true;
  7.     }
  8.     Node* cur = _root;
  9.     Node* parent = cur;
  10.     while (cur)
  11.     {
  12.         if (cur->_kv.first > kv.first)//插入结点的key值小于当前结点，往左走
  13.         {
  14.             parent = cur;
  15.             cur = cur->_left;
  16.         }
  17.         else if (cur->_kv.first < kv.first)//插入结点的key值大于当前结点，往右走
  18.         {
  19.             parent = cur;
  20.             cur = cur->_right;
  21.         }
  22.         else
  23.         {
  24.             return false;//没有找到，返回false
  25.         }
  26.     }
  27.     //插入节点
  28.     cur = new Node(kv);
  29.     if (parent->_kv.first < kv.first)
  30.     {
  31.         //注意是三叉链，还要链接上parent
  32.         parent->_right = cur;
  33.         cur->_parent = parent;
  34.     }
  35.     else
  36.     {
  37.         //要链接上parent
  38.         parent->_left = cur;
  39.         cur->_parent = parent;
  40.     }
  41.     //控制平衡
  42.     //1.更新平衡因子
  43.     //2.如果出现不平衡则需要旋转处理
  44.     while (parent)
  45.     {
  46.         //在父亲结点左边插入平衡因子--,右边则++
  47.         if (parent->_left == cur)
  48.             parent->_bf--;
  49.         else
  50.             parent->_bf++;
  52.         //1.平衡因子=0就不要更新平衡因子了
  53.         //2.=1或-1则要继续往上调整
  54.         //3.=2或-2则要旋转处理
  55.         if (parent->_bf == 0)
  56.         {
  57.             break;
  58.         }
  59.         else if (parent->_bf == -1 || parent->_bf == 1)
  60.         {
  61.             //继续向上调整平衡因子
  62.             cur = parent;
  63.             parent = parent->_parent;
  64.         }
  65.         //此时不平衡，需要旋转
  66.         else if (parent->_bf == -2 || parent->_bf == 2)
  67.         {
  68.             旋转分四种情况，直线单旋，折线双旋
  69.             if (parent->_bf == -2)
  70.             {
  71.                 if (cur->_bf == -1)
  72.                 {
  73.                     //左边不平衡，并且子节点也是左边偏重，右单旋
  74.                     RotateR(parent);
  75.                 }
  76.                 else
  77.                 {
  78.                     //左右双旋
  79.                     RotateLR(parent);
  80.                 }
  81.             }
  82.             else //parent->_bf == 2
  83.             {
  84.                 if (cur->_bf == 1)
  85.                 {
  86.                     //如果右边不平衡，并且子节点也是右边偏重，则左单旋
  87.                     RotateL(parent);
  88.                 }
  89.                 else
  90.                 {
  91.                     //如果右边不平衡，而子节点是左边偏重，此时需要先转换为上面的状态，先右单旋再左单旋。但是不能直接右单旋再左单旋，还需要根据情况处理平衡因子。
  92.                     RotateRL(parent);
  93.                 }
  94.             }
  95.             break;
  96.         }
  97.         else 
  98.         {
  99.             //走到这里就不是旋转的问题,你要检查别的问题
  100.             assert(false);
  101.         }			
  102.     }
  103.     return true;
  104. }

🎄AVL树的删除

AVL树的删除极为复杂，可以不要求掌握，了解即可，但是其实删除的思路和插入类似，分为以下几步。
1.按照二叉搜索树的规则删除
2.更新平衡因子，并且进行旋转来调整（最坏情况下可能会一直调整到根节点）。

这里就直接复用上面平衡因子更新的代码以及之前博客实现的二叉搜索树的删除。

  1. bool erase(const K& key)
  2. {
  3. 	//删除直接按照二叉搜索树的规则删除，然后再进行平衡因子的更新即可
  4. 	Node* cur = _root;
  5. 	Node* parent = cur;
  6. 	/*
  7. 		删除有三种情况，一种是删除叶子节点，可以直接删除
  8. 		第二种情况，如果删除的节点只有一个子树，那么删除这个节点后，就让父节点指向他的这一子树
  9. 		前两种情况可以合并处理
  11. 		第三种情况则是左右子树都不为空，此时选择一个来节点来替换他后，再删除，就可以不破坏原有结构
  12. 		如果要保持原有结构不变化，那么选择的节点必须要和删除节点在中序遍历中是连续的，而满足的只有两个节点，一个是其左子树的最大值，一个是其右子树的最小值。
  13. 	*/
  14. 	//删除部分
  15. 	while (cur)
  16. 	{
  17. 		//找到删除的位置
  18. 		if (key > cur->_kv.first)
  19. 		{
  20. 			parent = cur;
  21. 			cur = cur->_right;
  22. 		}
  23. 		else if (key < cur->_kv.first)
  24. 		{
  25. 			parent = cur;
  26. 			cur = cur->_left;
  27. 		}
  28. 		else
  29. 		{
  30. 			//前两种情况合并处理，如果当前结点只有一个子树，则让父节点指向他的子树
  31. 			//处理只有右子树时					
  32. 			if (cur->_left == nullptr)
  33. 			{
  34. 				//如果当前节点为根节点，则让右子树成为新的根节点
  35. 				if (cur == _root)
  36. 				{
  37. 					_root = cur->_left;
  38. 				}
  39. 				else
  40. 				{
  41. 					//判断当前节点是他父节点的哪一个子树
  42. 					if (parent->_right == cur)
  43. 					{
  44. 						parent->_right = cur->_right;
  45. 					}
  46. 					else
  47. 					{
  48. 						parent->_left = cur->_right;
  49. 					}
  50. 				}
  52. 				delete cur;
  53. 			}
  54. 			//处理只有左子树时	
  55. 			else if (cur->_right == nullptr)
  56. 			{
  57. 				//如果当前节点为根节点，则让左子树成为新的根节点
  58. 				if (cur == _root)
  59. 				{
  60. 					_root = cur->_right;
  61. 				}
  62. 				else
  63. 				{
  64. 					if (parent->_right == cur)
  65. 					{
  66. 						parent->_right = cur->_left;
  67. 					}
  68. 					else
  69. 					{
  70. 						parent->_left = cur->_left;
  71. 					}
  72. 				}
  74. 				delete cur;
  75. 			}
  76. 			//处理左右子树都不为空时,选取左子树的最右节点或者右子树的最左节点
  77. 			else
  78. 			{
  79. 				//这里我选取的是左子树的最右节点
  81. 				Node* LeftMax = cur->_left;
  82. 				Node* LeftMaxParent = cur;
  84. 				//找到左子树的最右节点
  85. 				while (LeftMax->_right)
  86. 				{
  87. 					LeftMaxParent = LeftMax;
  88. 					LeftMax = LeftMax->_right;
  89. 				}
  91. 				//替换节点
  92. 				std::swap(cur->_kv, LeftMax->_kv);
  94. 				//判断当前节点是他父节点的哪一个子树, 因为已经是最右子树了，所以这个节点的右子树为空，但是左子树可能还有数据，所以让父节点指向他的左子树
  95. 				//并且删除最右节点
  96. 				if (LeftMax == LeftMaxParent->_left)
  97. 				{
  98. 					LeftMaxParent->_left = LeftMax->_left;
  99. 				}
  100. 				else
  101. 				{
  102. 					LeftMaxParent->_right = LeftMax->_left;
  103. 				}
  105. 				delete LeftMax;
  106. 			}
  108. 			//删除成功，中断
  109. 			break;
  110. 		}
  111. 	}
  113. 	//查找不到
  114. 	if (cur == nullptr)
  115. 		return false;
  117. 	//更新平衡因子
  118. 	while (parent)
  119. 	{
  120. 		//更新父节点的平衡因子，注意这里和插入是反过来的，因为是删除
  121. 		if (cur == parent->_left)
  122. 		{
  123. 			parent->_bf++;
  124. 		}
  125. 		else
  126. 		{
  127. 			parent->_bf--;
  128. 		}
  130. 		//判断更新后父节点是否平衡
  132. 		//平衡
  133. 		if (parent->_bf == 0)
  134. 		{
  135. 			break;
  136. 		}
  137. 		//高度发生变化，要继续往上判断
  138. 		else if (parent->_bf == 1 || parent->_bf == -1)
  139. 		{
  140. 			cur = parent;
  141. 			parent = parent->_parent;
  142. 		}
  143. 		//此时不平衡，需要旋转
  144. 		else if (parent->_bf == 2 || parent->_bf == -2)
  145. 		{
  146. 			//旋转分四种情况，直线单旋，折线双旋
  148. 			if (parent->_bf == 2)
  149. 			{
  150. 				//如果右边不平衡，并且子节点也是右边偏重，则左单旋
  151. 				if (cur->_bf == 1)
  152. 				{
  153. 					RotateL(parent);
  154. 				}
  155. 				//如果右边不平衡，而子节点是左边偏重，此时需要先转换为上面的状态，先右单旋再左单旋。但是不能直接右单旋再左单旋，还需要根据情况处理平衡因子
  156. 				else
  157. 				{
  158. 					RotateRL(parent);
  159. 				}
  160. 			}
  161. 			else
  162. 			{
  163. 				//左边不平衡，并且子节点也是左边偏重，右单旋
  164. 				if (cur->_bf == -1)
  165. 				{
  166. 					RotateR(parent);
  167. 				}
  168. 				//同上，左右双旋
  169. 				else
  170. 				{
  171. 					RotateLR(parent);
  172. 				}
  173. 			}
  175. 			//旋转完后恢复平衡，更新结束。
  176. 			break;
  177. 		}
  178. 	}
  180. 	return true;
  181. }

🎄AVL树的验证

AVL树有两点需要验证：二叉搜索和高度平衡
1.二叉搜索树的特性，可以通过中序遍历来看看是否有序来判断。
2.高度平衡可以通过判断他所有的子树是否两边高度平衡，来判断其是否具有平衡的特性。

中序遍历

  1. void _InOrderTravel(Node* root) const
  2. {
  3.     if (root == nullptr)
  4.         return;
  6.     _InOrderTravel(root->_left);
  8.     std::cout << root->_kv.first << ':'  << root->_kv.second << std::endl;
  10.     _InOrderTravel(root->_right);
  11. }
  13. void InOrderTravel() const
  14. {
  15.     _InOrderTravel(_root);
  16. }
  17. int main()
  18. {
  19. 	int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16,14};
  20. 	//int arr{ 16, 3, 7, 11, 9, 26, 18, 14, 15 };
  21. 	AVLTree<int, int> t;
  22. 	for (auto  e : arr)
  23. 	{
  24. 		t.insert(make_pair(e,e));
  25. 	}
  26. 	
  27. 	t.InOrderTravel();
  28. 	return 0;
  29. }

到这里验证通过只能说明是搜索树没有问题。我们还要验证树是否平衡。

1.先计算出左右子树的高度
2.再检测每课子树的平衡因子

  1. int countHeight(Node* root) const
  2. {
  3.     if (root == nullptr)
  4.         return 0;
  6.     int leftHeight = countHeight(root->_left);
  7.     int rightHeight = countHeight(root->_right);
  9.     return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
  10. }
  12. bool _IsBalance(Node* root) const
  13. {
  14.     if (root == nullptr)
  15.         return true;
  17.     int leftHeight = countHeight(root->_left);
  18.     int rightHeight = countHeight(root->_right);
  20.     return abs(leftHeight - rightHeight) < 2
  21.         && _IsBalance(root->_left)
  22.         && _IsBalance(root->_right);
  23. }
  25. bool IsBalance() const
  26. {
  27.     return _IsBalance(_root);
  28. }

这里再推荐一道题，可以顺便去AC了：验证平衡二叉树

🎄AVL树的修改

修改可以直接调用insert，最后直接返回pair对象。

  1. pair<Node*, bool> Insert(const pair<K, V>& kv)
  2. {
  3.     if (_root == nullptr)
  4.     {
  5.         _root = new Node(kv);
  6.         return make_pair(_root, true);
  7.     }
  9.     // 找到存储位置，把数据插入进去
  10.     Node* parent = _root, * cur = _root;
  11.     while (cur)
  12.     {
  13.         if (cur->_kv.first > kv.first)
  14.         {
  15.             parent = cur;
  16.             cur = cur->_left;
  17.         }
  18.         else if (cur->_kv.first < kv.first)
  19.         {
  20.             parent = cur;
  21.             cur = cur->_right;
  22.         }
  23.         else
  24.         {
  25.             return make_pair(cur, true);
  26.         }
  27.     }
  29.     cur = new Node(kv);
  30.     Node* newnode = cur;
  31.     if (parent->_kv.first < kv.first)
  32.     {
  33.         parent->_right = cur;
  34.         cur->_parent = parent;
  35.     }
  36.     else
  37.     {
  38.         parent->_left = cur;
  39.         cur->_parent = parent;
  40.     }
  42.     // 控制平衡
  43.     // 1、更新平衡因子
  44.     // 2、如果出现不平衡，则需要旋转
  45.     //while (parent)
  46.     while (cur != _root)
  47.     {
  48.         if (parent->_left == cur)
  49.         {
  50.             parent->_bf--;
  51.         }
  52.         else
  53.         {
  54.             parent->_bf++;
  55.         }
  57.         if (parent->_bf == 0)
  58.         {
  59.             break;
  60.         }
  61.         else if (parent->_bf == 1 || parent->_bf == -1)
  62.         {
  63.             // parent所在的子树高度变了，会影响parent->parent
  64.             // 继续往上更新
  65.             cur = parent;
  66.             parent = parent->_parent;
  67.         }
  68.         else if (parent->_bf == 2 || parent->_bf == -2)
  69.         {
  70.             //parent所在子树已经不平衡，需要旋转处理一下
  71.             if (parent->_bf == -2)
  72.             {
  73.                 if (cur->_bf == -1)
  74.                 {
  75.                     // 右单旋
  76.                     RotateR(parent);
  77.                 }
  78.                 else // cur->_bf == 1
  79.                 {
  80.                     RotateLR(parent);
  81.                 }
  82.             }
  83.             else // parent->_bf  == 2
  84.             {
  85.                 if (cur->_bf == 1)
  86.                 {
  87.                     // 左单旋
  88.                     RotateL(parent);
  89.                 }
  90.                 else // cur->_bf == -1
  91.                 {
  92.                     RotateRL(parent);
  93.                 }
  94.             }
  96.             break;
  97.         }
  98.         else
  99.         {
  100.             // 插入节点之前，树已经不平衡了，需要检查
  101.             assert(false);
  102.         }
  103.     }
  105.     return make_pair(newnode, true);
  106. }

⏰AVL树的性能

  • 分析：
  1. AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度logN
  2. 但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置
  • 总结：
    如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但如果需要一个结构经常修改，就不太适合。

CSDN 社区图书馆，开张营业！

深读计划，写书评领图书福利~

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_48953972/article/details/125521900

内容来源于网络，如有侵权，请联系作者删除！

数据结构c++算法数据结构初阶

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com