devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【数据结构】AVL树（万字超详细 附动图）

作者：weixin_40725706 | 2024-04-28 22:54:03

赞

踩

【数据结构】AVL树（万字超详细 附动图）

一、前言

二、AVL树的性质

三、AVL树节点的定义

四、AVL树的插入

五、AVL树的平衡调整

六、AVL树的验证

6.1 验证有序

6.2 验证平衡

七、AVL树的删除

八、AVL树的性能和代码

一、前言

还没有学习过二叉搜索树的同学可以移步

【数据结构】二叉搜索树-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/Eristic0618/article/details/137919573?spm=1001.2014.3001.5501AVL树，又称为平衡二叉树，它基于二叉搜索树并通过平衡而得到。

在前面的学习中我们提到，二叉搜索树可以提高搜索数据的效率，但在数据有序的情况下会退化为单支树，此时在树中查找元素就得遍历一整个分支，时间复杂度也会退化至O(N)。

如果有一种算法，可以使二叉搜索树时刻保持左右子树的平衡，就可以避免这种最坏情况。

因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了AVL树，解决了上述问题。

二、AVL树的性质

当我们向二叉搜索树中插入新节点时，如果能用某种方法时刻保证树中每个节点的左右子树高度之差不超过1，就可以降低整棵树的高度，保证每条分支的平衡

AVL树的性质如下：

  • AVL树可以是空树
  • 一颗AVL树的左右子树都是AVL树
  • 一颗AVL树的左右子树高度差不超过1

例如：

三、AVL树节点的定义

AVL树的左右子树高度差不能超过1，但是如何便捷的去检测该性质是否被打破呢？

我们可以在节点中定义一个平衡因子，如果左子树比右子树高一层，那么平衡因子就为-1；如果左右子树一样高，平衡因子就为0；如果右子树比左子树高一层，那么平衡因子就为1，这三种情况下AVL树的性质都没有被打破。

按照这个规则，如果平衡因子为-2、2或其他值，则说明左右子树已经失衡，性质被打破。

在调整失衡的AVL树时，我们需要频繁的访问父节点，所以在AVL树中我们需要使用三叉链，因此AVL树的节点除了包含左右子节点的指针，还需要一个指向父节点的指针

另外需要说明一下，本文中，我们使用key/value模型的AVL树

AVL树节点的定义如下：

  1. template<class K,class V>
  2. struct AVLTreeNode
  3. {
  4. 	AVLTreeNode<K, V>* _left;
  5. 	AVLTreeNode<K, V>* _right;
  6. 	AVLTreeNode<K, V>* _parent;
  7. 	
  8. 	pair<K, V> _kv; //第一个数据存储key，第二个数据存储value
  9. 	int _bf; //平衡因子(balance factor)
  10.  
  11. 	AVLTreeNode(const pair<const K, V>& kv)
  12. 		:_left(nullptr)
  13. 		,_right(nullptr)
  14. 		,_parent(nullptr)
  15. 		,_kv(kv)
  16. 		,_bf(0) //新节点左右都为空，平衡因子为0
  17. 	{}
  18. };

可能有些同学对pair没有了解，这里简单介绍一下

pair可以将两个数据组成一组元素，因此对于key/value模型这种需要用到两个数据为一组的元素时就可以使用，内部的成员变量为first和second，其主要使用方法为：

  1. pair<T1, T2> p1(v1, v2); //输入两个数据创建pair类型变量
  2. make_pair(v1, v2);       //输入两个数据通过函数创建pair类型变量
  3. p1.first                 //访问p1的第一个数据
  4. p1.second                //访问p1的第二个数据

四、AVL树的插入

向AVL树中插入节点与向二叉搜索树中插入节点的过程基本相同，唯一的区别就是AVL树在插入节点后可能存在失衡的情况，需要调整。

我们先按照二叉搜索树的规则将节点插入到AVL树中，并判断插入的节点在父节点的左边还是右边

按照平衡因子的规则，如果新节点插入到了父节点的左侧，那么父节点的平衡因子-1

如果新节点插入到了父节点的右侧，那么父节点的平衡因子+1

以上，便是新增节点的父节点平衡因子可能的变化情况。

但是！插入一个节点不但会影响父节点，还可能会影响到祖先节点。

