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

【数据结构高阶】AVL树_avl树怎么构造

作者：一键难忘520 | 2024-08-17 08:12:34

赞

踩

avl树怎么构造

上期博客我们讲解了set/multiset/map/multimap的使用，下面我们来深入到底层，讲解其内部结构：

目录

一、AVL树的概念

二、AVL树的实现

2.1 节点的定义

2.2 数据的插入

2.2.1 平衡因子的调整

2.2.1.1 调整平衡因子的规律

2.2.2 子树的旋转调整

2.2.2.1 左单旋

2.2.2.2 右单旋

2.2.2.3 左右双旋

2.2.2.4 右左双旋

2.3 AVL树的检查验证

2.4 测试代码

三、AVL树实现的完整代码

一、AVL树的概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年，发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

● 它的左右子树都是AVL树

● 左右子树高度之差（简称平衡因子，不是每种AVL树都有平衡因子，平衡因子只是AVL树实现的一种方式）的绝对值不超过1（下图的平衡因子计算公式为：节点的右子树高度-左子树高度）

下图是一个AVL树：

二、AVL树的实现

2.1 节点的定义

这次我们直接实现K-V模型的二叉树：

  1. template<class Key,class Val>
  2. class AVLTreeNode
  3. {
  4. public:
  5. 	AVLTreeNode<Key, Val>* _left;
  6. 	AVLTreeNode<Key, Val>* _right;
  7. 	AVLTreeNode<Key, Val>* _parent;//多一个指针指向其父节点,方便我们的后续操作
  8. 	pair<Key, Val> _kv;
  9. 	int _bf;//balance factor(平衡因子)
  10.  
  11. 	AVLTreeNode(pair<Key, Val> kv)
  12. 		:_left(nullptr),
  13. 		_right(nullptr),
  14. 		_parent(nullptr),
  15. 		_kv(kv),
  16. 		_bf(0)
  17. 	{}
  18. };

2.2 数据的插入

AVL树的数据插入需要遵循二叉搜索树的规律：

  1. template<class Key, class Val>
  2. class AVLTree
  3. {
  4. public:
  5. 	typedef AVLTreeNode<Key, Val> Node;
  6.  
  7. 	bool Insert(const pair<Key,Val>& kv)
  8. 	{
  9. 		Node* cur = _root, * parent = nullptr;
  10. 		while (cur)//找到合适的位置
  11. 		{
  12. 			if (kv.first < cur->_kv.first)
  13. 			{
  14. 				parent = cur;
  15. 				cur = cur->_left;
  16. 			}
  17. 			else if (kv.first > cur->_kv.first)
  18. 			{
  19. 				parent = cur;
  20. 				cur = cur->_right;
  21. 			}
  22. 			else
  23. 			{
  24. 				cout << "插入的值重复" << endl;
  25. 				return false;
  26. 			}
  27. 		}
  28. 		cur = new Node(kv);
  29. 		cur->_parent = parent;
  30. 		//将插入的节点连接上二叉树
  31. 		if (parent == nullptr)
  32. 		{
  33. 			_root = cur;
  34. 		}
  35. 		else if (kv.first < parent->_kv.first)
  36. 		{
  37. 			parent->_left = cur;
  38. 		}
  39. 		else
  40. 		{
  41. 			parent->_right = cur;
  42. 		}
  43. 		return true;
  44. 	}
  45.  
  46. private:
  47. 	AVLTreeNode<Key, Val>* _root = nullptr;
  48. };

但是成功插入数据后就结束了吗？在AVL树中可没有这么简单，我们需要更新其插入节点的父节点的平衡因子，来保证这课树的整体结构还是一个AVL树。

2.2.1 平衡因子的调整

下面我们来讨论一下更新父节点平衡因子的操作：

我们看到上面的二叉树，现在向其中插入一个键值为8的数据：

插入后我们发现其插入节点的父节点平衡因子需要修改，那就要修改一下：

修改其父节点后，我们发现其父节点的父节点的平衡因子也需要调整，那再调整一下吧：

