• 数据结构-红黑树

    目录

    红黑树的概念及结构

    概念

    结构

    红黑树的插入

    红黑树的删除

    判断是否为红黑树

    最长路径

    最短路径

    红黑树的概念及结构

    概念

       红黑树也是一种二叉排序树，在红黑树中每个结点存储着对应的颜色(红色或者黑色)，由于AVL树的高度平衡是因为非常频繁地调用旋转来保存自身平衡的，代价较大。所以在AVL树的基础上进一步放宽条件，引入红黑树，即红黑树的最长路径不会比最短路径长两倍。861ef3c37a0342e98eeef6fa481c144a.png一棵红黑树需要满足以下性质才能保证最长路径不会超过最短路径的两倍：

    1，根结点必须是黑色，其他结点不是黑色就是红色

    2，红色结点的双亲结点与孩子结点都是黑色的，也就是不会存在两个相邻的红色结点

    3，对于每一个结点，从该结点到任一叶结点的路径上，每条路径上的黑色结点数量相同

    4，空结点为黑色

    通过上面的性质可以得出一些结论：

    1，最短路径上的结点都是黑色的，而最长路径上的结点一黑一红交替

    2，若一棵红黑树有n个结点则红黑树的高度为h <= 2*log(2) (n+1)

    3，在红黑树中，对于红色结点其出度只能为0或者2

    4，在红黑树中，如果黑色结点只有一个孩子结点，则该孩子结点只能为红色

    结构

       红黑树的链式结构依然用三叉链，红黑树的每一个结点都存储着左孩子结点地址，右孩子结点地址，双亲结点地址，KeyValue数据以及结点的颜色。61f0d7ec94054dbca084b24f3c58505d.png

       新开辟的结点默认选择是红色的：假设新插入的结点默认是黑色的，那么这个结点所在的路径会比其他路径多一个黑色的结点，会破坏性质3，调整起来很麻烦。如果插入的结点默认是红色的，所有路径上的黑色结点数量依然相同，如果插入结点的双亲是黑色的则不需要处理直接结束插入，如果插入结点的双亲是红色的则破坏性质2需要处理。所以选择新插入的结点为红色的代价小。

    红黑树的插入

       红黑树的插入思路与二叉搜索树的插入相同，只不过红黑树需要在插入新结点之后，判断插入之后有没有违反红黑树的性质。如果没有违反则插入成功，否则需要进行修复使之平衡。

    第一步：找到新结点的插入位置，并记录新结点的双亲位置

    b4f3707083fb4c399c66eea789bdc451.png

    第二步：进行插入，如果新结点小于双亲则往左插入，如果新结点大于双亲则往右插入 

    aad613ff33844b7798f9983469add35a.png

    第三步：判断是否需要修复，如果双亲结点的颜色为黑色则不需要修复，如果双亲结点的颜色为红色则需要修复 

    当双亲的颜色为红色时，需要进行修复，而修复的方法分为两种，这两种方法是根据其插入结点的叔叔来决定的。

    1，当叔叔存在并且为红时，进行调色然后继续往上处理------祖父变为红色，双亲与叔叔变为黑色4581c0c9b5d44f47b27a856425291217.pngf69793fe786a478aac127c550a53bf8c.png2，当叔叔不存在或者叔叔的颜色为黑，需要进行旋转与调色处理------（1，双亲是祖父的左孩子并且新插入结点是双亲的左孩子，进行祖父右旋转并将祖父变为红，双亲变为黑。（2，双亲是祖父的左孩子并且新插入结点是双亲的右孩子，进行双亲左旋转祖父右旋转，并将祖父变红，新插入结点变黑。（3，双亲是祖父的右孩子并且新插入结点是双亲的右孩子，进行祖父左旋转并将祖父变为红色，双亲变为黑色。（4，双亲是祖父的右孩子并且新插入结点是双亲的左孩子，进行双亲右旋转祖父左旋转，并将祖父变为红色，新插入结点变为黑色。

    0fd09119b03b430d9affbdca5155d0ad.png6b0e0177fc6f4f8e9a17762fd92cdf02.png

    1. // 旋转代码
    2.  
    3.     //右旋转
    4. 	void RotateR(Node* root)
    5. 	{
    6. 		Node* subL = root->_left;
    7. 		Node* subLR = subL->_right;
    8. 		Node* rootParent = root->_parent;
    9.  
    10. 		subL->_right = root;
    11. 		root->_parent = subL;
    12.  
    13. 		root->_left = subLR;
    14. 		if (subLR)
    15. 		{
    16. 			subLR->_parent = root;
    17. 		}
    18.  
    19. 		if (rootParent == nullptr)
    20. 		{
    21. 			_root = subL;
    22. 			subL->_parent=nullptr;
    23. 		}
    24. 		else
    25. 		{
    26. 			if (rootParent->_left == root)
    27. 			{
    28. 				rootParent->_left = subL;
    29. 			}
    30. 			else if (rootParent->_right == root)
    31. 			{
    32. 				rootParent->_right = subL;
    33. 			}
    34. 			subL->_parent = rootParent;
    35. 		}
    36. 	}
    37.  
    38. 	// 左旋转
    39. 	void RotateL(Node* root)
    40. 	{
    41. 		Node* subR = root->_right;
    42. 		Node* subRL = subR->_left;
    43. 		Node* rootParent = root->_parent;
    44. 		subR->_left = root;
    45. 		root->_parent = subR;
    46.  
    47. 		root->_right = subRL;
    48. 		if (subRL)
    49. 		{
    50. 			subRL->_parent = root;
    51. 		}
    52.  
    53. 		if (rootParent == nullptr)
    54. 		{
    55. 			_root = subR;
    56. 			subR->_parent = nullptr;
    57. 		}
    58. 		else
    59. 		{
    60. 			if (rootParent->_left == root)
    61. 			{
    62. 				rootParent->_left = subR;
    63. 			}
    64. 			else if (rootParent->_right == root)
    65. 			{
    66. 				rootParent->_right = subR;
    67. 			}
    68. 			subR->_parent = rootParent;
    69. 		}
    70. 	}

    最后将根结点的颜色变为黑色。54c1932186a942eb924e73aed1801a8d.png

    1.     pairbool> Insert(const pair& kv)
    2. 	{
    3. 		if (_root == nullptr) // 根结点为空，直接插入
    4. 		{
    5. 			_root = new Node(kv); // 新结点的地址给_root记录
    6. 			_root->_parent = nullptr; // 根结点的双亲为空
    7. 			_root->_colour = BLACK; // 根结点颜色变为黑色
    8. 			return make_pair(_root, true); // 返回成功插入的结点
    9. 		}
    10.  
    11. 		Node* parent = nullptr; // 记录插入位置的双亲结点
    12. 		Node* curr = _root; // 寻找插入的位置
    13.  
    14. 		while (curr) // curr为空表示找到了插入的位置
    15. 		{
    16. 			if (curr->_kv.first > kv.first) // 往左寻找
    17. 			{
    18. 				parent = curr;
    19. 				curr=curr->_left;
    20. 			}
    21. 			else if (curr->_kv.first < kv.first) // 往右寻找
    22. 			{
    23. 				parent = curr;
    24. 				curr = curr->_right;
    25. 			}
    26. 			else // 已经有对应数据的结点，插入失败
    27. 			{
    28. 				return make_pair(curr, false); // 返回已经有对应数据的结点
    29. 			}
    30. 		}
    31. 		
    32. 		Node* newNode = new Node(kv); // 开辟红色新结点，开始插入
    33.  
    34. 		if (parent->_kv.first > kv.first) // 比双亲小，往左边插入
    35. 		{
    36. 			parent->_left = newNode;
    37. 		}
    38. 		else if(parent->_kv.first// 比双亲大，往右边插入
    39. 		{
    40. 			parent->_right = newNode;
    41. 		}
    42. 		newNode->_parent = parent; // 让新结点的_parent指向双亲
    43.  
    44. 		curr = newNode; // curr为新插入的结点，parent为新插入结点的双亲
    45.  
    46. 		while (parent && parent->_colour == RED) // 如果新插入结点的双亲为红色则需要调整
    47. 		{
    48. 			Node* grandFather = parent->_parent; // 红色结点一定有双亲
    49.  
    50. 			if (grandFather->_left == parent) // 叔叔是祖父的右孩子
    51. 			{
    52. 				Node* uncle = grandFather->_right;
    53.  
    54. 				if (uncle && uncle->_colour == RED) // 叔叔存在而且颜色为红
    55. 				{
    56. 					//双亲与叔叔颜色变黑
    57. 					parent->_colour = uncle->_colour = BLACK; 
    58. 					grandFather->_colour = RED; // 祖父颜色变红
    59.  
    60. 					// 迭代
    61. 					curr = grandFather;
    62. 					parent = curr->_parent;
    63. 				}
    64. 				else // 叔叔不存在或者叔叔颜色为黑
    65. 				{
    66. 					if (parent->_left == curr) // 左左---右单选
    67. 					{
    68. 						RotateR(grandFather); // 旋转祖父
    69. 						grandFather->_colour = RED;
    70. 						parent->_colour = BLACK;
    71. 					}
    72. 					else // 左右---左右双旋
    73. 					{
    74. 						RotateL(parent); // 先旋转双亲
    75. 						RotateR(grandFather); // 再旋转祖父
    76. 						grandFather->_colour = RED; // 祖父变红
    77. 						curr->_colour = BLACK; // 新插入的结点变黑
    78. 					}
    79. 					break;
    80. 				}
    81.  
    82. 			}
    83. 			else if(grandFather->_right==parent) // 叔叔是祖父的左孩子
    84. 			{
    85. 				Node* uncle = grandFather->_left;
    86.  
    87. 				if (uncle && uncle->_colour== RED) // 叔叔存在而且颜色为红 
    88. 				{
    89. 					// 调色加继续向上处理
    90. 					parent->_colour = uncle->_colour = BLACK;
    91. 					grandFather->_colour = RED;
    92.  
    93. 					// 迭代
    94. 					curr = grandFather;
    95. 					parent = curr->_parent;
    96. 				}
    97. 				else // 叔叔不存在或者叔叔颜色为黑
    98. 				{
    99. 					// 调色加旋转，结束处理
    100. 					if (parent->_right == curr) // 右右---左单选
    101. 					{
    102. 						RotateL(grandFather);
    103. 						grandFather->_colour = RED;
    104. 						parent->_colour = BLACK;
    105. 					}
    106. 					else // 右左---右左双旋
    107. 					{
    108. 						RotateR(parent);
    109. 						RotateL(grandFather);
    110. 						grandFather->_colour = RED;
    111. 						curr->_colour = BLACK;
    112. 					}
    113. 					break;
    114. 				}
    115. 			}
    116. 		}
    117.  
    118. 		_root->_colour = BLACK; // 将根结点变为黑色
    119. 		return make_pair(newNode, true); // 插入成功，返回插入结点
    120. 	}

    红黑树的删除

    第一步：找到要删除的结点

    cda0b1072d9447d3b3faffb6838a73ad.png

    第二步：按照要删除结点的类型进行分类删除：1，左子树为空   2，右子树为空   3，左右子树都为空   4，左右子树都不为空

    第三步：在删除之前，根据删除结点的特征与颜色进行调整

    1，如果删除的结点是红色

    可以直接删除，不会影响红黑树的特性

    2，如果删除的结点是黑色，并且有一个孩子结点（孩子结点一定是红色）

    则将该黑色结点删除，并将该孩子结点变黑交给双亲托管

    3，如果删除的结点是黑色，并且兄弟结点是黑色，其远侄子是红色

    交换双亲与兄弟的颜色，并且将远侄子的颜色变为黑色，双亲进行一次单旋转（删除结点在双亲的左进行左旋转；删除结点在双亲的右进行右旋转）；完成之后3特征结束

    a75f8274c0f1418a9ca217b0912c919d.png664f07002d004c9ea61c3b6ae52cd45f.png5b26a6be719540ee9309e065847b0098.png

    4，如果删除结点是黑色，并且兄弟结点是黑色，近侄子是红色，远侄子是黑色

    兄弟与近侄子交换颜色，然后对兄弟做一次单旋转（删除结点在双亲的左进行右旋转；删除结点在双亲的右进行左旋转）；完成之后4特征变为3特征继续

    2bce04dc8fbe44f38a9fd94e4dd412f9.pngaf3c11f25c1747f0b9d73f304ca896de.pngdb552dbc9bd34fe9b31d15fedd4b78d8.png

    5，如果删除的结点是黑色，并且兄弟结点的颜色是红色

    交换双亲与兄弟的颜色，然后对双亲做一次单旋转（删除结点在双亲的左进行左旋转；删除结点在双亲的右进行右旋转）这样完成之后5特征变为3特征或者4特征孩子6特征继续

    3ffeb56cb1eb42e89da8731fd7d48def.png

    6，如果删除的结点是黑色，兄弟结点是黑色并且其左右孩子都是黑色（左右孩子可以为空）

    将兄弟结点变为红色，紧接着判断双亲是否为根结点或者是否为红色，如果成立调整结束，如果不成立将child变为parent，parent变为child->_parent继续往上一层调整

    ddad1a7d3fd04bedaaa1ec1936b49764.png

    de1f64a09e5b4db598288b6bb8d07916.png

    要删除的结点只能也只有这样的特征，其他特征都不存在。

    5df36dee868b4371b126eab2ce3b9b73.png

    1. void UpdateB(Node* child, Node* parent)
    2. 	{
    3. 		if (child->_colour == RED) // 删除结点为红色
    4. 		{
    5. 			return;
    6. 		}
    7.  
    8. 		if (child->_colour==BLACK) // 删除结点为黑色并且有一个孩子
    9. 		{
    10. 			if (child->_left && child->_left->_colour==RED)
    11. 			{
    12. 				child->_left->_colour = BLACK;
    13. 				return;
    14. 			}
    15. 			else if (child->_right && child->_right->_colour==RED)
    16. 			{
    17. 				child->_right->_colour = BLACK;
    18. 				return;
    19. 			}
    20. 		}
    21.  
    22. 		while (child!=_root) // 删除结点为黑色没有孩子
    23. 		{	
    24. 			if (child == parent->_left)
    25. 			{
    26. 				Node* brother = parent->_right;
    27. 				Node* nephewL = brother->_left;
    28. 				Node* nephewR = brother->_right;
    29.  
    30. 				if (brother->_colour == BLACK && nephewR && nephewR->_colour == RED)
    31. 				{
    32. 					// 父亲与兄弟结点的颜色互换
    33. 					COLOUR tmp = brother->_colour;
    34. 					brother->_colour = parent->_colour;
    35. 					parent->_colour = tmp;
    36.  
    37. 					nephewR->_colour = BLACK; // 兄弟的右孩子换成黑色
    38.  
    39. 					RotateL(parent); // 父亲左旋转
    40.  
    41. 					return;
    42. 				}
    43. 				else if (brother->_colour == BLACK && nephewL && nephewL->_colour == RED)
    44. 				{
    45. 					// 兄弟与兄弟左孩子结点的颜色互换
    46. 					COLOUR tmp = brother->_colour;
    47. 					brother->_colour = nephewL->_colour;
    48. 					nephewL->_colour = tmp;
    49. 					// 兄弟右旋转
    50. 					RotateR(brother);
    51. 				}
    52. 				else if (brother->_colour == BLACK
    53. 					&& (nephewL == nullptr || nephewL->_colour == BLACK) 
    54. 					&& (nephewR == nullptr || nephewR->_colour == BLACK))
    55. 				{
    56. 					brother->_colour = RED;
    57. 					if (parent == _root || parent->_colour == RED)
    58. 					{
    59. 						parent->_colour = BLACK;
    60. 						return;
    61. 					}
    62. 					//向上调整
    63. 					child = parent;
    64. 					parent = child->_parent;
    65. 				}
    66. 				else if (brother->_colour == RED)
    67. 				{
    68. 					// 父亲与兄弟结点的颜色互换
    69. 					COLOUR tmp = brother->_colour;
    70. 					brother->_colour = parent->_colour;
    71. 					parent->_colour = tmp;
    72. 					RotateL(parent);
    73. 				}
    74. 			}
    75. 			else if(child==parent->_right)
    76. 			{
    77. 				Node* brother = parent->_left;
    78. 				Node* nephewL = brother->_left;
    79. 				Node* nephewR = brother->_right;
    80.  
    81. 				if (brother->_colour == BLACK && nephewL && nephewL->_colour == RED)
    82. 				{
    83. 					// 父亲与兄弟结点的颜色互换
    84. 					COLOUR tmp = brother->_colour;
    85. 					brother->_colour = parent->_colour;
    86. 					parent->_colour = tmp;
    87.  
    88. 					nephewL->_colour = BLACK; // 兄弟的左孩子换成黑色
    89.  
    90. 					RotateR(parent); // 父亲右旋转
    91.  
    92. 					return;
    93. 				}
    94. 				else if (brother->_colour == BLACK && nephewR && nephewR->_colour == RED)
    95. 				{
    96. 					// 兄弟与兄弟右孩子结点的颜色互换
    97. 					COLOUR tmp = brother->_colour;
    98. 					brother->_colour = nephewR->_colour;
    99. 					nephewR->_colour = tmp;
    100. 					// 兄弟左旋转
    101. 					RotateL(brother);
    102. 				}
    103. 				else if (brother->_colour == BLACK 
    104. 					&& (nephewL == nullptr || nephewL->_colour == BLACK) 
    105. 					&& (nephewR == nullptr || nephewR->_colour == BLACK))
    106. 				{
    107. 					brother->_colour = RED;
    108. 					if (parent == _root || parent->_colour == RED)
    109. 					{
    110. 						parent->_colour = BLACK;
    111. 						return;
    112. 					}
    113. 					//向上调整
    114. 					child = parent;
    115. 					parent = child->_parent;
    116. 				}
    117. 				else if (brother->_colour == RED)
    118. 				{
    119. 					// 父亲与兄弟结点的颜色互换
    120. 					COLOUR tmp = brother->_colour;
    121. 					brother->_colour = parent->_colour;
    122. 					parent->_colour = tmp;
    123. 					RotateR(parent);
    124. 				}
    125. 			}
    126.  
    127. 			
    128. 		}
    129. 		
    130. 	}
    131.  
    132. 	bool Erase(const K& key)
    133. 	{
    134. 		if (_root == nullptr) // 红黑树为空不需要删除
    135. 		{
    136. 			return false;
    137. 		}
    138.  
    139. 		Node* parent = nullptr;
    140. 		Node* curr = _root;
    141.  
    142. 		while (curr)
    143. 		{
    144. 			if (curr->_kv.first > key) // 往左寻找
    145. 			{
    146. 				parent = curr;
    147. 				curr = curr->_left;
    148. 			}
    149. 			else if(curr->_kv.first// 往右寻找
    150. 			{
    151. 				parent = curr;
    152. 				curr = curr->_right;      
    153. 			}
    154. 			else // 找到了开始删除
    155. 			{
    156. 				if (curr->_left == nullptr) // 删除结点的左孩子为空
    157. 				{
    158. 					if (curr == _root) // 删除的是根结点
    159. 					{
    160. 						_root = curr->_right;
    161. 						if (_root)
    162. 						{
    163. 							_root->_parent = nullptr;
    164. 							_root->_colour = BLACK;
    165. 						}
    166. 					}
    167. 					else // 删除的不是根结点
    168. 					{
    169. 						UpdateB(curr, parent); // 删除之前进行调整
    170.  
    171. 						if (parent->_left == curr)
    172. 						{
    173. 							parent->_left = curr->_right;
    174. 						}
    175. 						else
    176. 						{
    177. 							parent->_right = curr->_right;
    178. 						}	
    179.  
    180. 						if (curr->_right)
    181. 						{
    182. 							curr->_right->_parent = parent;
    183. 						}	
    184. 					}
    185. 					delete curr;
    186. 					return true;
    187. 				}
    188. 				else if (curr->_right == nullptr) // 删除结点的右孩子为空
    189. 				{
    190. 					if (curr == _root) // 删除的是根结点
    191. 					{
    192. 						_root = curr->_left;
    193. 						if (_root)
    194. 						{
    195. 							_root->_parent = nullptr;
    196. 							_root->_colour = BLACK;
    197. 						}		
    198. 					}
    199. 					else // 删除的不是根结点
    200. 					{
    201. 						UpdateB(curr, parent); // 删除之前进行判断调整
    202.  
    203. 						if (parent->_left == curr)
    204. 						{
    205. 							parent->_left = curr->_left;
    206. 						}
    207. 						else
    208. 						{
    209. 							parent->_right = curr->_left;
    210. 						}
    211.  
    212. 						if (curr->_left)
    213. 						{
    214. 							curr->_left->_parent = parent;
    215. 						}
    216. 					}
    217. 					delete curr;
    218. 					return true;
    219. 				}
    220. 				else // 删除结点的左右孩子都不空，进行替换删除
    221. 				{
    222. 					Node* min = curr->_right;
    223. 					while (min->_left)
    224. 					{
    225. 						min = min->_left;
    226. 					}
    227. 					pair tmp = min->_kv;
    228. 					Erase(tmp.first);
    229. 					curr->_kv = tmp;
    230. 					return true;
    231. 				}
    232. 			}
    233. 		}
    234. 		return false;
    235. 	}

    判断是否为红黑树

       判断一棵树是否为红黑树只需要验证这颗树是否满足红黑树的性质

    07005b5157be4513ac1fd1e1eaf2e238.png

    1. bool IsRedBlackTree()
    2. 	{
    3. 		Node* pRoot = _root;
    4. 		// 空树也是红黑树
    5. 		if (nullptr == pRoot)
    6. 			return true;
    7.  
    8. 		// 检测根节点是否满足情况
    9. 		if (BLACK != pRoot->_colour)
    10. 		{
    11. 			return false;
    12. 		}
    13.  
    14. 		int blackcount = 0; // 先计算一条路径上的黑色数量为基准
    15. 		Node* curr = _root;
    16. 		while (curr)
    17. 		{
    18. 			if (curr->_colour==BLACK)
    19. 			{
    20. 				blackcount++;
    21. 			}
    22. 			curr = curr->_left;
    23. 		}
    24.  
    25. 		return _IsRedBlackTree(_root, 0, blackcount);
    26. 	}

    最长路径

    1.     int _maxHeight(Node* root)
    2. 	{
    3. 		if (root == nullptr)
    4. 			return 0;
    5.  
    6. 		int lh = _maxHeight(root->_left);
    7. 		int rh = _maxHeight(root->_right);
    8.  
    9. 		return lh > rh ? lh + 1 : rh + 1;
    10. 	}

    最短路径

    1.     int _minHeight(Node* root)
    2. 	{
    3. 		if (root == nullptr)
    4. 			return 0;
    5.  
    6. 		int lh = _minHeight(root->_left);
    7. 		int rh = _minHeight(root->_right);
    8.  
    9. 		return lh < rh ? lh + 1 : rh + 1;
    10. 	}

     

  • 相关阅读:
    想裁剪视频时长，用电脑怎么裁剪视频时长
    docker 常用命令整理
    C#学习记录——网络编程基础
    【C++从0到王者】第二十八站：二叉搜索树的应用
    【Java项目】如何设计一个用户签到系统？并且这个签到系统支持7天，14天等不同天数的连续签到功能？
    Matlab optimtool优化阵列天线的幅相激励
    强化学习环境 - robogym - 学习 - 1
    记一次由于google新版本限制升级导致的跨域问题
    springBoot的转发和重定向
    【Elasticsearch＜一＞✈️✈️】简单安装使用以及各种踩坑
  • 原文地址：https://blog.csdn.net/m0_61433144/article/details/126401073