我们观察上面的四种可能，其中左边的两种情况下，插入节点后以父节点为根的子树高度发生了变化；在右边的两种情况下，插入节点后以父节点为根的子树高度没有发生变化。

观察过后可以发现，当父节点的平衡因子从0变为1/-1后，子树高度发生变化；当父节点的平衡因子从1/-1变为0后，子树高度不发生变化 

如果以父节点为根的子树高度没有发生变化，那么就不会影响到祖先节点的平衡因子；如果高度变了就会继续向上影响到祖先节点的平衡因子

因此，我们可以通过判断节点的插入位置来计算父节点的平衡因子，进而判断子树高度是否发生变化，再进一步计算对祖先节点平衡因子的影响，来判断AVL树是否失衡。

至此，我们已经可以开始写插入新节点和更新平衡因子的代码了：

  1. template<class K, class V>
  2. class AVLTree
  3. {
  4. 	typedef AVLTreeNode<K, V> Node;
  5. public:
  6. 	bool insert(const pair<const K, V>& kv)
  7. 	{
  8. 		if (_root == nullptr) //检测为空树的情况
  9. 		{
  10. 			_root = new Node(kv);
  11. 			return true;
  12. 		}
  13.  
  14. 		Node* parent = nullptr;
  15. 		Node* cur = _root;
  16.  
  17. 		while (cur) //搜索新节点的插入位置
  18. 		{
  19. 			parent = cur;
  20. 			if (kv.first > cur->_kv.first)
  21. 				cur = cur->_right;
  22. 			else if (kv.first < cur->_kv.first)
  23. 				cur = cur->_left;
  24. 			else
  25. 				return false;
  26. 		}
  27.  
  28. 		cur = new Node(kv);
  29.         //将父节点与新节点链接
  30.         //比较新节点和父节点的key判断插入到左边还是右边
  31. 		if (kv.first > parent->_kv.first) //这里防止有人看不懂再强调一遍，kv是pair类型的对象，kv.first是key，kv.second是value
  32. 		{
  33. 			parent->_right = cur;
  34. 			cur->_parent = parent;
  35. 		}
  36. 		else
  37. 		{
  38. 			parent->_left = cur;
  39. 			cur->_parent = parent;
  40. 		}
  41.  
  42. 		while (cur != _root)
  43. 		{
  44.             //插入节点后除了对父节点造成影响还可能对祖宗节点造成影响
  45.             //因此随着循环进行，这里的cur不一定为新节点，可以理解为高度发生变化的子树的根节点
  46.             //更新父节点的平衡因子
  47. 			if (cur == parent->_left)
  48. 				parent->_bf--;
  49. 			else
  50. 				parent->_bf++;
  51.  
  52.             //更新后检测父节点的平衡因子
  53. 			if (parent->_bf == 0) //平衡因子为0说明没有打破性质，跳出循环
  54. 				break;
  55. 			else if (parent->_bf == 1 || parent->_bf == -1) //更新后平衡因子为1或-1说明高度发生变化，改变cur和parent的指向后继续向上更新
  56. 			{
  57. 				cur = parent;
  58. 				parent = parent->_parent;
  59. 			}
  60. 			else if (parent->_bf == 2 || parent->_bf == -2) //更新后平衡因子为2或-2.说明已经失衡，需要调整
  61. 			{
  62.                 //不同情况的调整方法...
  63. 				if (parent->_bf == 2)
  64. 				{
  65. 					if (cur->_bf == 1)
  66. 					{
  67. 						//...
  68. 					}
  69. 					else if (cur->_bf == -1)
  70. 					{
  71. 						//...
  72. 					}
  73. 				}
  74. 				else
  75. 				{
  76. 					if (cur->_bf == 1)
  77. 					{
  78. 						//...
  79. 					}
  80. 					else if (cur->_bf == -1)
  81. 					{
  82. 						//...
  83. 					}
  84. 				}
  85. 				break;
  86. 			}
  87. 			else //平衡因子出现意外情况，报错
  88. 			{
  89. 				assert(false);
  90. 			}
  91. 		}
  92.  
  93. 		return true;
  94. 	}
  95.  
  96. private:
  97. 	Node* _root = nullptr;
  98. };

五、AVL树的平衡调整（附动图）

如果在一颗原本平衡的AVL树中插入一个新节点，可能会造成失衡，此时需要调整树的结构使之重新平衡，这种调整方法称为旋转。