但是本次调整过后，平衡因子出现了2这个数值，但是平衡因子只能是1/0/-1，说明这时该节点下的子树已经不满足AVL树的结构了，这时要对其子树进行旋转来调整该树的结构（至于怎么旋转我们在下面会详细讲解），经过旋转过后子树肯定是满足AVL树的结构的，所以就并不再检查进行旋转的节点父节点平衡因子了：

那我们再看看另一种情况，我们向下面的二叉树中插入键值为6的数据：

插入后，我们发现需要修改其父节点的平衡因子： 

修改后，我们发现其父节点的平衡因子为0，为0时就意味着子树的高度没有发生变化，我们就没有必要再向上更新其父节点的平衡因子了： 

2.2.1.1 调整平衡因子的规律

所以总结一下上述规律，我们插入节点后肯定是要调整其父节点的平衡因子的，那调整父节点的平衡因子后，什么时候要向上调整其父节点的父节点（爷爷节点）的平衡因子呢？

这里有三种情况：

当父节点的平衡因子调整过后为1或-1时，此时说明其节点所在的子树的高度发生了变化（变为1或-1前，平衡因子只可能是0，说明插入之前子树两边的高度是相同的，这时在插入一个节点会导致其中一颗子树的高度发生变化），这时需要再继续向上调整其父节点的平衡因子

当父节点的平衡因子调整过后为2或-2时，该节点的子树不平衡，需要处理这颗旋转处理子树，旋转实质是是将该节点所在的子树的高度降1，所以旋转过后不影响子树的高度变化，此时就不需要再向上更新其父节点的平衡因子了

当父节点的平衡因子调整过后为0时（变为0前，平衡因子只可能是1或-1，说明插入之前一边高，一边低，但是插入节点是在矮的那边，其子树的高度不变），说明所在的子树高度不变，不用继续向上更新

我们用代码来实现一下平衡因子的调整：

  1. template<class Key, class Val>
  2. class AVLTree
  3. {
  4. public:
  5. 	typedef AVLTreeNode<Key, Val> Node;
  6.  
  7. 	bool Insert(const pair<Key,Val>& kv)
  8. 	{
  9. 		Node* cur = _root, * parent = nullptr;
  10. 		while (cur)//找到合适的位置
  11. 		{
  12. 			if (kv.first < cur->_kv.first)
  13. 			{
  14. 				parent = cur;
  15. 				cur = cur->_left;
  16. 			}
  17. 			else if (kv.first > cur->_kv.first)
  18. 			{
  19. 				parent = cur;
  20. 				cur = cur->_right;
  21. 			}
  22. 			else
  23. 			{
  24. 				cout << "插入的值重复" << endl;
  25. 				return false;
  26. 			}
  27. 		}
  28. 		cur = new Node(kv);
  29. 		cur->_parent = parent;
  30. 		//将插入的节点连接上二叉树
  31. 		if (parent == nullptr)
  32. 		{
  33. 			_root = cur;
  34. 		}
  35. 		else if (kv.first < parent->_kv.first)
  36. 		{
  37. 			parent->_left = cur;
  38. 		}
  39. 		else
  40. 		{
  41. 			parent->_right = cur;
  42. 		}
  43. 		//向上调整各节点的平衡因子
  44. 		while (parent)
  45. 		{
  46. 			if (parent->_left == cur)
  47. 			{
  48. 				--parent->_bf;//更新平衡因子
  49. 			}
  50. 			else
  51. 			{
  52. 				++parent->_bf;//更新平衡因子
  53. 			}
  54. 			//根据父节点的平衡因子的情况决定师傅继续向上调整各节点的平衡因子
  55. 			if (parent->_bf == 1 || parent->_bf == -1)//平衡因子为1或1继续向上更新
  56. 			{
  57. 				parent = parent->_parent;
  58. 				cur = cur->_parent;
  59. 			}
  60. 			else if (parent->_bf == 2 || parent->_bf == -2)//平衡因子为2或-2,树的结构不平衡，旋转parent节点所在子树
  61. 			{
  62. 				//旋转parent所在的子树
  63. 			}
  64. 			else if (parent->_bf == 0)//平衡因子为0,插入结束
  65. 			{
  66. 				break;
  67. 			}
  68. 			else//出现其他的情况说明树的根据有问题，报错退出
  69. 			{
  70. 				cout << "树的结构出错了" << endl;
  71. 				assert(0);
  72. 				exit(-1);
  73. 			}
  74. 		}
  75. 		return true;
  76. 	}
  77.  
  78. private:
  79. 	AVLTreeNode<Key, Val>* _root = nullptr;
  80. };

