• 【C++进阶】AVL树

    0.前言

    前面我们已经学习过二叉搜索树了，但如果我们是用二叉搜索树来封装map和set等关联式容器是有缺陷的，很可能会退化为单分支的情况，那样效率就极低了，那么有没有方法来弥补二叉搜索树的缺陷呢？

    那么AVL树就出现了，通过AVL树的右单旋、左单旋、左右单旋，右左单旋等操作来防止二叉搜索树退化为单分支的情况出现。

    因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
    AVL树也是以这两位大佬名字的首字母来命名的。

    1.AVL树的概念

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

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

    我们这里使用的平衡因子是右子树高度 - 左子树高度。 

     

    2.AVL树节点的定义

    代码如下：

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

    3.AVL树的插入

    AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么
    AVL树的插入过程可以分为两步：

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

    插入思路：

     1.按照搜索树规则插入

    2.更新插入节点的祖先节点的平衡因子

            a.插入父亲的右边，父亲的平衡因子--

            b.插入父亲的左边，父亲的平衡因子++

            c.父亲平衡因子 == 0， 父亲所在子树高度不变，不再继续往上更新。插入结束

            d.父亲平衡因子 == 1 or -1， 父亲所在子树高度变了，继续往上更新。

            e.父亲平衡因子 == 2 or -2， 父亲所在子树已经不平衡了，需要旋转处理。

    更新中不可能出现其他值，插入之前树是AVL树，平衡因子要么是1 -1 0， ++ --

    最多就是c/d/e三种情况。

     代码如下：

    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. 		while (cur)
    11. 		{
    12. 			if (cur->_kv.first < kv.first)
    13. 			{
    14. 				parent = cur;
    15. 				cur = cur->_right;
    16. 			}
    17. 			else if (cur->_kv.first > kv.first)
    18. 			{
    19. 				parent = cur;
    20. 				cur = cur->_left;
    21. 			}
    22. 			else
    23. 			{
    24. 				return false;
    25. 			}
    26. 		}
    27.  
    28. 		cur = new Node(kv);
    29. 		if (parent->_kv.first < kv.first)
    30. 		{
    31. 			parent->_right = cur;
    32. 		}
    33. 		else
    34. 		{
    35. 			parent->_left = cur;
    36. 		}
    37. 		cur->_parent = parent;
    38.  
    39. 		//更新平衡因子
    40. 		while (parent)
    41. 		{
    42. 			if (cur == parent->_left)
    43. 			{
    44. 				parent->_bf--;
    45. 			}
    46. 			else
    47. 			{
    48. 				parent->_bf++;
    49. 			}
    50. 			if (parent->_bf == 0)
    51. 			{
    52. 				//更新结束
    53. 				break;
    54. 			}
    55. 			else if (parent->_bf == -1 || parent->_bf == 1)
    56. 			{
    57. 				//继续往上更新
    58. 				cur = parent;
    59. 				parent = parent->_parent;
    60. 			}
    61. 			else if (parent->_bf == -2 || parent->_bf == 2)
    62. 			{
    63. 				//当前子树出现了问题，需要旋转平衡一下
    64. 				if (parent->_bf == -2 && cur->_bf == -1)
    65. 				{
    66. 					//右单旋
    67. 					RotateR(parent);
    68. 				}
    69. 				else if (parent->_bf == 2 && cur->_bf == 1)
    70. 				{
    71. 					//左单旋
    72. 					RotateL(parent);
    73. 				}
    74. 				else if (parent->_bf == -2 && cur->_bf == 1)
    75. 				{
    76. 					//左右双旋
    77. 					RotateLR(parent);
    78. 				}
    79. 				else if (parent->_bf == 2 && cur->_bf == -1)
    80. 				{
    81. 					//右左双旋
    82. 					//RotateRL(parent);
    83. 				}
    84. 				break;
    85. 			}
    86. 			else
    87. 			{
    88. 				//理论上不会出现这种情况，但仍要判断，大佬都不能保证自己的代码没有bug
    89. 				assert(false);
    90. 			}
    91.  
    92. 		}
    93. 		return true;
    94. 	}

    4.AVL树的旋转

    4.1 右单旋

    插入新节点要插入较高左子树的左侧（左左）-》右单旋

    图形解析：

     实现代码如下：

    1. 	void RotateR(Node* parent)
    2. 	{
    3. 		Node* subL = parent->_left;
    4. 		Node* subLR = subL->_right;
    5. 		parent->_left = subLR;
    6. 		if (subLR)	//subLR有可能为空，不为空时才能调整subLR的父节点
    7. 			subLR->_parent = parent;
    8. 		subL->_right = parent;
    9. 		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
    10. 		Node* ppNode = parent->_parent;
    11. 		parent->_parent = subL;
    12.  
    13. 		if (parent == _root)
    14. 		{
    15. 			_root = subL;
    16. 			_root->_parent = nullptr;
    17. 		}
    18. 		else
    19. 		{
    20. 			if (ppNode->_left == parent)
    21. 			{
    22. 				ppNode->_left = subL;
    23. 			}
    24. 			else
    25. 			{
    26. 				ppNode->_right = subL;
    27. 			}
    28. 			subL->_parent = ppNode;
    29. 		}
    30. 		subL->_bf = parent->_bf = 0;
    31. 	}

    4.2 左单旋

    插入新节点要插入较高右子树的右侧（右右）-》左单旋

    图形解析：

     代码如下：

    1. 	void RotateL(Node* parent)
    2. 	{
    3. 		Node* subR = parent->_right;
    4. 		Node* subRL = subR->_left;
    5. 		parent->_right = subRL;
    6. 		if (subRL)	//subRL有可能为空，不为空时才能调整subRL的父节点
    7. 			subRL->_parent = parent;
    8. 		subR->_left = parent;
    9. 		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
    10. 		Node* ppNode = parent->_parent;
    11. 		parent->_parent = subR;
    12.  
    13. 		if (parent == _root)
    14. 		{
    15. 			_root = subR;
    16. 			_root->_parent = nullptr;
    17. 		}
    18. 		else
    19. 		{
    20. 			if (ppNode->_left == parent)
    21. 			{
    22. 				ppNode->_left = subR;
    23. 			}
    24. 			else
    25. 			{
    26. 				ppNode->_right = subR;
    27. 			}
    28. 			subR->_parent = ppNode;
    29. 		}
    30. 		subR->_bf = parent->_bf = 0;
    31. 	}

    4.3 左右双旋

    插入新节点要插入较高左子树的右侧（左右）-》左右双旋

    图形解析：

    对于插入的位置根据h的高度和插入的位置时的平衡因子出现的最终的结果可分为三种情况：

    1.h == 0

            60自己就是新增节点。bf == 0

    此时的平衡因子为，30 60 90节点都为0。

    2.h > 0

            a.新增节点插入的是60的左子树中 bf == -1

    此时的平衡因子为，30节点为0,90为0,60为1

            b.新增节点插入的是60的右子树中bf == 1

    此时的平衡因子为，30节点为-1,90为0,60为0

    代码如下：

     

    1. 	void RotateLR(Node* parent)
    2. 	{
    3. 		Node* subL = parent->_left;
    4. 		Node* subLR = subL->_right;
    5.  
    6. 		int bf = subLR->_bf;
    7.  
    8. 		RotateL(parent->_left);
    9. 		RotateR(parent);
    10.  
    11. 		if (bf == 0)
    12. 		{
    13. 			subL->_bf = 0;
    14. 			subLR->_bf = 0;
    15. 			parent->_bf = 0;
    16. 		}
    17. 		else if (bf == -1)
    18. 		{
    19. 			subL->_bf = 0;
    20. 			subLR->_bf = 0;
    21. 			parent->_bf = 1;
    22. 		}
    23. 		else if (bf == 1)
    24. 		{
    25. 			subL->_bf = -1;
    26. 			subLR->_bf = 0;
    27. 			parent->_bf = 0;
    28. 		}
    29. 		else
    30. 		{
    31. 			//理论上不会出现的情况
    32. 			assert(false);
    33. 		}
    34. 	}

    4.4 右左双旋

    插入新节点要插入较高右子树的左侧（右左）-》右左双旋

    与左右双旋类似

    代码如下：

    1. 	void RotateRL(Node* parent)
    2. 	{
    3. 		Node* subR = parent->_right;
    4. 		Node* subRL = subR->_left;
    5.  
    6. 		int bf = subRL->_bf;
    7.  
    8. 		RotateR(parent->_right);
    9. 		RotateL(parent);
    10.  
    11. 		if (bf == 0)
    12. 		{
    13. 			parent->_bf = 0;
    14. 			subRL->_bf = 0;
    15. 			subR->_bf = 0;
    16. 		}
    17. 		else if (bf == -1)
    18. 		{
    19. 			parent->_bf = 0;
    20. 			subRL->_bf = 0;
    21. 			subR->_bf = 1;
    22. 		}
    23. 		else if (bf == 1)
    24. 		{
    25. 			parent->_bf = -1;
    26. 			subRL->_bf = 0;
    27. 			subR->_bf = 0;
    28. 		}
    29. 		else
    30. 		{
    31. 			//理论上不会出现的情况
    32. 			assert(false);
    33. 		}
    34. 	}


    总结：
    假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑
    1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
    当pSubR的平衡因子为1时，执行左单旋
    当pSubR的平衡因子为-1时，执行右左双旋
    2. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
    当pSubL的平衡因子为-1是，执行右单旋
    当pSubL的平衡因子为1时，执行左右双旋
    旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。
     

    5.AVL树的验证

    5.1 验证其是否为二叉搜索树

    给一个序列进行一次中序遍历，看是否有序，有序即为二叉搜索树。

    1. void TestAVLTree1()
    2. {
    3. 	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
    4. 	AVLTree<int, int> t1;
    5. 	for (auto e : a)
    6. 	{
    7. 		t1.Insert({ e,e });
    8. 	}
    9.  
    10. 	t1.InOrder();
    11. }

    5.2 验证其是否为平衡树

    1. 	bool _IsBalance(Node* root)
    2. 	{
    3. 		if (root == nullptr)
    4. 		{
    5. 			return true;
    6. 		}
    7.  
    8. 		int leftHeight = _Height(root->_left);
    9. 		int rightHeight = _Height(root->_right);
    10.  
    11. 		//不平衡
    12. 		if (abs(leftHeight - rightHeight) >= 2)
    13. 		{
    14. 			cout << root->_kv.first << endl;
    15. 			return false;
    16. 		}
    17.  
    18. 		//顺便检查一下平衡因子是否正确
    19. 		if (rightHeight - leftHeight != root->_bf)
    20. 		{
    21. 			cout << root->_kv.first << endl;
    22. 			return false;
    23. 		}
    24.  
    25. 		return _IsBalance(root->_left)
    26. 			&& _IsBalance(root->right);
    27. 	}

    6.AVL树的删除（了解）

    因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

    7.AVL树的性能

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

     8.AVL树的整体模拟代码实现

    1. #pragma once
    2. #include
    3. using namespace std;
    4. #include
    5.  
    6. template<class K, class V>
    7. struct AVLTreeNode
    8. {
    9. 	AVLTreeNode* _left;	//该节点的左孩子
    10. 	AVLTreeNode* _right;	//该节点的右孩子
    11. 	AVLTreeNode* _parent;	//该节点的双亲
    12.  
    13. 	pair  _kv;	//该节点的key和value
    14.  
    15. 	int _bf; //balance factor 平衡因子
    16. 	AVLTreeNode(const pair& kv)	//该节点初始化
    17. 		:_left(nullptr)  
    18. 		, _right(nullptr)
    19. 		, _parent(nullptr)
    20. 		, _kv(kv)  
    21. 		, _bf(0)
    22. 	{}
    23. };
    24.  
    25. template<class K, class V>
    26. class 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. 		Node* parent = nullptr;
    38. 		Node* cur = _root;
    39. 		while (cur)
    40. 		{
    41. 			if (cur->_kv.first < kv.first)
    42. 			{
    43. 				parent = cur;
    44. 				cur = cur->_right;
    45. 			}
    46. 			else if (cur->_kv.first > kv.first)
    47. 			{
    48. 				parent = cur;
    49. 				cur = cur->_left;
    50. 			}
    51. 			else
    52. 			{
    53. 				return false;
    54. 			}
    55. 		}
    56.  
    57. 		cur = new Node(kv);
    58. 		if (parent->_kv.first < kv.first)
    59. 		{
    60. 			parent->_right = cur;
    61. 		}
    62. 		else
    63. 		{
    64. 			parent->_left = cur;
    65. 		}
    66. 		cur->_parent = parent;
    67.  
    68. 		//更新平衡因子
    69. 		while (parent)
    70. 		{
    71. 			if (cur == parent->_left)
    72. 			{
    73. 				parent->_bf--;
    74. 			}
    75. 			else
    76. 			{
    77. 				parent->_bf++;
    78. 			}
    79. 			if (parent->_bf == 0)
    80. 			{
    81. 				//更新结束
    82. 				break;
    83. 			}
    84. 			else if (parent->_bf == -1 || parent->_bf == 1)
    85. 			{
    86. 				//继续往上更新
    87. 				cur = parent;
    88. 				parent = parent->_parent;
    89. 			}
    90. 			else if (parent->_bf == -2 || parent->_bf == 2)
    91. 			{
    92. 				//当前子树出现了问题，需要旋转平衡一下
    93. 				if (parent->_bf == -2 && cur->_bf == -1)
    94. 				{
    95. 					//右单旋
    96. 					RotateR(parent);
    97. 				}
    98. 				else if (parent->_bf == 2 && cur->_bf == 1)
    99. 				{
    100. 					//左单旋
    101. 					RotateL(parent);
    102. 				}
    103. 				else if (parent->_bf == -2 && cur->_bf == 1)
    104. 				{
    105. 					//左右双旋
    106. 					RotateLR(parent);
    107. 				}
    108. 				else if (parent->_bf == 2 && cur->_bf == -1)
    109. 				{
    110. 					//右左双旋
    111. 					RotateRL(parent);
    112. 				}
    113. 				break;
    114. 			}
    115. 			else
    116. 			{
    117. 				//理论上不会出现这种情况，但仍要判断，大佬都不能保证自己的代码没有bug
    118. 				assert(false);
    119. 			}
    120.  
    121. 		}
    122. 		return true;
    123. 	}
    124. 	void RotateR(Node* parent)
    125. 	{
    126. 		Node* subL = parent->_left;
    127. 		Node* subLR = subL->_right;
    128. 		parent->_left = subLR;
    129. 		if (subLR)	//subLR有可能为空，不为空时才能调整subLR的父节点
    130. 			subLR->_parent = parent;
    131. 		subL->_right = parent;
    132. 		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
    133. 		Node* ppNode = parent->_parent;
    134. 		parent->_parent = subL;
    135.  
    136. 		if (parent == _root)
    137. 		{
    138. 			_root = subL;
    139. 			_root->_parent = nullptr;
    140. 		}
    141. 		else
    142. 		{
    143. 			if (ppNode->_left == parent)
    144. 			{
    145. 				ppNode->_left = subL;
    146. 			}
    147. 			else
    148. 			{
    149. 				ppNode->_right = subL;
    150. 			}
    151. 			subL->_parent = ppNode;
    152. 		}
    153. 		subL->_bf = parent->_bf = 0;
    154. 	}
    155. 	void RotateL(Node* parent)
    156. 	{
    157. 		Node* subR = parent->_right;
    158. 		Node* subRL = subR->_left;
    159. 		parent->_right = subRL;
    160. 		if (subRL)	//subRL有可能为空，不为空时才能调整subRL的父节点
    161. 			subRL->_parent = parent;
    162. 		subR->_left = parent;
    163. 		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
    164. 		Node* ppNode = parent->_parent;
    165. 		parent->_parent = subR;
    166.  
    167. 		if (parent == _root)
    168. 		{
    169. 			_root = subR;
    170. 			_root->_parent = nullptr;
    171. 		}
    172. 		else
    173. 		{
    174. 			if (ppNode->_left == parent)
    175. 			{
    176. 				ppNode->_left = subR;
    177. 			}
    178. 			else
    179. 			{
    180. 				ppNode->_right = subR;
    181. 			}
    182. 			subR->_parent = ppNode;
    183. 		}
    184. 		subR->_bf = parent->_bf = 0;
    185. 	}
    186. 	void RotateLR(Node* parent)
    187. 	{
    188. 		Node* subL = parent->_left;
    189. 		Node* subLR = subL->_right;
    190.  
    191. 		int bf = subLR->_bf;
    192.  
    193. 		RotateL(parent->_left);
    194. 		RotateR(parent);
    195.  
    196. 		if (bf == 0)
    197. 		{
    198. 			subL->_bf = 0;
    199. 			subLR->_bf = 0;
    200. 			parent->_bf = 0;
    201. 		}
    202. 		else if (bf == -1)
    203. 		{
    204. 			subL->_bf = 0;
    205. 			subLR->_bf = 0;
    206. 			parent->_bf = 1;
    207. 		}
    208. 		else if (bf == 1)
    209. 		{
    210. 			subL->_bf = -1;
    211. 			subLR->_bf = 0;
    212. 			parent->_bf = 0;
    213. 		}
    214. 		else
    215. 		{
    216. 			//理论上不会出现的情况
    217. 			assert(false);
    218. 		}
    219. 	}
    220. 	void RotateRL(Node* parent)
    221. 	{
    222. 		Node* subR = parent->_right;
    223. 		Node* subRL = subR->_left;
    224.  
    225. 		int bf = subRL->_bf;
    226.  
    227. 		RotateR(parent->_right);
    228. 		RotateL(parent);
    229.  
    230. 		if (bf == 0)
    231. 		{
    232. 			parent->_bf = 0;
    233. 			subRL->_bf = 0;
    234. 			subR->_bf = 0;
    235. 		}
    236. 		else if (bf == -1)
    237. 		{
    238. 			parent->_bf = 0;
    239. 			subRL->_bf = 0;
    240. 			subR->_bf = 1;
    241. 		}
    242. 		else if (bf == 1)
    243. 		{
    244. 			parent->_bf = -1;
    245. 			subRL->_bf = 0;
    246. 			subR->_bf = 0;
    247. 		}
    248. 		else
    249. 		{
    250. 			//理论上不会出现的情况
    251. 			assert(false);
    252. 		}
    253. 	}
    254. 	Node* Find(const K& key)
    255. 	{
    256. 		Node* cur = _root;
    257. 		while (cur)
    258. 		{
    259. 			if (cur->_kv.first < key)
    260. 			{
    261. 				cur = cur->_right;
    262. 			}
    263. 			else if (cur->_kv.first > key)
    264. 			{
    265. 				cur = cur->_left;
    266. 			}
    267. 			else
    268. 			{
    269. 				return cur;
    270. 			}
    271. 		}
    272.  
    273. 		return nullptr;
    274. 	}
    275.  
    276.  
    277. 	void InOrder()
    278. 	{
    279. 		_InOrder(_root);
    280. 		cout << endl;
    281. 	}
    282. 	bool IsBalance()
    283. 	{
    284. 		return _IsBalance(_root);
    285. 	}
    286. 	int Height()
    287. 	{
    288. 		return _Height(_root);
    289. 	}
    290.  
    291. 	int Size()
    292. 	{
    293. 		return _Size(_root);
    294. 	}
    295. private:
    296. 	int _Size(Node* root)
    297. 	{
    298. 		return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
    299. 	}
    300. 	int _Height(Node* root)
    301. 	{
    302. 		if (root == nullptr)
    303. 		{
    304. 			return 0;
    305. 		}
    306. 		return max(_Height(root->_left), _Height(root->_right)) + 1;
    307. 	}
    308. 	bool _IsBalance(Node* root)
    309. 	{
    310. 		if (root == nullptr)
    311. 		{
    312. 			return true;
    313. 		}
    314.  
    315. 		int leftHeight = _Height(root->_left);
    316. 		int rightHeight = _Height(root->_right);
    317.  
    318. 		//不平衡
    319. 		if (abs(leftHeight - rightHeight) >= 2)
    320. 		{
    321. 			cout << root->_kv.first << endl;
    322. 			return false;
    323. 		}
    324.  
    325. 		//顺便检查一下平衡因子是否正确
    326. 		if (rightHeight - leftHeight != root->_bf)
    327. 		{
    328. 			cout << root->_kv.first << endl;
    329. 			return false;
    330. 		}
    331.  
    332. 		return _IsBalance(root->_left)
    333. 			&& _IsBalance(root->_right);
    334. 	}
    335. 	void _InOrder(Node* root)
    336. 	{
    337. 		if (root == nullptr)
    338. 		{
    339. 			return;
    340. 		}
    341.  
    342. 		_InOrder(root->_left);
    343. 		cout << root->_kv.first << ":" << root->_kv.second << endl;
    344. 		_InOrder(root->_right);
    345. 	}
    346. 	Node* _root = nullptr;
    347. };
    348.  
    349. void TestAVLTree1()
    350. {
    351. 	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
    352. 	AVLTree<int, int> t1;
    353. 	for (auto e : a)
    354. 	{
    355. 		t1.Insert({ e,e });
    356. 	}
    357.  
    358. 	t1.InOrder();
    359. }
    360. void TestAVLTree2()
    361. {
    362. 	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
    363. 	AVLTree<int, int> t1;
    364. 	for (auto e : a)
    365. 	{
    366. 		t1.Insert({ e,e });
    367. 	}
    368. 	t1.InOrder();
    369. 	cout << t1.IsBalance() << endl;
    370. }

  • 相关阅读:
    CodeForces-1324F Maximum White Subtree（换根dp 联通子图信息查询）
    Hudi从内核到实战介绍
    【JavaWeb】手写一个Servlet+JSP+JavaBean分页
    docker --link容器互联
    6.5 - 万维网
    ts学习笔记
    python末尾逗号导致返回结果是一个元组
    一图看懂，阿里云飞天企业版如何支持政企数智创新
    使用mindspore提供的docker运行官方示例resnet_thor，训练速度非常慢
    2022年数维杯国际大学生数学建模挑战赛D题三重拉尼娜事件下极端气候灾害损失评估与应对策略研究解题过程
  • 原文地址：https://blog.csdn.net/2301_78611726/article/details/139009541