根据树的原本结构和节点插入位置的不同分为四种情况和四种旋转方式：

（1）新节点插入较高左子树的左侧：右单旋

自己做的动图大家有需要自取~这里就不加水印了

问题来了：如何判断插入的新节点的方位呢？

很简单，以上面的情况为例，插入新节点后60的平衡因子变成-2，说明左子树更高，而30的平衡因子变成-1，说明新节点插入到了30的左子树。后面左单旋以及双旋中都同理，我们使用平衡因子就可以判断新节点插入的位置

右单旋代码如下：

  1. void RotateRight(Node *parent) //parent为平衡因子发生失衡的节点
  2. {
  3.     Node *subL = parent->_left; //subL为parent的左子节点
  4.     Node *subLR = subL->_right; //subLR为subL的右子节点
  5.     //parent，subL和subLR三个节点是旋转中唯三需要进行操作的三个节点
  6.  
  7.     // 将parent与subLR节点进行链接
  8.     parent->_left = subLR;
  9.     if (subLR) //subLR可能为空
  10.         subLR->_parent = parent;
  11.  
  12.     Node *parentParent = parent->_parent; //记录parent的父节点
  13.  
  14.     if (parent != _root)
  15.     {
  16.         subL->_parent = parentParent; //将subL与parent的父节点链接
  17.         if (parent == parentParent->_left)
  18.             parentParent->_left = subL;
  19.         else
  20.             parentParent->_right = subL;
  21.     }
  22.     else //如果parent为根，旋转后subL成为新的根
  23.     {
  24.         _root = subL;
  25.         subL->_parent = nullptr;
  26.     }
  27.  
  28.     //将subL与parent链接
  29.     subL->_right = parent;
  30.     parent->_parent = subL;
  31.  
  32.     parent->_bf = subL->_bf = 0; //更新平衡因子
  33. }

（2）新节点插入较高右子树的右侧：左单旋

因为左单旋的原理和右单旋是类似的，只要理解了右单旋，加上动图的配合，左单旋和后面的双旋都是很好理解的 

左单旋代码如下：

  1. void RotateLeft(Node *parent)
  2. {
  3.     Node *subR = parent->_right;
  4.     Node *subRL = subR->_left;
  5.  
  6.     parent->_right = subRL;
  7.     if (subRL)
  8.         subRL->_parent = parent;
  9.  
  10.     Node *parentParent = parent->_parent;
  11.  
  12.     if (parent != _root)
  13.     {
  14.         subR->_parent = parentParent;
  15.         if (parent == parentParent->_left)
  16.             parentParent->_left = subR;
  17.         else
  18.             parentParent->_right = subR;
  19.     }
  20.     else
  21.     {
  22.         _root = subR;
  23.         subR->_parent = nullptr;
  24.     }
  25.  
  26.     subR->_left = parent;
  27.     parent->_parent = subR;
  28.  
  29.     parent->_bf = subR->_bf = 0;
  30. }

（3）新节点插入较高左子树的右侧：先左单旋再右单旋（左右双旋） 

这种情况又可以分为两种情况：

不过这两种情况都属于在较高左子树的右侧插入，处理方式都是相同的，唯一的区别在于最后旋转完成后，更新平衡因子时的值不同。

接下来我们以上面的那个情况为例展示左右双旋的过程：

而下面的情况和上面的情况唯一的区别在于，最后更新的平衡因子不同

如何去决定每个节点更新后的平衡因子呢？可以看到这两种情况中，如果在b下面插入新节点，那么旋转过后30和60的平衡因子更新成0，90的平衡因子更新成1；如果在c下面插入新节点，则是60和90的平衡因子更新成0，30的平衡因子更新成-1

而新节点究竟插入到了b下面还是在c下面，我们可以通过插入节点后60的平衡因子来判断

左右双旋代码如下：

  1. void RotateLR(Node *parent)
  2. {
  3.     Node *subL = parent->_left;
  4.     Node *subLR = subL->_right;
  5.     int bf = subLR->_bf; //记录插入节点后subLR的平衡因子
  6.  
  7.     RotateLeft(subL); //先左单旋
  8.     RotateRight(parent); //再右单旋
  9.  
  10.     //更新平衡因子
  11.     //通过前面记录的平衡因子判断更新的情况
  12.     if (bf == 0)
  13.     {
  14.         parent->_bf = subL->_bf = subLR->_bf = 0;
  15.     }
  16.     else if (bf == 1)
  17.     {
  18.         subL->_bf = -1;
  19.         parent->_bf = subLR->_bf = 0;
  20.     }
  21.     else if (bf == -1)
  22.     {
  23.         parent->_bf = 1;
  24.         subL->_bf = subLR->_bf = 0;
  25.     }
  26.     else
  27.     {
  28.         assert(false);
  29.     }
  30. }