2.2.2 子树的旋转调整

当某个节点的平衡因子变为2或-2时，我们需要对其所在的子树进行旋转调整

下面我们分情况来讨论：

2.2.2.1 左单旋

下面的图代表的是一棵AVL树，其中52和60表示的两个节点，A、B、C分别为高度为h的AVL子树：

下面向C子树中插入数据使其高度发生变化：

现在键值为52的节点平衡因子变为2，下面我们要将这棵子树旋转：

我们可以看到旋转的过程是这样的：

B子树变成52的右子树->52变成60的左子树->60变成整颗树的根

上面这种需要旋转的树的根节点平衡因子为2，并且其根节点右孩子节点的平衡因子为1；这种情况下的旋转我们将其称为左单旋

下面我们就用代码实现一下左单旋：

  1. void RotateL(Node* parent)//左单旋
  2. {
  3. 	Node* subR = parent->_right;
  4. 	Node* subRL = subR->_left;
  5. 	Node* pparent = parent->_parent;
  6. 	parent->_right = subRL;//更新parent的右节点
  7. 	if (subRL)//防止该节点为空
  8. 	{
  9. 		subRL->_parent = parent;//更新subRL的父节点
  10. 	}
  11. 	parent->_parent = subR;//更新parent的父节点
  12. 	subR->_left = parent;//subR的左子树置为parent
  13. 	subR->_parent = pparent;//更新subR的父节点
  14. 	if (pparent == nullptr)//旋转的是整棵树
  15. 	{
  16. 		_root = subR;//更新根节点
  17. 	}
  18. 	else//将旋转后的子树链接上整个二叉树
  19. 	{
  20. 		if (pparent->_left == parent)
  21. 		{
  22. 			pparent->_left = subR;
  23. 		}
  24. 		else
  25. 		{
  26. 			pparent->_right = subR;
  27. 		}
  28. 	}
  29. 	subR->_bf = parent->_bf = 0;//更新平衡因子
  30. }

下图是画出了代码所表示的节点： 

2.2.2.2 右单旋

再来看到另一种情况：

 下面向子树A中插入数据使其高度发生变化：

现在键值为60的节点平衡因子变为-2，下面我们要将这棵子树旋转： 

我们可以看到旋转的过程是这样的：

B子树变成60的左子树->60变成52的右子树->52变成整颗树的根

上面这种需要旋转的树的根节点平衡因子为-2，并且其根节点左孩子节点的平衡因子为-1；这种情况下的旋转我们将其称为右单旋

下面我们用代码实现一下右单旋：

  1. void RotateR(Node* parent)//右单旋
  2. {
  3. 	Node* subL = parent->_left;
  4. 	Node* subLR = subL->_right;
  5. 	Node* pparent = parent->_parent;
  6. 	parent->_left = subLR;//更新parent的左节点
  7. 	if (subLR)//防止该节点为空
  8. 	{
  9. 		subLR->_parent = parent;//更新subLR的父节点
  10. 	}
  11. 	parent->_parent = subL;//更新parent的父节点
  12. 	subL->_right = parent;//subL的右子树置为parent
  13. 	subL->_parent = pparent;//更新subL的父节点
  14. 	if (pparent == nullptr)//旋转的是整棵树
  15. 	{
  16. 		_root = subL;//更新根节点
  17. 	}
  18. 	else//将旋转后的子树链接上整个二叉树
  19. 	{
  20. 		if (pparent->_left == parent)
  21. 		{
  22. 			pparent->_left = subL;
  23. 		}
  24. 		else
  25. 		{
  26. 			pparent->_right = subL;
  27. 		}
  28. 	}
  29. 	subL->_bf = parent->_bf = 0;//更新平衡因子
  30. }

下图画出了代码所表示的节点： 

2.2.2.3 左右双旋

接着来看到稍微复杂一点的情况，下面的图代表的是一棵AVL树，其中99、66和88表示的是三个节点，A、D分别为高度为h的AVL子树，B、C分别为高度为h-1的AVL子树：

