• AVL树C++实现——高度平衡二叉搜索树

    目录

    一、AVL树的概念

    二、AVL 树节点的定义

    三、AVL 树的插入

    3.1 搜索树的插入

    3.2 更新平衡因子的规则

    3.4 左单旋调整

    3.3 右单旋调整

    3.5 先左单旋再右单旋

    1. 右左插入

    2. 右右插入

    3. 右侧新增

    3.5 先右单旋再左单旋

    四、AVL 树测试

    五、代码与测试用例

    一、AVL树的概念

    二叉搜索树可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于再顺序表中搜索元素，效率低下。

    因此，两位俄罗斯数学家便发明了一种解决上述问题的方法：

    当向二叉搜索树中插入新节点后，如果能保证每个结点左右子树高度之差的绝对值不超过1(需要对树的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

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

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

    如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有 n 个结点，其高度可保持在 logN，搜索的时间复杂度为 logN。

    二、AVL 树节点的定义

    二叉搜索树结点的定义与 AVL 树结点的定义在于：

    1. 三叉链模式，增加了父指针。
    2. 增加了平衡因子，方便我们调整平衡(可有可无，只是为了方便我们实现)

    其数据的存储方式我们采用 K-value 模型。

    三、AVL 树的插入

    3.1 搜索树的插入

    AVL 本质就是二叉搜索树，只不过 AVL 树是在二叉搜索树的基础上引入了平衡因子。即，在 AVL 树中的插入过程可以分为两步：

    1. 按照二叉搜索树的方式插入新节点
    2. 调整节点的平衡因子

    我们先来实现第一步，按二叉搜索树的方式插入新节点。

     这里就不过多介绍了，上一篇讲解过了二叉搜索树的插入。二叉搜索树的插入

    1. bool _Insert(const pair& kv)
    2. {
    3. 	if (_root == nullptr)
    4. 	{
    5. 		_root = new Node(kv);
    6. 		return true;
    7. 	}
    8. 	Node* parent = nullptr;
    9. 	Node* cur = _root;
    10.  
    11. 	//找插入的位置
    12. 	while (cur)
    13. 	{
    14. 		if (cur->_kv.first < kv.first)
    15. 		{
    16. 			parent = cur;
    17. 			cur = cur->_right;
    18. 		}
    19. 		else if (cur->_kv.first > kv.first)
    20. 		{
    21. 			parent = cur;
    22. 			cur = cur->_left;
    23. 		}
    24. 		else
    25. 		{
    26. 			return false;
    27. 		}
    28. 	}
    29.  
    30. 	//开始插入
    31. 	cur = new Node(kv);
    32. 	if (parent->_kv.first < kv.first)
    33. 	{
    34. 		parent->_right = cur;
    35. 	}
    36. 	else
    37. 	{
    38. 		parent->_left = cur;
    39. 	}
    40. 	//因为增加了父域，所以还要处理cur的父域
    41. 	cur->_parent = parent;
    42. }

    3.2 更新平衡因子的规则

    以上我们完成了节点的插入，但是插入了节点后，树可能会出现以下情况：

     所以，为了防止以上情况出现，我们在插入后要调整平衡。

    为了维持平衡，我们引入了平衡因子来控制树的平衡，所以我们每次插入后要更新平衡因子，如果出现失去平衡的情况，我们则要进行旋转来维持平衡。

    更新平衡因子的规则：

    1. 新增在右边，则会让父平衡因子++，新增在左边，父平衡因子 -- ;
    2. 更新后，如果 parent->bf == 0，说明 parent 插入前的平衡因子是 1 or -1，插入填上了矮的一边，parent 的子树高度不变，不需要继续往上更新。
    3. 更新后，如果 parent->bf 为 1 或 -1， 说明parent插入前的平衡因子是0，说明左右子树高度相等，插入后有一边高，parnet 高度变了，需要继续往上更新。
    4. 更新后，如果 parent->bf == 2 或 -2 ，说明 parent 插入前的平衡因子是 1 or -1，已经到达平衡临界值，parent 子树进行旋转处理将树保持平衡。
    5. 更新后，如果 parent->bf >2 或 <-2 ，则说明插入前树已经失去的平衡，要进行代码的检查。

    现在，我们要对祖先路径更新平衡因子，直到更新到根节点结束。

    注释我写的非常清楚，结合上图和代码一起理解。

     当规则4出现时，我们则要进行旋转来调整平衡，旋转共分为 4 种情况，左左右单旋、右右左单旋、左右左右双旋、右左右左双旋我们一一进行解决。

    3.4 左单旋调整

    新节点插入较高右子树的右侧 --- 右右：左单旋
    观察下图，如果我们在 c 节点下插入新节点，导致 60的左右子树失去平衡，调整前后的情况如下:

     现在我们要发现左单旋的执行规律：

    1.树的右子树失去平衡(parent->bf == 2)，并且新插入的节点位于右子树的右侧(cur->bf == 1)。

    2. 将 cur->left 交由 parent->right 抚养，再调整父子关系，使 cur->left 指向 parent ，即完成旋转。

    3.平衡因子归零。观察上图，旋转后，60 的左右子树高度相同(a、b高度为h，c的高度为 h+1，注意：60左子树的高度也为h+1，因为存在 30 节点)

    接下来我们编写代码

    3.3 右单旋调整

    新节点插入较高左子树的左侧-左左：右单旋。
    观察下图，如果我们在 a 节点处插入新节点，导致 60的左右子树失去平衡，调整前后的情况如下：

     现在我们要发现右单旋的执行规律：

    1.树的左子树失去平衡(parent->bf == -2)，并且新插入的节点位于左子树的左侧(cur->bf == -1)。

    2. 将 cur->right 交由 parent->left 抚养，再调整父子关系，使 cur->right 指向 parent ，即完成旋转。

    右单旋就是方向相反的左单旋，理解了左单旋，右单旋实现起来非常简单， 代码如下。 
    1. //情况2：左左右单旋
    2. void RotateR(Node * parent)
    3. {
    4. 	Node* subL = parent->_left;
    5. 	Node* subLR = subL->_right;
    6.  
    7. 	parent->_left = subLR;
    8. 	if (subLR)
    9. 		subLR->_parent = parent;
    10.  
    11. 	Node* ppNode = parent->_parent;
    12. 	subL->_right = parent;
    13. 	parent->_parent = subL;
    14. 	if (ppNode)
    15. 	{
    16. 		if (ppNode->_left == parent)
    17. 		{
    18. 			ppNode->_left = subL;
    19. 		}
    20. 		else
    21. 		{
    22. 			ppNode->_right = subL;
    23. 		}
    24. 		subL->_parent = ppNode;
    25. 	}
    26. 	else
    27. 	{
    28. 		_root = subL;
    29. 		subL->_parent = nullptr;
    30. 	}
    31. 	subL->_bf = parent->_bf = 0;
    32. }

    3.5 先左单旋再右单旋

    上面我们解决了4种情况中的两种情况，对于平衡的调整还有左右左右双旋和右左右左双旋这两种情况。

    其调整的条件是根的左子树的右侧插入了新的节点。

    这种插入情况我们还要再细分为三种插入情况，其平衡因子会出现不同的情况：

    1. 在30的右子树 60 左侧进行插入。
    2. 在30的右子树 60 右侧进行插入。
    3. 30的右子树为空，插入的节点为60本身。

    1. 右左插入

    先分析第一种情况，如图：

    此时 60 节点的左侧插入节点导致 90 节点下的左右子树高度失衡，所以我们接下来要对 90 节点下进行旋转处理。

    旋转的步骤分为两步：

     先对30进行左单旋，然后再对90进行右单旋

    1.先对 30 进行左单旋，这样，30节点的左右子树便恢复了平衡。

    2.因为 60 左子树高度高于右子树，以 90节点视角来看，符合右单旋的条件(左高右低)，所以90节点进行右单旋

    然后对 90 进行右单旋

    2. 右右插入

     以上情况是在 60 的左边进行插入，同样也有在 60 的右边进行插入，两种插入会导致 90、30的 平衡因子出现不同的情况。注意观察下图平衡因子的变化，与上图是不同的。

     然后对90进行右单旋

    3. 右侧新增

     此时我们解决的都是 30 有左右子树，60有左右子树，还有一种可能，h为0，即60本身为新增。

    然后进行旋转

     好的，三种情况我们都分析完了，发现其实无论哪种情况，其步骤都经历的左单旋和右单旋，只是平衡因子因情况的不同而不同。

    而这三种情况的不同都是由 60 影响的，所以我们根据 60 平衡因子的不同分别进行调整即可。

     

    3.5 先右单旋再左单旋

     同样的，右左右左双旋和左右左右双旋几乎一致，就不做过多讲解了，结合画图，仿照左右双旋，很容易写出代码。

     代码如下：

    1. else if (parent->_bf == 2 && cur->_bf == -1)
    2. {
    3. 	//右左双旋
    4. 	Node* subR = parent->_right;
    5. 	Node* subRL = subR->_left;
    6. 	int bf = subRL->_bf;
    7.  
    8. 	//旋转
    9. 	RotateR(parent->_right);
    10. 	RotateL(parent);
    11.  
    12. 	subRL->_bf = 0;
    13. 	if (bf == 1)
    14. 	{
    15. 		subR->_bf = 0;
    16. 		parent->_bf = -1;
    17. 	}
    18. 	else if (bf == -1)
    19. 	{
    20. 		subR->_bf = 1;
    21. 		parent->_bf = 0;
    22. 	}
    23. 	else if (bf == 0)
    24. 	{
    25. 		subR->_bf = 0;
    26. 		parent->_bf = 0;
    27. 	}
    28. 	else
    29. 	{
    30. 		assert(false);
    31. 	}
    32. }

    四、AVL 树测试

    实现了插入我们来测试一下代码。

     好的，程序能正常运行，但程序能正常运行就说明我们的 AVL 就是成功的吗？我们的 AVL 树就是平衡的吗？

    所以现在我们要使用检查树的高度的方式来检查树是否是平衡的。即，如果左右子树的高度差不超过1，则说明该树是平衡的，接下来我们来编写成员函数。

    1. int _Height(Node* root)
    2. {
    3. 	if (root == nullptr)
    4. 		return 0;
    5. 	return max(_Height(root->_left), _Height(root->_right)) + 1;
    6. }

    有了测量高度的函数后我们来编写平衡判断函数。

    1. bool _IsBalance(Node* root)
    2. {
    3. 	if (root == nullptr)
    4. 		return true;
    5. 	int leftHeight = _Height(root->_left);
    6. 	int rightHeight = _Height(root->_right);
    7. 	int diffHeight = abs(leftHeight - rightHeight);
    8.  
    9. 	// |diffHeight|小于2 则当前树平衡。
    10. 	// 还要去判断左右子树是否平衡
    11. 	return abs(diffHeight) < 2
    12. 		&& _IsBalance(root->_left)
    13. 		&& _IsBalance(root->_right);
    14. }

    好的，接下来往树中插入一万个随机数据，然后来判断其是否平衡。

    14层的平衡二叉树大约有16万个节点，所以高度计算正确，通过 IsBalance 函数也判定当前树为平衡。

    最后我们来玩一下AVL树，往树中插入一亿个数据，然后找到77777处的数据。结果如下：

     一亿个数据，插入的效率是O(n*logN)，想找到其中任意一个值，最多查找高度处。

    五、代码与测试用例

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #pragma once
    6. using namespace std;
    7. //AVL树结点定义
    8. template<class K, class V>
    9. struct AVLTreeNode
    10. {
    11. 	AVLTreeNode * _left;
    12. 	AVLTreeNode * _right;
    13. 	AVLTreeNode * _parent;
    14.  
    15. 	pair _kv;   //key-value模型
    16. 	int _bf;          //banlance factor  平衡因子
    17.  
    18. 	AVLTreeNode(const pair& kv)
    19. 		:_left(nullptr), _right(nullptr), _parent(nullptr)
    20. 		, _kv(kv)
    21. 		, _bf(0)
    22. 	{}
    23. };
    24.  
    25. template<class K, class V>
    26. struct AVLTree
    27. {
    28. 	typedef AVLTreeNode Node;
    29. public:
    30. 	bool Insert(const pair& kv)
    31. 	{
    32. 		if (_root == nullptr)
    33. 		{
    34. 			_root = new Node(kv);
    35. 			return true;
    36. 		}
    37.  
    38. 		Node* parent = nullptr;
    39. 		Node* cur = _root;
    40. 		while (cur)
    41. 		{
    42. 			if (cur->_kv.first < kv.first)
    43. 			{
    44. 				parent = cur;
    45. 				cur = cur->_right;
    46. 			}
    47. 			else if (cur->_kv.first > kv.first)
    48. 			{
    49. 				parent = cur;
    50. 				cur = cur->_left;
    51. 			}
    52. 			else
    53. 			{
    54. 				return false;
    55. 			}
    56. 		}
    57.  
    58. 		cur = new Node(kv);
    59. 		if (parent->_kv.first < kv.first)
    60. 		{
    61. 			parent->_right = cur;
    62. 		}
    63. 		else
    64. 		{
    65. 			parent->_left = cur;
    66. 		}
    67.  
    68. 		cur->_parent = parent;
    69.  
    70. 		// 控制平衡
    71. 		// 1、更新平衡因子
    72. 		while (parent)
    73. 		{
    74. 			if (cur == parent->_right)
    75. 			{
    76. 				parent->_bf++;
    77. 			}
    78. 			else
    79. 			{
    80. 				parent->_bf--;
    81. 			}
    82.  
    83. 			if (parent->_bf == 0)
    84. 			{
    85. 				break;
    86. 			}
    87. 			else if (abs(parent->_bf) == 1)
    88. 			{
    89. 				parent = parent->_parent;
    90. 				cur = cur->_parent;
    91. 			}
    92. 			else if (abs(parent->_bf) == 2)
    93. 			{
    94. 				// 说明parent所在子树已经不平衡了，需要旋转处理
    95. 				if (parent->_bf == 2 && cur->_bf == 1)
    96. 				{
    97. 					RotateL(parent);
    98. 				}
    99. 				else if ((parent->_bf == -2 && cur->_bf == -1))
    100. 				{
    101. 					RotateR(parent);
    102. 				}
    103. 				else if (parent->_bf == -2 && cur->_bf == 1)
    104. 				{
    105. 					RotateLR(parent);
    106. 				}
    107. 				else if (parent->_bf == 2 && cur->_bf == -1)
    108. 				{
    109. 					RotateRL(parent);
    110. 				}
    111. 				else
    112. 				{
    113. 					assert(false);
    114. 				}
    115.  
    116. 				break;
    117. 			}
    118. 			else
    119. 			{
    120. 				assert(false);
    121. 			}
    122. 		}
    123.  
    124. 		return true;
    125. 	}
    126. 	void Inorder()
    127. 	{
    128. 		_Inorder(_root);
    129. 	}
    130. 	int Height()
    131. 	{
    132. 		return _Height(_root);
    133. 	}
    134. 	bool IsBalance()
    135. 	{
    136. 		return _IsBalance(_root);
    137. 	}
    138.  
    139. 	pair Find(const K& key)
    140. 	{
    141. 		Node* cur = _root;
    142. 		while (cur)
    143. 		{
    144. 			if (cur->_kv.first > key)
    145. 			{
    146. 				cur = cur->_left;
    147. 			}
    148. 			else if (cur->_kv.first < key)
    149. 			{
    150. 				cur = cur->_right;
    151. 			}
    152. 			else
    153. 			{
    154. 				return cur->_kv;
    155. 			}
    156. 		}
    157. 		return pair<int, int>(0, 0);
    158. 	}
    159. private:
    160.  
    161. 	bool _IsBalance(Node* root)
    162. 	{
    163. 		if (root == nullptr)
    164. 			return true;
    165. 		int leftHeight = _Height(root->_left);
    166. 		int rightHeight = _Height(root->_right);
    167. 		int diffHeight = abs(leftHeight - rightHeight);
    168.  
    169. 		// |diffHeight|小于2 则当前树平衡。
    170. 		// 还要去判断左右子树是否平衡
    171. 		return abs(diffHeight) < 2
    172. 			&& _IsBalance(root->_left)
    173. 			&& _IsBalance(root->_right);
    174. 	}
    175.  
    176. 	int _Height(Node* root)
    177. 	{
    178. 		if (root == nullptr)
    179. 			return 0;
    180. 		return max(_Height(root->_left), _Height(root->_right)) + 1;
    181. 	}
    182.  
    183. 	void _Inorder(Node* root)
    184. 	{
    185. 		if (root)
    186. 		{
    187. 			_Inorder(root->_left);
    188. 			cout << root->_kv.first << ":" << root->_kv.second << endl;
    189. 			_Inorder(root->_right);
    190. 		}
    191. 	}
    192. 	void RotateL(Node* parent)
    193. 	{
    194. 		Node* subR = parent->_right;
    195. 		Node* subRL = subR->_left;
    196.  
    197. 		parent->_right = subRL;
    198. 		if (subRL)
    199. 			subRL->_parent = parent;
    200.  
    201. 		Node* ppNode = parent->_parent;
    202.  
    203. 		subR->_left = parent;
    204. 		parent->_parent = subR;
    205.  
    206. 		if (_root == parent)
    207. 		{
    208. 			_root = subR;
    209. 			subR->_parent = nullptr;
    210. 		}
    211. 		else
    212. 		{
    213. 			if (ppNode->_left == parent)
    214. 			{
    215. 				ppNode->_left = subR;
    216. 			}
    217. 			else
    218. 			{
    219. 				ppNode->_right = subR;
    220. 			}
    221.  
    222. 			subR->_parent = ppNode;
    223. 		}
    224.  
    225. 		subR->_bf = parent->_bf = 0;
    226. 	}
    227.  
    228. 	void RotateR(Node* parent)
    229. 	{
    230. 		Node* subL = parent->_left;
    231. 		Node* subLR = subL->_right;
    232.  
    233. 		parent->_left = subLR;
    234. 		if (subLR)
    235. 		{
    236. 			subLR->_parent = parent;
    237. 		}
    238.  
    239. 		Node* ppNode = parent->_parent;
    240.  
    241. 		subL->_right = parent;
    242. 		parent->_parent = subL;
    243.  
    244. 		if (_root == parent)
    245. 		{
    246. 			_root = subL;
    247. 			subL->_parent = nullptr;
    248. 		}
    249. 		else
    250. 		{
    251. 			if (ppNode->_left == parent)
    252. 			{
    253. 				ppNode->_left = subL;
    254. 			}
    255. 			else
    256. 			{
    257. 				ppNode->_right = subL;
    258. 			}
    259.  
    260. 			subL->_parent = ppNode;
    261. 		}
    262.  
    263. 		subL->_bf = parent->_bf = 0;
    264. 	}
    265.  
    266. 	void RotateLR(Node* parent)
    267. 	{
    268. 		Node* subL = parent->_left;
    269. 		Node* subLR = subL->_right;
    270. 		int bf = subLR->_bf;
    271.  
    272. 		RotateL(parent->_left);
    273. 		RotateR(parent);
    274.  
    275. 		subLR->_bf = 0;
    276. 		if (bf == 1)
    277. 		{
    278. 			parent->_bf = 0;
    279. 			subL->_bf = -1;
    280. 		}
    281. 		else if (bf == -1)
    282. 		{
    283. 			// 错的
    284. 			/*parent->_bf = 0;
    285. 			subL->_bf = 1;*/
    286.  
    287. 			parent->_bf = 1;
    288. 			subL->_bf = 0;
    289. 		}
    290. 		else if (bf == 0)
    291. 		{
    292. 			parent->_bf = 0;
    293. 			subL->_bf = 0;
    294. 		}
    295. 		else
    296. 		{
    297. 			assert(false);
    298. 		}
    299. 	}
    300.  
    301. 	void RotateRL(Node* parent)
    302. 	{
    303. 		Node* subR = parent->_right;
    304. 		Node* subRL = subR->_left;
    305.  
    306. 		int bf = subRL->_bf;
    307.  
    308. 		RotateR(parent->_right);
    309. 		RotateL(parent);
    310.  
    311. 		subRL->_bf = 0;
    312. 		if (bf == 1)
    313. 		{
    314. 			subR->_bf = 0;
    315. 			parent->_bf = -1;
    316. 		}
    317. 		else if (bf == -1)
    318. 		{
    319. 			subR->_bf = 1;
    320. 			parent->_bf = 0;
    321. 		}
    322. 		else if (bf == 0)
    323. 		{
    324. 			parent->_bf = 0;
    325. 			subR->_bf = 0;
    326. 		}
    327. 		else
    328. 		{
    329. 			assert(false);
    330. 		}
    331. 	}
    332.  
    333. private:
    334. 	Node* _root = nullptr;
    335. };
    336.  
    337. void TestAVLTree1()
    338. {
    339. 	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    340. 	AVLTree<int, int> t1;
    341. 	for (auto e : a)
    342. 	{
    343. 		t1.Insert(make_pair(e, e));
    344. 	}
    345. 	t1.Inorder();
    346. 	cout << t1.Height() << endl;
    347. 	if (t1.IsBalance())
    348. 		cout << "平衡树" << endl;
    349. 	else
    350. 		cout << "非平衡树" << endl;
    351. }
    352.  
    353.  
    354. void TestAVLTree2()
    355. {
    356. 	//随机插入一万个数据
    357. 	size_t N = 10000;
    358. 	srand((unsigned int)time(NULL));
    359. 	AVLTree<int, int> t1;
    360. 	for (size_t i = 0; i < N; ++i)
    361. 	{
    362. 		int x = rand() % 100 + 1;
    363. 		t1.Insert(make_pair(i, x));
    364. 		bool IsBalance = t1.IsBalance();
    365. 		printf("%-4d:%-2d  ", i, x);
    366. 		printf("Balance:%d\n", IsBalance);
    367. 		if (!IsBalance)
    368. 		{
    369. 			cout << i << endl;
    370. 			assert(false);
    371. 		}
    372. 	}
    373. 	//树的高度
    374. 	cout << "Tree Height:" << t1.Height() << endl;
    375.  
    376. 	//判断平衡
    377. 	if (t1.IsBalance())
    378. 		cout << "IS AVL" << endl;
    379. 	else
    380. 		cout << "NOT AVL" << endl;
    381. }
    382.  
    383. void TestAVLTree3()
    384. {
    385. 	size_t N = 100000000;
    386. 	srand((unsigned int)time(NULL));
    387. 	AVLTree<int, int> t1;
    388. 	for (size_t i = 0; i < N; ++i)
    389. 	{
    390. 		int x = rand() % 100 + 1;
    391. 		t1.Insert(make_pair(i, x));
    392. 	}
    393. 	cout << t1.Height() << endl;
    394. 	pair<int, int> result = t1.Find(777777);
    395. 	cout << result.first << ":" << result.second << endl;
    396. }
    397.  
    398. int main()
    399. {
    400. 	//TestAVLTree1();
    401. 	//TestAVLTree2();
    402. 	TestAVLTree3();
    403. 	return 0;
    404. }

  • 相关阅读:
    python 使用xlsx和pandas处理Excel表格
    京东JAVA面试心得与面试题详解
    华为云CDN，如何推动互联网行业健康发展？
    JAVA反编译工具：JADX-GUI、
    力扣刷题day45|300最长递增子序列、674最长连续递增序列、718最长重复子数组
    Python基础语法（五）—— 文件基本操作(打开、写入、关闭、查找)
    Spring Boot 整合 Shiro，十分钟，让你知道有多简单
    微信小程序父子组件之间传值
    JAVA网络编程
    Android与H5交互 -- 点击H5跳转到 Android原生 页面
  • 原文地址：https://blog.csdn.net/Brant_zero/article/details/127813316