（4）新节点插入较高右子树的左侧：先右单旋再左单旋（右左双旋）

这种情况和左右双旋的情况原理一样，我们直接上动图和代码

右左双旋的代码如下：

  1. void RotateRL(Node *parent)
  2. {
  3.     Node *subR = parent->_right;
  4.     Node *subRL = subR->_left;
  5.     int bf = subRL->_bf;
  6.  
  7.     RotateRight(subR);
  8.     RotateLeft(parent);
  9.  
  10.     if (bf == 0)
  11.     {
  12.         parent->_bf = subR->_bf = subRL->_bf = 0;
  13.     }
  14.     else if (bf == 1)
  15.     {
  16.         parent->_bf = -1;
  17.         subR->_bf = subRL->_bf = 0;
  18.     }
  19.     else if (bf == -1)
  20.     {
  21.         subR->_bf = 1;
  22.         parent->_bf = subRL->_bf = 0;
  23.     }
  24.     else
  25.     {
  26.         assert(false);
  27.     }
  28. }

现在四个旋转的函数都实现了，完整的插入函数代码如下：

  1. bool insert(const pair<const K, V> &kv)
  2. {
  3.     if (_root == nullptr)
  4.     {
  5.         _root = new Node(kv);
  6.         return true;
  7.     }
  8.  
  9.     Node *parent = nullptr;
  10.     Node *cur = _root;
  11.  
  12.     while (cur)
  13.     {
  14.         parent = cur;
  15.         if (kv.first > cur->_kv.first)
  16.             cur = cur->_right;
  17.         else if (kv.first < cur->_kv.first)
  18.             cur = cur->_left;
  19.         else
  20.             return false;
  21.     }
  22.  
  23.     cur = new Node(kv);
  24.     if (kv.first > parent->_kv.first)
  25.     {
  26.         parent->_right = cur;
  27.         cur->_parent = parent;
  28.     }
  29.     else
  30.     {
  31.         parent->_left = cur;
  32.         cur->_parent = parent;
  33.     }
  34.  
  35.     while (cur != _root)
  36.     {
  37.         if (cur == parent->_left)
  38.             parent->_bf--;
  39.         else
  40.             parent->_bf++;
  41.  
  42.         if (parent->_bf == 0)
  43.             break;
  44.         else if (parent->_bf == 1 || parent->_bf == -1)
  45.         {
  46.             cur = parent;
  47.             parent = parent->_parent;
  48.         }
  49.         else if (parent->_bf == 2 || parent->_bf == -2)
  50.         {
  51.             if (parent->_bf == 2) //说明右子树更高
  52.             {
  53.                 if (cur->_bf == 1) //说明新节点插入到了右边，符合在更高右子树的右侧插入的情况
  54.                 {
  55.                     RotateLeft(parent); //执行左单旋
  56.                 }
  57.                 else if (cur->_bf == -1) //说明新节点插入到了左边，符合在更高右子树的左侧插入的情况
  58.                 {
  59.                     RotateRL(parent); //执行右左双旋
  60.                 }
  61.             }
  62.             else //左子树更高
  63.             {
  64.                 if (cur->_bf == 1) //说明新节点插入到了右边，符合在更高左子树的右侧插入的情况
  65.                 {
  66.                     RotateLR(parent); //执行左右双旋
  67.                 }
  68.                 else if (cur->_bf == -1) //说明新节点插入到了左边，符合在更高左子树的左侧插入的情况
  69.                 {
  70.                     RotateRight(parent); //执行右单旋
  71.                 }
  72.             }
  73.             break;
  74.         }
  75.         else
  76.         {
  77.             assert(false);
  78.         }
  79.     }
  80.  
  81.     return true;
  82. }

六、AVL树的验证

6.1 验证有序

最重要的插入节点部分完成了，不过在验证是否符合AVL树性质前，我们首先需要验证其是否是一棵二叉搜索树