现在我们向B子树中插入数据使其高度发生变化：

现在键值为99的节点平衡因子变为-2，下面我们要将这棵子树旋转： 

下面先将66所在子树进行左单旋：

再让99所在子树右单旋：

上面这种需要旋转的树的根节点平衡因子为-2，并且其根节点左孩子节点的平衡因子为1；这种情况下的两次旋转我们将其称为左右双旋

但是我们要注意的是，当新增节点在C子树上时，通过左右双旋调整后的结果又不一样：

 

我们可以看到因为新增节点的位置发生了变化，最终导致了各节点的平衡因子出现了差异

除了这两种情况，还有一种当h为0的极端情况：

所以我们在用代码实现的时要注意

  1. void RotateLR(Node* parent)//左右双旋
  2. {
  3. 	Node* subL = parent->_left;
  4. 	Node* subLR = subL->_right;
  5. 	int subLR_bf = subLR->_bf;//记录该节点的平衡因子来做旋转结束后的修改平衡因子的依据
  6. 	RotateL(subL);//调用左单旋
  7. 	RotateR(parent);//调用右单旋
  8. 	if (subLR_bf == -1)
  9. 	{
  10. 		parent->_bf = 1;
  11. 		subL->_bf = 0;
  12. 		subLR->_bf = 0;
  13. 	}
  14. 	else if (subLR_bf == 0)
  15. 	{
  16. 		parent->_bf = 0;
  17. 		subL->_bf = 0;
  18. 		subLR->_bf = 0;
  19. 	}
  20. 	else if (subLR_bf == 1)
  21. 	{
  22. 		parent->_bf = 0;
  23. 		subL->_bf = -1;
  24. 		subLR->_bf = 0;
  25. 	}
  26. 	else
  27. 	{
  28. 		assert(false);
  29. 	}
  30. }

2.2.2.4 右左双旋

最后我们只剩一种情况了：需要旋转的树的根节点平衡因子为-2，并且其根节点右孩子节点的平衡因子为-1

下面我们来分析：

我们向上面这棵树中的C子树插入数据使其高度发生变化：

现在键值为66的节点平衡因子变为2，下面我们要将这棵子树旋转：

下面先将99所在子树进行右单旋：

再将66所在子树进行左单旋：

这样先右旋再左旋的情况我们将其称做：右左双旋

和左右双旋一样，新增节点的位置发生变化，会导致各节点的平衡因子出现差异，当新增节点在B子树上时，通过左右双旋调整后的结果又不一样：：

另外还有h为0的特殊情况：

好了，分析到这里，使用代码实现也就不是问题了：

  1. void RotateRL(Node* parent)//右左双旋
  2. {
  3. 	Node* subR = parent->_right;
  4. 	Node* subRL = subR->_left;
  5. 	int subRL_bf = subRL->_bf;//记录该节点的平衡因子来做旋转结束后的修改平衡因子的依据
  6. 	RotateR(subR);//调用右单旋
  7. 	RotateL(parent);//调用左单旋
  8. 	if (subRL_bf == -1)
  9. 	{
  10. 		parent->_bf = 0;
  11. 		subR->_bf = 1;
  12. 		subRL->_bf = 0;
  13. 	}
  14. 	else if (subRL_bf == 0)
  15. 	{
  16. 		parent->_bf = 0;
  17. 		subR->_bf = 0;
  18. 		subRL->_bf = 0;
  19. 	}
  20. 	else if (subRL_bf == 1)
  21. 	{
  22. 		parent->_bf = -1;
  23. 		subR->_bf = 0;
  24. 		subRL->_bf = 0;
  25. 	}
  26. 	else
  27. 	{
  28. 		assert(false);
  29. 	}
  30. }

2.3 AVL树的检查验证

下面我们来实现一个函数来检查自己所创建的AVL树是否符合规则：

  1. int _CountHeight(Node* root)//计算树的高度
  2. {
  3. 	if (root == nullptr)
  4. 		return 0;
  5. 	int leftnum = _CountHeight(root->_left);
  6. 	int rightnum = _CountHeight(root->_right);
  7. 	return leftnum > rightnum ? leftnum + 1 : rightnum + 1;
  8. }
  9. bool _IsBalance(Node* root)
  10. {
  11. 	if (root == nullptr)
  12. 		return true;
  13. 	int leftH = _CountHeight(root->_left);
  14. 	int rightH = _CountHeight(root->_right);
  15. 	if (rightH - leftH != root->_bf)//检查当前节点平衡因子是否正确
  16. 	{
  17. 		cout << root->_kv.first << "节点平衡因子异常" << endl;
  18. 		return false;
  19. 	}
  20.  
  21. 	return abs(leftH - rightH) < 2
  22. 		&& _IsBalance(root->_left)
  23. 		&& _IsBalance(root->_right);//检查左右子树高度之差的绝对值是否小于2
  24. }
  25. bool IsBalance()//检查是否为AVL树
  26. {
  27. 	return _IsBalance(_root);
  28. }

2.4 测试代码

  1. void Test_AVLTree()
  2. {
  3. 	const size_t N = 5000;
  4. 	AVLTree<int, int> t;
  5. 	for (size_t i = 0; i < N; ++i)
  6. 	{
  7. 		size_t x = rand() + i;
  8. 		t.Insert(make_pair(x, x));
  9. 	}
  10. 	t.InOrder();
  11. 	cout << t.IsBalance() << endl;
  12. 	cout << t.CountHeight() << endl;
  13. }

运行效果：