在之前讲解二叉搜索树中提到过，如果中序遍历能够得到一个有序的序列，就说明是二叉搜索树

中序遍历代码如下：

  1. void InOrder()
  2. {
  3.     _InOrder(_root);
  4.     cout << endl;
  5. }
  6.  
  7. void _InOrder(Node *root)
  8. {
  9.     if (root == nullptr)
  10.         return;
  11.     _InOrder(root->_left);
  12.     cout << root->_kv.first << " "; // key/value模型，我们只打印key即可
  13.     _InOrder(root->_right);
  14. }

验证：

说明符合二叉搜索树性质

6.2 验证平衡

要验证是否符合AVL树性质，只需要检测它的所有节点的子树高度差不超过1即可

需要注意的是，这里不可以直接通过判断平衡因子的绝对值是否大于1来验证平衡，因为平衡因子是不客观的，可以被修改

因此，我们通过递归来得到每棵子树的高度并进行判断即可

代码如下：

  1. bool IsBalance()
  2. {
  3.     return _IsBalance(_root);
  4. }
  5.  
  6. bool _IsBalance(Node *root)
  7. {
  8.     if (root == nullptr)
  9.         return true;
  10.     int leftHeigit = _Height(root->_left);
  11.     int rightHeight = _Height(root->_right);
  12.     if (rightHeight - leftHeigit != root->_bf)
  13.     {
  14.         cout << root->_kv.first << "平衡因子异常" << endl;
  15.         return false;
  16.     }
  17.  
  18.     return abs(rightHeight - leftHeigit) <= 1 
  19.         && _IsBalance(root->_left) 
  20.         && _IsBalance(root->_right);
  21. }
  22.  
  23. int Height()
  24. {
  25.     return _Height(_root);
  26. }
  27.  
  28. int _Height(Node *root)
  29. {
  30.     if (root == nullptr)
  31.         return 0;
  32.     int higher = max(_Height(root->_left), _Height(root->_right));
  33.     return higher + 1;
  34. }

验证：

如果在验证是否是AVL树中需要更多大量的测试用例，我们可以取一些随机数：

  1. int main()
  2. {
  3. 	const int N = 1000;
  4. 	vector<int> v;
  5. 	v.reserve(N);
  6. 	srand(time(0));
  7.  
  8. 	for (int i = 0; i < N; i++)
  9. 	{
  10. 		v.push_back(rand() + i);
  11. 	}
  12.  
  13. 	AVLTree<int, int> t;
  14. 	for (auto i : v)
  15. 	{
  16. 		t.insert(make_pair(i, 1));
  17. 	}
  18. 	t.InOrder();
  19. 	if (t.IsBalance())
  20. 		cout << "是AVL树" << endl;
  21. 	else
  22. 		cout << "不是AVL树" << endl;
  23. 	return 0;
  24. }

 

七、AVL树的删除

AVL树的删除并不是本文的重点，因为其原理我们在前面已经学习过了

我们只需要按照二叉搜索树的方式来对目标节点进行删除，再判断是否失衡，如果失衡则旋转即可

八、AVL树的性能和代码

AVL树追求的是严格平衡，因此可以保证查找时高效的时间复杂度O(logN)，但是如果我们需要频繁的对其进行旋转来维护平衡，一定程度上会影响效率，尤其是删除节点时的最差情况下我们可能需要一路旋转到根的位置。

相对于AVL树的严格平衡，红黑树则追求一种相对平衡，因此会略胜一筹，后面的文章中会对红黑树进行讲解。