三、AVL树实现的完整代码

  1. #pragma once
  2. #include<iostream>
  3. #include<cassert>
  4.  
  5. using namespace std;
  6.  
  7. template<class Key,class Val>
  8. class AVLTreeNode
  9. {
  10. public:
  11. 	AVLTreeNode<Key, Val>* _left;
  12. 	AVLTreeNode<Key, Val>* _right;
  13. 	AVLTreeNode<Key, Val>* _parent;//多一个指针指向其父节点,方便我们的后续操作
  14. 	pair<Key, Val> _kv;
  15. 	int _bf;//balance factor(平衡因子)
  16.  
  17. 	AVLTreeNode(const pair<Key, Val>& kv)
  18. 		:_left(nullptr),
  19. 		_right(nullptr),
  20. 		_parent(nullptr),
  21. 		_kv(kv),
  22. 		_bf(0)
  23. 	{}
  24. };
  25.  
  26.  
  27. template<class Key, class Val>
  28. class AVLTree
  29. {
  30. 	typedef AVLTreeNode<Key, Val> Node;
  31.  
  32. public:
  33. 	bool Insert(const pair<Key,Val>& kv)
  34. 	{
  35. 		Node* cur = _root, * parent = nullptr;
  36. 		while (cur)//找到合适的位置
  37. 		{
  38. 			if (kv.first < cur->_kv.first)
  39. 			{
  40. 				parent = cur;
  41. 				cur = cur->_left;
  42. 			}
  43. 			else if (kv.first > cur->_kv.first)
  44. 			{
  45. 				parent = cur;
  46. 				cur = cur->_right;
  47. 			}
  48. 			else
  49. 			{
  50. 				cout << "插入的值重复" << endl;
  51. 				return false;
  52. 			}
  53. 		}
  54. 		cur = new Node(kv);
  55. 		cur->_parent = parent;
  56. 		//将插入的节点连接上二叉树
  57. 		if (parent == nullptr)
  58. 		{
  59. 			_root = cur;
  60. 		}
  61. 		else if (kv.first < parent->_kv.first)
  62. 		{
  63. 			parent->_left = cur;
  64. 		}
  65. 		else
  66. 		{
  67. 			parent->_right = cur;
  68. 		}
  69. 		//向上调整各节点的平衡因子
  70. 		while (parent)
  71. 		{
  72. 			if (parent->_left == cur)
  73. 			{
  74. 				--parent->_bf;//更新平衡因子
  75. 			}
  76. 			else
  77. 			{
  78. 				++parent->_bf;//更新平衡因子
  79. 			}
  80. 			//根据父节点的平衡因子的情况决定师傅继续向上调整各节点的平衡因子
  81. 			if (parent->_bf == 1 || parent->_bf == -1)//平衡因子为1或1继续向上更新
  82. 			{
  83. 				parent = parent->_parent;
  84. 				cur = cur->_parent;
  85. 			}
  86. 			else if (parent->_bf == 2 || parent->_bf == -2)//平衡因子为2或-2,树的结构不平衡，旋转parent节点所在子树
  87. 			{
  88. 				//旋转parent所在的子树
  89. 				if (parent->_bf == 2 && cur->_bf == 1)
  90. 				{
  91. 					RotateL(parent);//左单旋
  92. 				}
  93. 				else if (parent->_bf == -2 && cur->_bf == -1)
  94. 				{
  95. 					RotateR(parent);//右单旋
  96. 				}
  97. 				else if (parent->_bf == -2 && cur->_bf == 1)
  98. 				{
  99. 					RotateLR(parent);//左右双旋
  100. 				}
  101. 				else if (parent->_bf == 2 && cur->_bf == -1)
  102. 				{
  103. 					RotateRL(parent);//右左双旋
  104. 				}
  105. 				else
  106. 				{
  107. 					assert(false);
  108. 				}
  109. 				break;
  110. 			}
  111. 			else if (parent->_bf == 0)//平衡因子为0,插入结束
  112. 			{
  113. 				break;
  114. 			}
  115. 			else//出现其他的情况说明树的根据有问题，报错退出
  116. 			{
  117. 				cout << "树的结构出错了" << endl;
  118. 				assert(0);
  119. 				exit(-1);
  120. 			}
  121. 		}
  122. 		return true;
  123. 	}
  124.  
  125. 	void InOrder()//中序遍历
  126. 	{
  127. 		_InOrder(_root);
  128. 		cout << endl;
  129. 	}
  130.  
  131. 	int CountHeight()//计算树的高度
  132. 	{
  133. 		return _CountHeight(_root);
  134. 	}
  135.  
  136. 	bool IsBalance()//检查是否为AVL树
  137. 	{
  138. 		return _IsBalance(_root);
  139. 	}
  140.  
  141. private:
  142. 	void RotateL(Node* parent)//左单旋
  143. 	{
  144. 		Node* subR = parent->_right;
  145. 		Node* subRL = subR->_left;
  146. 		Node* pparent = parent->_parent;
  147. 		parent->_right = subRL;//更新parent的右节点
  148. 		if (subRL)//防止该节点为空
  149. 		{
  150. 			subRL->_parent = parent;//更新subRL的父节点
  151. 		}
  152. 		parent->_parent = subR;//更新parent的父节点
  153. 		subR->_left = parent;//subR的左子树置为parent
  154. 		subR->_parent = pparent;//更新subR的父节点
  155. 		if (pparent == nullptr)//旋转的是整棵树
  156. 		{
  157. 			_root = subR;//更新根节点
  158. 		}
  159. 		else//将旋转后的子树链接上整个二叉树
  160. 		{
  161. 			if (pparent->_left == parent)
  162. 			{
  163. 				pparent->_left = subR;
  164. 			}
  165. 			else
  166. 			{
  167. 				pparent->_right = subR;
  168. 			}
  169. 		}
  170. 		subR->_bf = parent->_bf = 0;//更新平衡因子
  171. 	}
  172.  
  173. 	void RotateR(Node* parent)//右单旋
  174. 	{
  175. 		Node* subL = parent->_left;
  176. 		Node* subLR = subL->_right;
  177. 		Node* pparent = parent->_parent;
  178. 		parent->_left = subLR;//更新parent的左节点
  179. 		if (subLR)//防止该节点为空
  180. 		{
  181. 			subLR->_parent = parent;//更新subLR的父节点
  182. 		}
  183. 		parent->_parent = subL;//更新parent的父节点
  184. 		subL->_right = parent;//subL的右子树置为parent
  185. 		subL->_parent = pparent;//更新subL的父节点
  186. 		if (pparent == nullptr)//旋转的是整棵树
  187. 		{
  188. 			_root = subL;//更新根节点
  189. 		}
  190. 		else//将旋转后的子树链接上整个二叉树
  191. 		{
  192. 			if (pparent->_left == parent)
  193. 			{
  194. 				pparent->_left = subL;
  195. 			}
  196. 			else
  197. 			{
  198. 				pparent->_right = subL;
  199. 			}
  200. 		}
  201. 		subL->_bf = parent->_bf = 0;//更新平衡因子
  202. 	}
  203.  
  204. 	void RotateLR(Node* parent)//左右双旋
  205. 	{
  206. 		Node* subL = parent->_left;
  207. 		Node* subLR = subL->_right;
  208. 		int subLR_bf = subLR->_bf;//记录该节点的平衡因子来做旋转结束后的修改平衡因子的依据
  209. 		RotateL(subL);//调用左单旋
  210. 		RotateR(parent);//调用右单旋
  211. 		if (subLR_bf == -1)
  212. 		{
  213. 			parent->_bf = 1;
  214. 			subL->_bf = 0;
  215. 			subLR->_bf = 0;
  216. 		}
  217. 		else if(subLR_bf == 0)
  218. 		{
  219. 			parent->_bf = 0;
  220. 			subL->_bf = 0;
  221. 			subLR->_bf = 0;
  222. 		}
  223. 		else if (subLR_bf == 1)
  224. 		{
  225. 			parent->_bf = 0;
  226. 			subL->_bf = -1;
  227. 			subLR->_bf = 0;
  228. 		}
  229. 		else
  230. 		{
  231. 			assert(false);
  232. 		}
  233. 	}
  234.  
  235. 	void RotateRL(Node* parent)//右左双旋
  236. 	{
  237. 		Node* subR = parent->_right;
  238. 		Node* subRL = subR->_left;
  239. 		int subRL_bf = subRL->_bf;//记录该节点的平衡因子来做旋转结束后的修改平衡因子的依据
  240. 		RotateR(subR);//调用右单旋
  241. 		RotateL(parent);//调用左单旋
  242. 		if (subRL_bf == -1)
  243. 		{
  244. 			parent->_bf = 0;
  245. 			subR->_bf = 1;
  246. 			subRL->_bf = 0;
  247. 		}
  248. 		else if (subRL_bf == 0)
  249. 		{
  250. 			parent->_bf = 0;
  251. 			subR->_bf = 0;
  252. 			subRL->_bf = 0;
  253. 		}
  254. 		else if (subRL_bf == 1)
  255. 		{
  256. 			parent->_bf = -1;
  257. 			subR->_bf = 0;
  258. 			subRL->_bf = 0;
  259. 		}
  260. 		else
  261. 		{
  262. 			assert(false);
  263. 		}
  264. 	}
  265.  
  266. 	void _InOrder(Node* root)
  267. 	{
  268. 		if (root == NULL)//如果是空树就直接结束
  269. 		{
  270. 			return;
  271. 		}
  272. 		_InOrder(root->_left);//先递归遍历其左子树
  273. 		cout << root->_kv.first << " ";//再遍历其根节点
  274. 		_InOrder(root->_right);//最后递归遍历其右子树
  275. 	}
  276.  
  277. 	int _CountHeight(Node* root)//计算树的高度
  278. 	{
  279. 		if (root == nullptr)
  280. 			return 0;
  281. 		int leftnum = _CountHeight(root->_left);
  282. 		int rightnum = _CountHeight(root->_right);
  283. 		return leftnum > rightnum ? leftnum + 1 : rightnum + 1;
  284. 	}
  285.  
  286. 	bool _IsBalance(Node* root)
  287. 	{
  288. 		if (root == nullptr)
  289. 			return true;
  290. 		int leftH = _CountHeight(root->_left);
  291. 		int rightH = _CountHeight(root->_right);
  292. 		if (rightH - leftH != root->_bf)//检查当前节点平衡因子是否正确
  293. 		{
  294. 			cout << root->_kv.first << "节点平衡因子异常" << endl;
  295. 			return false;
  296. 		}
  297.  
  298. 		return abs(leftH - rightH) < 2
  299. 			&& _IsBalance(root->_left)
  300. 			&& _IsBalance(root->_right);//检查左右子树高度之差的绝对值是否小于2
  301. 	}
  302. private:
  303. 	AVLTreeNode<Key, Val>* _root = nullptr;
  304. };
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/一键难忘520/article/detail/991907?site=
推荐阅读
相关标签

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

  

闽ICP备14008679号