AVL树的完整代码如下：

  1. template<class K,class V>
  2. struct AVLTreeNode
  3. {
  4. 	AVLTreeNode<K, V>* _left;
  5. 	AVLTreeNode<K, V>* _right;
  6. 	AVLTreeNode<K, V>* _parent;
  7. 	
  8. 	pair<K, V> _kv;
  9. 	int _bf; //平衡因子
  10.  
  11. 	AVLTreeNode(const pair<const K, V>& kv)
  12. 		:_left(nullptr)
  13. 		,_right(nullptr)
  14. 		,_parent(nullptr)
  15. 		,_kv(kv)
  16. 		,_bf(0)
  17. 	{}
  18. };
  19.  
  20. template<class K, class V>
  21. class AVLTree
  22. {
  23. 	typedef AVLTreeNode<K, V> Node;
  24. public:
  25. 	bool insert(const pair<const K, V>& kv)
  26. 	{
  27. 		if (_root == nullptr)
  28. 		{
  29. 			_root = new Node(kv);
  30. 			return true;
  31. 		}
  32.  
  33. 		Node* parent = nullptr;
  34. 		Node* cur = _root;
  35.  
  36. 		while (cur)
  37. 		{
  38. 			parent = cur;
  39. 			if (kv.first > cur->_kv.first)
  40. 				cur = cur->_right;
  41. 			else if (kv.first < cur->_kv.first)
  42. 				cur = cur->_left;
  43. 			else
  44. 				return false;
  45. 		}
  46.  
  47. 		cur = new Node(kv);
  48. 		if (kv.first > parent->_kv.first)
  49. 		{
  50. 			parent->_right = cur;
  51. 			cur->_parent = parent;
  52. 		}
  53. 		else
  54. 		{
  55. 			parent->_left = cur;
  56. 			cur->_parent = parent;
  57. 		}
  58.  
  59. 		while (cur != _root)
  60. 		{
  61. 			if (cur == parent->_left)
  62. 				parent->_bf--;
  63. 			else
  64. 				parent->_bf++;
  65.  
  66. 			if (parent->_bf == 0)
  67. 				break;
  68. 			else if (parent->_bf == 1 || parent->_bf == -1)
  69. 			{
  70. 				cur = parent;
  71. 				parent = parent->_parent;
  72. 			}
  73. 			else if (parent->_bf == 2 || parent->_bf == -2)//平衡异常
  74. 			{
  75. 				if (parent->_bf == 2)
  76. 				{
  77. 					if (cur->_bf == 1)
  78. 					{
  79. 						RotateLeft(parent);
  80. 					}
  81. 					else if (cur->_bf == -1)
  82. 					{
  83. 						RotateRL(parent);
  84. 					}
  85. 				}
  86. 				else
  87. 				{
  88. 					if (cur->_bf == 1)
  89. 					{
  90. 						RotateLR(parent);
  91. 					}
  92. 					else if (cur->_bf == -1)
  93. 					{
  94. 						RotateRight(parent);
  95. 					}
  96. 				}
  97. 				break;
  98. 			}
  99. 			else
  100. 			{
  101. 				assert(false);
  102. 			}
  103. 		}
  104.  
  105. 		return true;
  106. 	}
  107.  
  108. 	void RotateLeft(Node* parent) //新节点插入较高右子树的右侧：左单旋
  109. 	{
  110. 		Node* subR = parent->_right;
  111. 		Node* subRL = subR->_left;
  112.  
  113. 		parent->_right = subRL;
  114. 		if(subRL)
  115. 			subRL->_parent = parent;
  116.  
  117. 		Node* parentParent = parent->_parent;
  118.  
  119. 		if (parent != _root)
  120. 		{
  121. 			subR->_parent = parentParent;
  122. 			if (parent == parentParent->_left)
  123. 				parentParent->_left = subR;
  124. 			else
  125. 				parentParent->_right = subR;
  126. 		}
  127. 		else
  128. 		{
  129. 			_root = subR;
  130. 			subR->_parent = nullptr;
  131. 		}
  132.  
  133. 		subR->_left = parent;
  134. 		parent->_parent = subR;
  135.  
  136. 		parent->_bf = subR->_bf = 0;
  137. 	}
  138.  
  139. 	void RotateRight(Node* parent) //新节点插入较高左子树的左侧：右单旋
  140. 	{
  141. 		Node* subL = parent->_left;
  142. 		Node* subLR = subL->_right;
  143.  
  144. 		parent->_left = subLR;
  145. 		if (subLR)
  146. 			subLR->_parent = parent;
  147.  
  148. 		Node* parentParent = parent->_parent;
  149.  
  150. 		if (parent != _root)
  151. 		{
  152. 			subL->_parent = parentParent;
  153. 			if (parent == parentParent->_left)
  154. 				parentParent->_left = subL;
  155. 			else
  156. 				parentParent->_right = subL;
  157. 		}
  158. 		else
  159. 		{
  160. 			_root = subL;
  161. 			subL->_parent = nullptr;
  162. 		}
  163.  
  164. 		subL->_right = parent;
  165. 		parent->_parent = subL;
  166.  
  167. 		parent->_bf = subL->_bf = 0;
  168. 	}
  169.  
  170. 	void RotateRL(Node* parent)
  171. 	{
  172. 		Node* subR = parent->_right;
  173. 		Node* subRL = subR->_left;
  174. 		int bf = subRL->_bf;
  175.  
  176. 		RotateRight(subR);
  177. 		RotateLeft(parent);
  178.  
  179. 		if (bf == 0)
  180. 		{
  181. 			parent->_bf = subR->_bf = subRL->_bf = 0;
  182. 		}
  183. 		else if (bf == 1)
  184. 		{
  185. 			parent->_bf = -1;
  186. 			subR->_bf = subRL->_bf = 0;
  187. 		}
  188. 		else if (bf == -1)
  189. 		{
  190. 			subR->_bf = 1;
  191. 			parent->_bf = subRL->_bf = 0;
  192. 		}
  193. 		else
  194. 		{
  195. 			assert(false);
  196. 		}
  197. 	}
  198.  
  199. 	void RotateLR(Node* parent)
  200. 	{
  201. 		Node* subL = parent->_left;
  202. 		Node* subLR = subL->_right;
  203. 		int bf = subLR->_bf;
  204.  
  205. 		RotateLeft(subL);
  206. 		RotateRight(parent);
  207.  
  208. 		if (bf == 0)
  209. 		{
  210. 			parent->_bf = subL->_bf = subLR->_bf = 0;
  211. 		}
  212. 		else if (bf == 1)
  213. 		{
  214. 			subL->_bf = -1;
  215. 			parent->_bf = subLR->_bf = 0;
  216. 		}
  217. 		else if (bf == -1)
  218. 		{
  219. 			parent->_bf = 1;
  220. 			subL->_bf = subLR->_bf = 0;
  221. 		}
  222. 		else
  223. 		{
  224. 			assert(false);
  225. 		}
  226. 	}
  227.  
  228. 	void InOrder()
  229. 	{
  230. 		_InOrder(_root);
  231. 		cout << endl;
  232. 	}
  233.  
  234. 	bool IsBalance()
  235. 	{
  236. 		return _IsBalance(_root);
  237. 	}
  238.  
  239. 	int Height()
  240. 	{
  241. 		return _Height(_root);
  242. 	}
  243.  
  244. 	size_t Size()
  245. 	{
  246. 		return _Size(_root);
  247. 	}
  248.  
  249. 	Node* Find(const K& key)
  250. 	{
  251. 		Node* cur = _root;
  252. 		while (cur)
  253. 		{
  254. 			if (key > cur->_kv.first)
  255. 				cur = cur->_right;
  256. 			else if (key < cur->_kv.first)
  257. 				cur = cur->_left;
  258. 			else
  259. 				return cur;
  260. 		}
  261. 		return nullptr;
  262. 	}
  263. private:
  264. 	void _InOrder(Node* root)
  265. 	{
  266. 		if (root == nullptr)
  267. 			return;
  268. 		_InOrder(root->_left);
  269. 		cout << root->_kv.first << " ";
  270. 		_InOrder(root->_right);
  271. 	}
  272.  
  273. 	bool _IsBalance(Node* root)
  274. 	{
  275. 		if (root == nullptr)
  276. 			return true;
  277. 		int leftHeigit = _Height(root->_left);
  278. 		int rightHeight = _Height(root->_right);
  279. 		if (rightHeight - leftHeigit != root->_bf)
  280. 		{
  281. 			cout << root->_kv.first << "平衡因子异常" << endl;
  282. 			return false;
  283. 		}
  284.  
  285. 		return abs(rightHeight - leftHeigit) <= 1 
  286. 			&& _IsBalance(root->_left)
  287. 			&& _IsBalance(root->_right);
  288. 	}
  289.  
  290. 	int _Height(Node* root)
  291. 	{
  292. 		if (root == nullptr)
  293. 			return 0;
  294. 		int higher = max(_Height(root->_left), _Height(root->_right));
  295. 		return higher + 1;
  296. 	}
  297.  
  298. 	size_t _Size(Node* root)
  299. 	{
  300. 		if (root == nullptr)
  301. 			return 0;
  302. 		return _Size(root->_left) + _Size(root->_right) + 1;
  303. 	}
  304. private:
  305. 	Node* _root = nullptr;
  306. };

如果有错误的地方，欢迎在评论区指出

完.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/504694
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号