• 带你10分钟学会红黑树

    前言：

         我们都知道二叉搜索树，是一种不错的用于搜索的数据结构，如果二叉搜索树越接近完全二叉树，那么它的效率就会也高，但是它也存在的致命的缺陷，在最坏的情况下，二叉搜索树会退化成为单链表，这时，二叉搜索树也就丧失了它的搜索能力。因此为了解决它的问题，后面就有人提出了两种改进结构AVL树和红黑树，让我们一起来学习一下其中的一种改进方案：红黑树吧！

    目录

    1.什么是红黑树

    2.红黑树的特点

    3.红黑树的模拟实现

            3.1红黑树的节点结构

            3.2红黑色的插入操作

            3.3红黑色的验证

            3.4红黑树的查找

            3.5红黑树的删除 

                    3.5.1删除详解 

                    3.5.2删除的代码实现 

             3.6测试代码

            3.7全部代码 

    4.红黑树与AVL树的比较  

    5.红黑树的应用

            3.2红黑色的插入操作

            3.3红黑色的验证

            3.4红黑树的查找

    4.红黑色与AVL树的比较  

    5.红黑色的应用

    1.什么是红黑树

             红黑树实际上就是一种二叉搜索树，但在每个节点上都增加了一个存储位表示节点的颜色，可以是red或者black。通过对任意一条从根节点到叶子节点的路径上各个节点着色方式的限定，红黑树确保没有一条路径比其它路径长出两倍。因而是接近平衡的。

            一颗二叉搜书树，越平衡搜索时效率就越高，显然红黑色的平衡性要比AVL树略差，但是经过大量的实验证明红黑色的效率还是不错的，仍能达到O(logN)，这个我也不是特别了解只是在别的树上看到的，我没有做过这种类似的大量的实验来证明它的性能，总之：虽然红黑树不是严格的平衡树，但是它的效率也是很高的，不管怎么样你要知道它的时间复杂度是小于2O(logN) !

    2.红黑树的特点

            1.每个节点不是红色就是黑色

            2.根节点是黑色

            3.如果一个节点是红色，那么它的两个孩子是黑色

            4.对于每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点。   

            5.每个叶子节点都是黑色的（此处的叶子节点指的是空节点） 

            一共有五条，但是归结起来就三点：1.根节点是黑色的，2.没有连续的红色节点，3. 叶子节点（空节点）是黑色的。

             咋一看红黑树怎么这么多要求呢，看的人头都是晕的，简单来分析一下，首先每个节点都存在两种颜色，或者是红色或者是黑色，凡是空节点都是黑色的也就是这里说的叶子节点。根节点是黑色的。这第1,2,5看起来还好理解，第3,4就不是很好理解了。第3：说明红色节点是不连续的，而第4：说明每个路径上面的黑色节点是相同的，比如：从根开始到1这个节点到叶子节点的黑色节点的个数是和过6这个节点到叶子节点的黑色节点的个数是相同的都是3个。因为如果满足上述的这些条件，那么就可以保证最长路径上的节点个数不会超过最短路径上的节点个数的两倍。

            它是如何保证的最长路径是小于等于最短路径的呢？因为叶子节点是黑色的，根节点也是黑色的，且没有连续的红色节点，那么最长的路径一定是黑红相间的，而最短的路径一定是都是由黑色节点组成的。 每条路径上黑色节点的个数是相同的，那么最长路径的节点数减去最短路径的节点数一定是最长路径上红色节点的个数，在上述的种种规定下，一条路径上的红色节点数一定是小于等于黑色节点的个数的，所以就保证了，最长路径上一定小于或者等于2倍的最短路径。

    3.红黑树的模拟实现

           实现红黑树，对于平衡树的旋转操作是必须要了解的，所以如果对平衡树的旋转不了解的同学建议先话三分钟了解一下平衡树  的旋转。（剩下的6分钟应该还是可以学会红黑树的...）

            3.1红黑树的节点结构

                   红黑树是二叉搜索树的结构，它的每个节点都是由节点存储的值，节点的指针和表示节点的颜色的枚举类型组成的。且树的结构是三叉链，这样结构方便从子节点逆着寻找父节点。

    当然还可以有其它的实现方式。 

    1.     //红黑树的节点有两种状态
    2. 	//RED-BLACK
    3. 	enum Colour
    4. 	{
    5. 		BLACK,
    6. 		RED,
    7. 	};
    8. 	template<class K,class V>
    9. 	struct RBTreeNode
    10. 	{
    11. 		//红黑色是三叉链
    12. 		//+节点的状态+存储在节点中的指针
    13. 		RBTreeNode _left;
    14. 		RBTreeNode _right;
    15. 		RBTreeNode _prev;
    16.  
    17. 		pair _Key;
    18. 		Colour _col;
    19. 		//构造函数
    20. 		RBTreeNode(const pair data)
    21. 			:_left(nullptr)
    22. 			,_right(nullptr)
    23. 			,_prev(nullptr)
    24. 			,_Key(data)
    25. 			,_col(RED)
    26. 		{ }
    27. 	};

            3.2红黑色的插入操作

             由于性质的约束，红黑色新插入的节不点可以是黑色的，红黑树新插入的节点都是红色的为什么呢？如果新插入点节点是黑色的会破坏第4点性质，破坏后是不容易修正的，但是如果插入的节点是红色的节点，这时候如果它的父节点是红色的就破坏了第3点性质，所以这时候就要通过一些旋转和节点的变色来进行处理，使得它满足第3点性质。简而言之就是如果插入的是黑色的节点是一定会破坏的第4点的，插入的是红色的节点只是有可能会破坏第3点，并且要保证每条路径上有相同数量的黑色节点是不太容易的，而让红色的节点不连续是比较简单的，两害相权取其轻，所以在插入时选择插入红色的节点。以下我将会列出所出现的所有情况。另外为了叙述方便我们给新插入的节点标为C，父节点为P，祖父节点为G，叔叔节点为U。

           

            情况1：树为空，此时需要将根节点赋值给新插入的节点，并且将根节点的颜色变黑，（恢复第1点性质）。

            情况2：插入节点后，这个节点的父节点是黑色的，此时不需要处理。结束插入。

            前面两种其实没有什么好看的，因为很简单，需要注意的是接下来的三种。

            情况3：插入节点后，C为红，P为红，如果U为红，此时G一定存在且为黑（不然在插入之前就不符合红黑色的特点了），这种情况一定破坏第三点，需要将P和U变为黑色，G变为红色，然后继续进行判断属于哪种情况，这种状态不需要旋转只要进行变色处理就可以了。 

            情况四：C为红，P为红，U不存在或者U为黑。C为P的左孩子，且P为G左孩子（或者C为P的右孩子，且P为G右孩子，总之是同向的），这时候进行右单旋（左单旋）。然后将P变为黑色，G变为红色就结束了。如图：

            情况五：C为红，P为红，U不存在或者U为黑。C为P的左孩子，P是G的右孩子（或者C为P的右孩子，P为G的左孩子，总之它们是反向的），这时候进行进行两次变化操作，首先在P的位置进行左旋，这时候不变节点的颜色，（这时候实际上已经转换为情况4，按照情况4 的操作就行）然后再G的位置进行右旋，将G变为红色，将C变为黑色。

            如图：        实际上由于P，C都为红色，旋转1次后，不违反第4点性质。然后就变为情景4.

             插入节点后检测是否破坏红黑树的性质。 显然情况1,2是没有破坏红黑树的性质的。只有情况3,4,5破坏了红黑树的性质。

            实现代码：

    1. 	    bool Insert(const V& data)
    2. 		{
    3. 			//如果根节点为空直接插入并初始化根节点
    4. 			if (_root == nullptr)
    5. 			{
    6. 				_root = new Node(data);
    7. 				_root->_col = BLACK;//将根节点变黑
    8. 			}
    9. 			Node* cur = _root;
    10. 			Node* parent = nullptr;
    11. 			while (cur)
    12. 			{
    13. 				//新插入的节点都是红色的，
    14. 				if (cur->_data == data)
    15. 				{
    16. 					//节点中存在data不需要进行插入
    17. 					return false;
    18. 				}
    19. 				else if (data > cur->_data)
    20. 				{
    21. 					parent = cur;
    22. 					cur = cur->_right;
    23. 				}
    24. 				else if (data < cur->_data)
    25. 				{
    26. 					parent = cur;
    27. 					cur = cur->_left;
    28. 				}
    29. 			}
    30. 			//申请新节点进行插入
    31. 			cur = new Node(data);
    32. 			cur->_parent = parent;
    33. 			cur->_col = RED;
    34. 			if (cur->_data > parent->_data)
    35. 			{
    36. 				parent->_right = cur;
    37. 			}
    38. 			else
    39. 			{
    40. 				parent->_left = cur;
    41. 			}
    42. 		
    43. 			while (parent && parent->_col == RED)//插入cur之后只有当parent存在且为红色才需要处理
    44. 			{
    45. 				//如果parent存在且为红色，那么说明它的parent的父亲一定存在，且为黑色
    46. 				Node* grandfather = parent->_parent;
    47. 				//这时候需要根据uncle的颜色进行判断来区分是哪种情况然后再进行处理
    48. 				if (parent == grandfather->_left)
    49. 				{
    50. 					Node* uncle = grandfather->_right;
    51. 					if (uncle && uncle->_col == RED)
    52. 					{
    53. 						//如果舅舅存在且为红，需要将parent和uncle都变为黑色，然后再将grandfather变为红色
    54. 						//继续迭代处理看是属于哪种情况
    55. 						uncle->_col = parent->_col = BLACK;
    56. 						grandfather->_col = RED;
    57. 						//迭代
    58. 						cur = grandfather;
    59. 						parent = cur->_parent;
    60. 					}
    61. 					else
    62. 					{
    63. 						//如果uncle不存在或者uncle存在且为黑色，就要进行其它的处理了
    64. 						if (cur == parent->_right)//parent == grandfather->_left
    65. 						{
    66. 							//这时候需要进行双旋
    67. 							//先进行一次左旋
    68. 							RotateL(parent);//在parent位置
    69. 							::swap(cur, parent);//交换两个指针
    70. 							//通过上面的处理可以将左右双旋变为右单旋
    71. 						}
    72. 						//这里处理的就是右单旋的情况，
    73. 						RotateR(grandfather);
    74. 						//变色
    75. 						parent->_col = BLACK;
    76. 						grandfather->_col = RED;
    77. 						break;
    78. 					}
    79. 				}
    80. 				else//parent == grandfather->_right
    81. 				{
    82. 					Node* uncle = grandfather->_left;
    83. 					//这里也是一样的，分为uncle为红色和不为红色两种情况
    84. 					if (uncle && uncle->_col == RED)
    85. 					{
    86. 						//如果uncle为红色，就要将parent和uncle都变为黑色，将grandfather变为红色
    87. 						//然后迭代进行其它处理
    88. 						parent->_col = uncle->_col = BLACK;
    89. 						grandfather->_col = RED;
    90. 						//迭代
    91. 						cur = grandfather;
    92. 						parent = cur->_parent;
    93. 					}
    94. 					else
    95. 					{
    96. 						//这里处理的是uncle为黑色或者uncle不存在的情况
    97. 						//需要旋转+变色进行处理
    98. 						if (cur == parent->_left)//parent == grandfather->_right
    99. 						{
    100. 							//右单旋
    101. 							RotateR(parent);
    102. 							::swap(cur, parent);
    103. 							//这样处理就可以将需要双旋的场景转化为单旋
    104. 						}
    105. 						RotateL(grandfather);
    106. 						//变色
    107. 						parent->_col = BLACK;
    108. 						grandfather->_col = RED;
    109. 						break;
    110. 					}
    111. 				}
    112. 			}
    113. 			_root->_col = BLACK;//不管怎么样最后将根节点变为黑色
    114. 			return true;
    115. 		}
    116.  
    117. 		//左右单旋的代码
    118. 		void RotateL(Node*parent)
    119. 		{
    120. 			//左单旋
    121. 			Node* subR = parent->_right;
    122. 			Node* subRL = subR->_left;
    123.  
    124. 			parent->_right = subRL;
    125. 			if (subRL)//subRL有可能不存在
    126. 				subRL->_parent = parent;
    127. 			Node* pParent = parent;
    128. 			subR->_left = parent;
    129. 			parent->_parent = subR;
    130. 			//三叉链的链接会复杂一点
    131. 			if (parent == _root)//判断parent是否为根
    132. 			{
    133. 				//更新根节点
    134. 				_root = subR;
    135. 				_root->_parent = nullptr;
    136. 			}
    137. 			else
    138. 			{
    139. 				subR->_parent = pParent;
    140. 				if (parent == pParent->_left)
    141. 				{
    142. 					pParent->_left = subR;
    143. 				}
    144. 				else
    145. 				{
    146. 					pParent->_right = subR;
    147. 				}
    148. 			}
    149. 		}
    150. 		void RotateR(Node* parent)
    151. 		{
    152. 			//右单旋
    153. 			Node* subL = parent->_left;
    154. 			Node* subLR = subL->_right;
    155. 			parent->_left = subLR;
    156. 			if (subLR)
    157. 				subLR->_parent = parent;
    158. 			Node* pParent = parent->_parent;
    159. 			subL->_right = parent;
    160. 			parent->_parent = subL;
    161. 			//三叉链的链接会复杂一点
    162.  
    163. 			if (parent == _root)
    164. 			{
    165. 				//更新根节点
    166. 				_root = subL;
    167. 				_root->_parent = nullptr;
    168. 			}
    169. 			else
    170. 			{
    171. 				subL->_parent = pParent;
    172. 				if (parent == pParent->_left)
    173. 				{
    174. 					pParent->_left = subL;
    175. 				}
    176. 				else
    177. 				{
    178. 					pParent->_right = subL;
    179. 				}
    180. 			}
    181. 		}

            3.3红黑色的验证

            红黑树的检测分为两步：

            1.检测其是否满足二叉搜索树（中序遍历是否有序）

            2.检测其是否满足红黑树的性质

    1.         void _Inorder(Node* root)
    2. 		{
    3. 			if (root == nullptr)
    4. 			{
    5. 				return;
    6. 			}
    7. 			_Inorder(root->_left);
    8. 			cout << root->_data << endl;
    9. 			_Inorder(root->_right);
    10. 		}
    11. 		void Inorder()
    12. 		{
    13.             if(_root)
    14. 		    {
    15.                 _Inorder(_root);
    16.             }
    17. 		}
    1.         Node* GetRoot()//获取根节点
    2. 		{
    3. 			return _root;
    4. 		}
    5. 		bool IsValidRBTree()
    6. 		{
    7. 			Node* root = GetRoot();
    8. 			if (root == nullptr)
    9. 			{
    10. 				return true;//空树也是红黑树
    11. 			}
    12. 			if (_root->_col != BLACK)
    13. 			{
    14. 				cout << "违反性质2" << endl;
    15. 				return false;
    16. 			}
    17. 			//获取任何一条路径上的黑色节点数
    18. 			Node* cur = root;
    19. 			size_t blackSize = 0;
    20. 			while (cur)
    21. 			{
    22. 				if (cur->_col == BLACK)
    23. 				{
    24. 					++blackSize;
    25. 				}
    26. 				cur = cur->_right;
    27. 			}
    28. 			size_t k = 0;
    29. 			return _IsValidRBTree(root, k, blackSize);
    30. 		}
    31. 		bool _IsValidRBTree(Node* pRoot, size_t k, size_t blackSize)
    32. 		{
    33. 			//走到空的时候判断k和black和是否相等
    34. 			if (pRoot == nullptr)
    35. 			{
    36. 				if (k != blackSize)
    37. 				{
    38. 					cout << "违反性质4" << endl;
    39. 					cout << k << " " << blackSize << endl;
    40. 					return false;
    41. 				}
    42. 				return true;
    43. 			}
    44. 			if (BLACK == pRoot->_col)
    45. 			{
    46. 				++k;
    47. 			}
    48. 			//检测当前节点与其双亲节点是否为红色
    49. 			Node* parent = pRoot->_parent;
    50. 			if (parent && parent->_col == RED && pRoot->_col == RED)
    51. 			{
    52. 				cout << "违反性质3：没有连在一起的红节点" << endl;
    53. 				return false;
    54. 			}
    55. 			return _IsValidRBTree(pRoot->_left, k, blackSize) 
    56. 				&& _IsValidRBTree(pRoot->_right, k, blackSize);
    57. 		}

            3.4红黑树的查找

            红黑树的查找和搜索树的查找一样只需要按照搜索树的规则进行查找就可以了。 

    1. 	    Node* Find(const K& key)
    2. 		{
    3. 			if (_root == nullptr)
    4. 			{
    5. 				return _root;
    6. 			}
    7. 			Node* cur = _root;
    8. 			while (cur)
    9. 			{
    10. 				if (cur->_data == key)
    11. 				{
    12. 					break;
    13. 				}
    14. 				else if (key > cur->_data)
    15. 				{
    16. 					//去右边找
    17. 					cur = cur->_right;
    18. 				}
    19. 				else
    20. 				{
    21. 					//去左边找
    22. 					cur = cur->_left;
    23. 				}
    24. 			}
    25. 			//找不到返回cur,cur此时走到nullptr
    26. 			return cur;
    27. 		}

            3.5红黑树的删除 

                    3.5.1删除详解 

            为什么要将红黑树的删除放在最后呢，这是有原因的，如果将红黑树的删除放前面那么十分钟肯定就学不会了。

            因为红黑树的删除是有一定的难度的，所以要做好心理准备。 

            首先和插入一样，因为红黑树是平衡二叉树所以它的删除和二叉搜索树的删除是有些一样的地方的，如果不了二叉搜索树的删除可以参考：二叉搜索树

            和插入一样，首先删除也分为这样的几步：

            第一步：查找要删除的值data是否在红黑树中。

            第二步：如果在要删除值在红黑树中 ，就要判断这个值是位于红黑树的哪个位置，因为在搜索树中不同位置的值的处理是不同的。

            第三步：进行调整。

            这样看是不是觉得红黑树的删除挺简单的呢，至少看起来是不难的！

             

            接下来让我们先详解第二步，我们就将要删除的值称为del,（这样方便写，也方便看） del有以下几种情况：

            情况1：del所在的节点左右子树都存在，那么这时候就需要寻找替代节点将，删除替代节点就行了。

            情况2：del的左子树或者右子树是空的。

            情况3：del是叶子节点。

            接下来我们就对这几种情况作具体的分析。

            情况1详解：如何寻找替代节点呢，其实如果了解搜索树的删除的朋友应该知道，无非就是去找del的前驱或者后继节点，然后用del的前驱或者后继节点的值，覆盖del就行了，那么下面要介绍两个概念，前驱节点和后继节点。

            前驱节点：就是比当前节点值小的节点中值最大的节点，也就是它左子树中的最右节点。

            后继节点：就是比当前节点值大的节点中值最小的节点，也就是它右子树中的最左节点。

            寻找替代节点的详解图: 

            这时候就将情况1转化为情况2或者情况3了。因为替代节点就两种情况 ，要么是一个子树为空的节点（情况2），要么是叶子节点（情况3）。

            情况2详解：

            如果左右子树中有一个为空，另一个不为空。

            如果左子树为空，右子树不为空，那么右子树肯定是红色节点，因为如果右子树为黑色的节点肯定会违背红黑树的性质：每条路径上都有相同路径的黑色节点。 

            右子树为空也是一样的，它左边的节点肯定是红色的节点，只需要将它不为空的节点作为替代节点，对替代节点进行操作就行了。

            图示：

            实际上这是将情况2转化为情况3。 

            情况3详解

            如果叶子节点是黑色的是不能直接删除的，需要进行处理。 也就是第三步进行调整。

            如果叶子节点是红色的，还需要进行处理吗？不需要的直接删除就行了 。

            第三步调整详解 

            看了这么多了，怎么样是不是感觉红黑树其实也是比较简单的呢，不过接下来的调整也要分为好几种情况，你可别把自己绕晕了。 

            调整大概可以分成三种情况，为了接下来好描述，我将当前需要调整的节点定义为delNode，简称D。它的兄弟定义为brother,简称B，它的双亲定义为parent，简称P。 它兄弟的左孩子简称为BL，它兄弟的右孩子简称为BR，怎么样这么一堆名称是不是已经让你晕了，其实记首字母就行了，在代码实现里面没有用缩写应该很容易看懂。

            如图：                情况1：

           这个节点是根节点，将根节点变黑就行了。

            如图：

                    情况2：

            B是黑色的。

            这时候又要分成两种情况了。B的孩子存在（BL或者BR），或者B的孩子不存在。

                            B的孩子存在：

            如果B的孩子存在，要根据B的孩子和B的位置以及B的位置和P的位置的相对关系来判断。分为四种情况：

            情况1：B在P的左边，如果BL存在，此时在P的位置进行左旋：然后变色，将B变成P的颜色将P变为黑色，BL变成黑色。因为其实这种情况下P的颜色是不确定的。

             

            情况2：B在P的左边，如果BR存在，此时要进行两次旋转，在B的位置进行左旋，然后在P的位置进行右旋，将BR变为P的颜色，将P变为黑色。

            情况3：B在P的右边，如果BR存在，此时在P的位置进行左旋，然后将B的颜色变成P的颜色，将P和BR的颜色变成黑色。

             

            情况4：B在P的右边，如果BL存在，此时要进行两次旋转。在B的位置右旋，在P的位置左旋，将BL变为P的颜色，将P变为黑色。

     

                            B的孩子不存在：

             理论上这种是最复杂的因为B的孩子不存在，B为黑色，D也为黑色，那么此时P就有两种情况，P为红色和P为黑色。

            如果P为红色，那么此时将B变为红色，P变为黑色就结束了。

         如图：

              如果P为黑色，就需要以P为调整节点继续向上进行调整。我们需要将B和D都变为红色然后以P为调整节点，继续判断是属于哪种情况再进行调整。如图： 

            注意：这里要小心一种特殊情况，那就是P是根节点(_root)，只需要将B变成红色结束即可。

             

            看着很复杂但是写成代码却是最简单的，这里卖个关子，我想你应该可以猜到是为什么。哈哈哈哈。 

                    情况3： 

             B是红色的，那么必然存在BL和BR且都是黑色的。（为什么，根据红黑树的形状得来的后面如果不太理解，看图你就知道了） 

            这时候就需要判断B和P的关系了，如果B在P的左边，进行右旋就行了，如果B在P的右边进行左旋就行了，旋转完需要变色。（或者先变色再旋转也可以）变色情况具体看图分析：

            如图：

                    3.5.2删除的代码实现 

            这里只贴了删除部分的代码，如果有不理解的地方可以参看注释，其实代码还可以简化一些的，但是那样子代码的可读性会降低很多，所以就没有那么写，好的代码不是越精简越好，可读性，可维护性等都很重要。 

    1. //红黑树的删除，比插入还要难一些
    2. //主要分为下面的几种情况
    3. bool Erase(const K& data)
    4. {
    5. 	//情况1：红黑树中不存在要删除的节点，返回false
    6. 	//情况2：只剩下根节点，删除根节点将根节点置空
    7. 	//情况3：要删除的节点左右子树都存在
    8. 	//情况4：要删除的节点只有左子树或者右子树
    9. 	//情况5：删除的是叶子节点
    10. 	Node* delNode = Find(data);//查找要删除的节点
    11. 	if (delNode == nullptr)
    12. 	{
    13. 		//情况1：红黑树中不存在要删除的节点，返回false
    14. 		cout << "节点不存在" << endl;
    15. 		return false;//这里判断红黑树中是否存在这个节点
    16. 	}
    17. 	if (_root == delNode
    18. 		&& _root->_left == nullptr
    19. 		&& _root->_right == nullptr)
    20. 	{
    21. 		//情况2：只剩下根节点，删除根节点将根节点置空
    22. 		delete _root;
    23. 		_root = nullptr;
    24. 		return true;
    25. 	}
    26. 	if (delNode->_left && delNode->_right)
    27. 	{
    28. 		//第三种情况是它的左右子树都不为空，那么这时候我们需要找替代节点，
    29. 		//然后将第三种情况转化为第四种或者第五种情况
    30. 		Node* replace = getReplaceNode(delNode);
    31. 		delNode->_data = replace->_data;
    32. 		delNode = replace;
    33. 	}
    34. 	if ((delNode->_left && delNode->_right == nullptr)
    35. 		|| (delNode->_left == nullptr && delNode->_right))
    36. 	{
    37. 		//第四种情况删除的这个节点有一个子节点为空另一个子节点不为空，
    38. 		//那么要删除的当前节点一定是黑色的节点，并且它的不为空的节点一定是红色节点，
    39. 		//否则的话将不满足红黑树的性质
    40. 		//将第四种情况转化为第五种情况
    41. 		Node* replace = delNode->_left != nullptr ? delNode->_left : delNode->_right;
    42. 		delNode->_data = replace->_data;
    43. 		delNode = replace;
    44. 	}
    45. 	if (delNode->_left == nullptr
    46. 		&& delNode->_right == nullptr)
    47. 	{
    48. 		//走到这里说明删除的这个节点是叶子节点，如果叶子节点是红色的那么直接删除就好了，
    49. 		//但是叶子节点是黑色的话就需要进行旋转处理了
    50. 		if (delNode->_col == BLACK)
    51. 		{
    52. 			//对黑色叶子节点进行处理
    53. 			AdjustDown(delNode);//调用函数进行处理
    54. 		}
    55. 		//删除节点
    56. 		Node* parent = delNode->_parent;
    57. 		if (parent->_left == delNode)
    58. 		{
    59. 			parent->_left = nullptr;
    60. 		}
    61. 		else
    62. 		{
    63. 			parent->_right = nullptr;
    64. 		}
    65. 		delNode->_parent = nullptr;
    66. 		delete delNode;
    67. 		delNode = nullptr;
    68. 	}
    69. 	return true;
    70. }
    71.  
    72. //在删除的节点是叶子节点且节点是红色的情况下的调整逻辑
    73. void AdjustDown(Node* delNode)
    74. {
    75. 	//分成三种大的情况:
    76. 	//情况1：如果这个节点是根节点，将它变黑返回就行了
    77. 	//情况2：它的兄弟节点为黑色
    78. 	//情况3：它的兄弟节点为红色
    79. 	Node* parent = delNode->_parent;
    80. 	Node* brother = (delNode == parent->_left ? parent->_right : parent->_right);
    81. 	if (_root == delNode)
    82. 	{
    83. 		//情况1：如果这个节点是根节点，将它变黑返回就行了
    84. 		_root->_col = BLACK;
    85. 		return;
    86. 	}
    87. 	else if (brother && brother->_col == BLACK)
    88. 	{
    89. 		//情况2：它的兄弟节点为黑色
    90. 		//这个又要分为两种情况
    91. 		//情况1：brother不存在左右孩子
    92. 		//情况2：brother存在左孩子或者右孩子，这时候brother的孩子肯定是红节点
    93.  
    94. 		if (brother->_left == nullptr
    95. 			&& brother->_right == nullptr)//情况1：brother不存在左右孩子
    96. 		{
    97. 			//这时候又要分成两种情况
    98. 			//情况1：parent为红色,这时候只需要将brother变为红色，parent变为黑色即可
    99. 			//情况2：parent为黑色,这时候就需要以parent为调整节点继续向上进行调整
    100. 			if (parent->_col == RED)
    101. 			{
    102. 				parent->_col = BLACK;
    103. 				brother->_col = RED;
    104. 			}
    105. 			else//情况2：parent为黑色,这时候就需要以parent为调整节点继续向上进行调整
    106. 			{
    107. 				if (parent == _root && brother->_col == BLACK)
    108. 				{
    109. 					//说明此时只有三个节点且全部为黑
    110. 					//将brother变红然后返回
    111. 					brother->_col = RED;
    112. 					return;
    113. 				}
    114. 				else
    115. 				{
    116. 					//需要将brother变为红色，
    117. 					//以parent为调整节点继续调整
    118. 					brother->_col = RED;
    119. 					AdjustDown(parent);
    120. 				}
    121. 			}
    122. 		}
    123. 		else//情况2：brother存在左孩子或者右孩子，这时候brother的孩子肯定是红节点
    124. 		{
    125. 			//这时候因为brother是红色的，delNode也是红色的，且brother存在孩子
    126. 			//那么这时候就有四种情况:
    127. 			//情况1：brother是parent的左孩子，并且brother存在左孩子
    128. 			//情况2：brother是parent的左孩子，并且brother存在右孩子
    129. 			//情况3：brother是parent的右孩子，并且brother存在右孩子
    130. 			//情况4：brother是parent的右孩子，且brother存在右孩子
    131. 			if (brother == parent->_left && brother->_left)
    132. 			{
    133. 				//情况1：brother是parent的左孩子，并且brother存在左孩子
    134. 				Node* brotherLeft = brother->_left;
    135. 				if (brotherLeft)
    136. 				{
    137. 					//在parent的位置右旋
    138. 					//brother的颜色变为parent的颜色
    139. 					//brotherLeft和parent都变为黑色
    140. 					brother->_col = parent->_col;
    141. 					parent->_col = brotherLeft->_col = BLACK;
    142. 					RotateR(parent);
    143. 				}
    144. 				else if (brother->_right) // 情况2：brother是parent的左孩子，并且brother存在右孩子
    145. 				{
    146. 					Node* brotherRight = brother->_right;
    147. 					//这时候要进行双旋，先左旋再右旋，在进行变色
    148. 					//在brother的位置进行左旋，然后在parent的位置进行右旋
    149. 					//brotherRight变成parent的颜色，parent变成黑色
    150. 					brotherRight->_col = parent->_col;
    151. 					parent->_col = BLACK;
    152. 					RotateL(brother);
    153. 					RotateR(parent);
    154. 				}
    155. 			}
    156. 			else if (brother == parent->_right && brother->_right)
    157. 			{
    158. 				//情况3：brother是parent的右孩子，并且brother存在右孩子
    159. 				Node* brotherRight = brother->_right;
    160. 				if (brotherRight)
    161. 				{
    162. 					//brother是parent的右孩子，且brother存在右孩子，进行左旋在parent的位置
    163. 					//brother的颜色变为parent的颜色，
    164. 					//parent和brotherRight变为黑色
    165. 					brother->_col = parent->_col;
    166. 					parent->_col = brotherRight->_col = BLACK;
    167. 					RotateL(parent);
    168. 				}
    169. 				else if (brother->_left)//情况4：brother是parent的右孩子，且brother存在左孩子
    170. 				{
    171. 					Node* britherLeft = brother->_left;
    172. 					//brother是parent的右孩子，且brother存在左孩子，
    173. 					//先在brither处右旋，再在parent处左旋
    174. 					//变色：parent变黑，brotherLeft变为parent的颜色
    175. 					britherLeft->_col = parent->_col;
    176. 					parent->_col = BLACK;
    177. 					RotateR(brother);
    178. 					RotateL(parent);
    179. 				}
    180. 			}
    181. 		}
    182. 	}
    183. 	else if (brother && brother->_col == RED)
    184. 	{
    185. 		//情况3：它的兄弟节点为红色
    186. 		//如果brother是红色的，那么它肯定存在两个孩子并且两个孩子都是黑色的，
    187. 		//不然就不符合红黑树的性质
    188. 		// 这时候又分成两种情况：
    189. 		//如果brother在parent的左边就右旋，然后将brother变黑，brother的right变红
    190. 		//如果brother在parent的右边就右旋,然后brother变黑，brother的left变红
    191. 		if (brother == parent->_left)
    192. 		{
    193. 			Node* brotherRight = brother->_right;
    194. 			brotherRight->_col = RED;
    195. 			brother->_col = BLACK;
    196. 			RotateR(parent);//右旋
    197. 		}
    198. 		else
    199. 		{
    200. 			Node* brotherLeft = brother->_left;
    201. 			brotherLeft->_col = RED;
    202. 			brother->_col = BLACK;
    203. 			RotateL(parent);
    204. 		}
    205. 	}
    206. }
    207. //找一个节点的前驱
    208. Node* prevNode(Node* root)
    209. {
    210. 	Node* cur = root->_left;//前驱是左子树中的最大节点，也就是左子树中的最右节点
    211. 	while (cur && cur->_right)
    212. 	{
    213. 		cur = cur->_right;
    214. 	}
    215. 	return cur;
    216. }
    217. //找一个节点的后继
    218. Node* successNode(Node* root)
    219. {
    220. 	Node* cur = root->_right;//后继是右子树中的最小节点，也就是右子树中的最左子树
    221. 	while (cur && cur->_left)
    222. 	{
    223. 		cur = cur->_left;
    224. 	}
    225. 	return cur;
    226. }
    227. //找替代节点
    228. //替代节点可以选前驱节点中符合条件的，如果前驱节点不符合条件就返回后继节点
    229. Node* getReplaceNode(Node* delNode)
    230. {
    231. 	Node* replace = prevNode(delNode);
    232. 	if (replace->_col == RED)
    233. 	{
    234. 		//如果替代节点是红节点直接返回就可以了，这种情况说明这个找到的替代节点是叶子节点
    235. 		return replace;
    236. 	}
    237. 	else if (replace->_left)//如果这个替代节点是黑色的，但是它的左节点存在，
    238. 						//那么左节点一定是红色的,因为我们判断的是这棵子树的最右节点,
    239. 						//如果左孩子是黑色的,就不满足红黑色，每条路径黑节点的数量相等这个属性
    240. 	{
    241. 		return replace->_left;
    242. 	}
    243. 	return successNode(delNode);
    244. }

            到这里红黑树的删除就结束了，不知道你用了多久看完它呢， 不知道看完它你是哪种状态呢，是大彻大悟还是模模糊糊呢，亦或者是感觉脑子有点痒痒的~

             3.6测试代码

             测试其实没有什么好说的。你就找一堆数据进行插入并且删除就好了，最好是足够多的数据这样可以查出一写影藏的BUG，这种树状的结构查看起来比较麻烦，所以我写了一个数层次结构的遍历，这样遇到问题的时候打印一下，找个地方画画看看是哪里出问题了就比较好分析，查看内存的话，能把你绕晕，这也是一种偷懒的做法吧，当然也有一些小工具可以进行测试，但是太麻烦了，懒得搞。

    1.         //这里写一个红黑树的层次遍历，有bug调试起来真的太恶心了
    2. 		void Traversal()
    3. 		{
    4. 			_Traversal(_root);
    5. 		}
    6. 		void _Traversal(Node* root)
    7. 		{
    8. 			if (root == nullptr)
    9. 			{
    10. 				return;
    11. 			}
    12. 			//借助队列
    13. 			queue q;
    14. 			q.push(root);
    15. 			while (!q.empty())
    16. 			{
    17. 				Node* cur = q.front();//取队头的数据
    18. 				cout << cur->_data;
    19. 				Color(cur->_col);
    20. 				cout << "左孩子：";Data(cur->_left);
    21. 				cout << "右孩子："; Data(cur->_right);
    22. 				cout << "父亲："; Data(cur->_parent);
    23. 				cout << endl;
    24. 				q.pop();
    25. 				if (cur->_left)
    26. 				{
    27. 					//将左右子树入队
    28. 					q.push(cur->_left);
    29. 				}
    30. 				if (cur->_right)
    31. 				{
    32. 					//将右子树入队
    33. 					q.push(cur->_right);
    34. 				}
    35. 			}
    36. 		}
    37. 		void Data(Node* cur)
    38. 		{
    39. 			if (cur)
    40. 			{
    41. 				cout << cur->_data <<"	";
    42.  
    43. 			}
    44. 			else
    45. 			{
    46. 				cout << "NULL" <<"	";
    47. 			}
    48. 		}
    49. 		//将枚举类型打印为颜色
    50. 		void Color(enum Colour&col)
    51. 		{
    52. 			if (col == BLACK)
    53. 			{
    54. 				cout << "黑色"<<"	";
    55. 			}
    56. 			else
    57. 			{
    58. 				cout << "红色" <<"	";
    59. 			}
    60. 		}
    1. void TestRBTreeErase()
    2. {
    3. 	qyy::RBTree<int> rb1;
    4. 	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14, 20, 30 };
    5. 	for (auto e : a)
    6. 	{
    7. 		rb1.Insert(e);
    8. 		cout << "插入" << e << "->" << endl;
    9. 	}
    10. 	rb1.Traversal();
    11.  
    12. 	rb1.Inorder();
    13. 	cout << rb1.IsValidRBTree() << endl;
    14. 	
    15. 	for (auto e : a)
    16. 	{
    17. 		rb1.Erase(e);
    18. 		cout << "删除" << e << "->" << endl;
    19. 	}
    20. 	rb1.Inorder();
    21.  
    22. }

            3.7全部代码 

           // RBTree.hpp

             

    1. #include
    2. #include
    3. using namespace std;
    4. namespace qyy
    5. {
    6. 	//用来表示红黑色节点的颜色
    7. 	enum Colour
    8. 	{
    9. 		RED,
    10. 		BLACK,
    11. 	};
    12. 	template<class K>
    13. 	struct RBTreeNode
    14. 	{
    15. 		RBTreeNode* _left;
    16. 		RBTreeNode* _right;
    17. 		RBTreeNode* _parent;
    18. 		K _data;
    19. 		Colour _col;
    20. 		//构造函数完成对节点的初始化
    21. 		RBTreeNode(const K& data)
    22. 			:_left(nullptr)
    23. 			,_right(nullptr)
    24. 			,_parent(nullptr)
    25. 			,_data(data)
    26. 			,_col(RED)
    27. 		{
    28. 		}
    29. 	};
    30. 	template<class K>
    31. 	class RBTree
    32. 	{
    33. 	public:
    34. 		typedef RBTreeNode Node;
    35. 		RBTree()
    36. 			:_root(nullptr)
    37. 		{}
    38. 		bool Insert(const K& data)
    39. 		{
    40. 			//如果根节点为空直接插入并初始化根节点
    41. 			if (_root == nullptr)
    42. 			{
    43. 				_root = new Node(data);
    44. 				_root->_col = BLACK;//将根节点变黑
    45. 			}
    46. 			Node* cur = _root;
    47. 			Node* parent = nullptr;
    48. 			while (cur)
    49. 			{
    50. 				//新插入的节点都是红色的，
    51. 				if (cur->_data == data)
    52. 				{
    53. 					//节点中存在data不需要进行插入
    54. 					return false;
    55. 				}
    56. 				else if (data > cur->_data)
    57. 				{
    58. 					parent = cur;
    59. 					cur = cur->_right;
    60. 				}
    61. 				else if (data < cur->_data)
    62. 				{
    63. 					parent = cur;
    64. 					cur = cur->_left;
    65. 				}
    66. 			}
    67. 			//申请新节点进行插入
    68. 			cur = new Node(data);
    69. 			cur->_parent = parent;
    70. 			cur->_col = RED;
    71. 			if (cur->_data > parent->_data)
    72. 			{
    73. 				parent->_right = cur;
    74. 			}
    75. 			else
    76. 			{
    77. 				parent->_left = cur;
    78. 			}
    79. 			//插入之后进行调整
    80. 			while (parent && parent->_col == RED)//插入cur之后只有当parent存在且为红色才需要处理
    81. 			{
    82. 				//如果parent存在且为红色，那么说明它的parent的父亲一定存在，且为黑色
    83. 				Node* grandfather = parent->_parent;
    84. 				//这时候需要根据uncle的颜色进行判断来区分是哪种情况然后再进行处理
    85. 				if (parent == grandfather->_left)
    86. 				{
    87. 					Node* uncle = grandfather->_right;
    88. 					if (uncle && uncle->_col == RED)
    89. 					{
    90. 						//如果舅舅存在且为红，需要将parent和uncle都变为黑色，然后再将grandfather变为红色
    91. 						//继续迭代处理看是属于哪种情况
    92. 						uncle->_col = parent->_col = BLACK;
    93. 						grandfather->_col = RED;
    94. 						//迭代
    95. 						cur = grandfather;
    96. 						parent = cur->_parent;
    97. 					}
    98. 					else
    99. 					{
    100. 						//如果uncle不存在或者uncle存在且为黑色，就要进行其它的处理了
    101. 						if (cur == parent->_right)//parent == grandfather->_left
    102. 						{
    103. 							//这时候需要进行双旋
    104. 							//先进行一次左旋
    105. 							RotateL(parent);//在parent位置
    106. 							::swap(cur, parent);//交换两个指针
    107. 							//通过上面的处理可以将左右双旋变为右单旋
    108. 						}
    109. 						//这里处理的就是右单旋的情况，
    110. 						RotateR(grandfather);
    111. 						//变色
    112. 						parent->_col = BLACK;
    113. 						grandfather->_col = RED;
    114. 						break;
    115. 					}
    116. 				}
    117. 				else//parent == grandfather->_right
    118. 				{
    119. 					Node* uncle = grandfather->_left;
    120. 					//这里也是一样的，分为uncle为红色和不为红色两种情况
    121. 					if (uncle && uncle->_col == RED)
    122. 					{
    123. 						//如果uncle为红色，就要将parent和uncle都变为黑色，将grandfather变为红色
    124. 						//然后迭代进行其它处理
    125. 						parent->_col = uncle->_col = BLACK;
    126. 						grandfather->_col = RED;
    127. 						//迭代
    128. 						cur = grandfather;
    129. 						parent = cur->_parent;
    130. 					}
    131. 					else
    132. 					{
    133. 						//这里处理的是uncle为黑色或者uncle不存在的情况
    134. 						//需要旋转+变色进行处理
    135. 						if (cur == parent->_left)//parent == grandfather->_right
    136. 						{
    137. 							//右单旋
    138. 							RotateR(parent);
    139. 							::swap(cur, parent);
    140. 							//这样处理就可以将需要双旋的场景转化为单旋
    141. 						}
    142. 						RotateL(grandfather);
    143. 						//变色
    144. 						parent->_col = BLACK;
    145. 						grandfather->_col = RED;
    146. 						break;
    147. 					}
    148. 				}
    149. 			}
    150. 			_root->_col = BLACK;//不管怎么样最后将根节点变为黑色
    151. 			return true;
    152. 		}
    153. 		//这里写一个红黑树的层次遍历，有bug调试起来真的太恶心了
    154. 		void Traversal()
    155. 		{
    156. 			_Traversal(_root);
    157. 		}
    158. 		void _Traversal(Node* root)
    159. 		{
    160. 			if (root == nullptr)
    161. 			{
    162. 				return;
    163. 			}
    164. 			//借助队列
    165. 			queue q;
    166. 			q.push(root);
    167. 			while (!q.empty())
    168. 			{
    169. 				Node* cur = q.front();//取队头的数据
    170. 				cout << cur->_data;
    171. 				Color(cur->_col);
    172. 				cout << "左孩子：";Data(cur->_left);
    173. 				cout << "右孩子："; Data(cur->_right);
    174. 				cout << "父亲："; Data(cur->_parent);
    175. 				cout << endl;
    176. 				q.pop();
    177. 				if (cur->_left)
    178. 				{
    179. 					//将左右子树入队
    180. 					q.push(cur->_left);
    181. 				}
    182. 				if (cur->_right)
    183. 				{
    184. 					//将右子树入队
    185. 					q.push(cur->_right);
    186. 				}
    187. 			}
    188. 		}
    189. 		void Data(Node* cur)
    190. 		{
    191. 			if (cur)
    192. 			{
    193. 				cout << cur->_data <<"	";
    194.  
    195. 			}
    196. 			else
    197. 			{
    198. 				cout << "NULL" <<"	";
    199. 			}
    200. 		}
    201. 		//将枚举类型打印为颜色
    202. 		void Color(enum Colour&col)
    203. 		{
    204. 			if (col == BLACK)
    205. 			{
    206. 				cout << "黑色"<<"	";
    207. 			}
    208. 			else
    209. 			{
    210. 				cout << "红色" <<"	";
    211. 			}
    212. 		}
    213. 		//左右单旋的代码
    214. 		void RotateL(Node*parent)
    215. 		{
    216. 			//左单旋
    217. 			Node* subR = parent->_right;
    218. 			Node* subRL = subR->_left;
    219.  
    220. 			parent->_right = subRL;
    221. 			if (subRL)//subRL有可能不存在
    222. 				subRL->_parent = parent;
    223. 			Node* pParent = parent->_parent;//这里之前写错了,刚开始没事，但是插入到后面就会出错
    224. 			subR->_left = parent;
    225. 			parent->_parent = subR;
    226. 			//三叉链的链接会复杂一点
    227. 			if (parent == _root)//判断parent是否为根
    228. 			{
    229. 				//更新根节点
    230. 				_root = subR;
    231. 				_root->_parent = nullptr;
    232. 			}
    233. 			else
    234. 			{
    235. 				subR->_parent = pParent;
    236. 				if (parent == pParent->_left)
    237. 				{
    238. 					pParent->_left = subR;
    239. 				}
    240. 				else
    241. 				{
    242. 					pParent->_right = subR;
    243. 				}
    244. 			}
    245. 		}
    246. 		void RotateR(Node* parent)
    247. 		{
    248. 			//右单旋
    249. 			Node* subL = parent->_left;
    250. 			Node* subLR = subL->_right;
    251. 			parent->_left = subLR;
    252. 			if (subLR)
    253. 				subLR->_parent = parent;
    254. 			Node* pParent = parent->_parent;
    255. 			subL->_right = parent;
    256. 			parent->_parent = subL;
    257. 			//三叉链的链接会复杂一点
    258.  
    259. 			if (parent == _root)
    260. 			{
    261. 				//更新根节点
    262. 				_root = subL;
    263. 				_root->_parent = nullptr;
    264. 			}
    265. 			else
    266. 			{
    267. 				subL->_parent = pParent;
    268. 				if (parent == pParent->_left)
    269. 				{
    270. 					pParent->_left = subL;
    271. 				}
    272. 				else
    273. 				{
    274. 					pParent->_right = subL;
    275. 				}
    276. 			}
    277. 		}
    278. 		//红黑树的删除，比插入还要难一些
    279. 		//主要分为下面的几种情况
    280. 		bool Erase(const K& data)
    281. 		{
    282. 			//情况1：红黑树中不存在要删除的节点，返回false
    283. 			//情况2：只剩下根节点，删除根节点将根节点置空
    284. 			//情况3：要删除的节点左右子树都存在
    285. 			//情况4：要删除的节点只有左子树或者右子树
    286. 			//情况5：删除的是叶子节点
    287. 			Node* delNode = Find(data);//查找要删除的节点
    288. 			if (delNode == nullptr)
    289. 			{
    290. 				//情况1：红黑树中不存在要删除的节点，返回false
    291. 				cout << "节点不存在" << endl;
    292. 				return false;//这里判断红黑树中是否存在这个节点
    293. 			}
    294. 			if (_root == delNode  
    295. 				&& _root->_left == nullptr
    296. 				&& _root->_right == nullptr)
    297. 			{
    298. 				//情况2：只剩下根节点，删除根节点将根节点置空
    299. 				delete _root;
    300. 				_root = nullptr;
    301. 				return true;
    302. 			}
    303. 			if (delNode->_left && delNode->_right)
    304. 			{
    305. 				//第三种情况是它的左右子树都不为空，那么这时候我们需要找替代节点，
    306. 				//然后将第三种情况转化为第四种或者第五种情况
    307. 				Node* replace = getReplaceNode(delNode);
    308. 				delNode->_data = replace->_data;
    309. 				delNode = replace;
    310. 			}
    311. 			if ((delNode->_left && delNode->_right == nullptr)
    312. 				|| (delNode->_left == nullptr && delNode->_right))
    313. 			{
    314. 				//第四种情况删除的这个节点有一个子节点为空另一个子节点不为空，
    315. 				//那么要删除的当前节点一定是黑色的节点，并且它的不为空的节点一定是红色节点，
    316. 				//否则的话将不满足红黑树的性质
    317. 				//将第四种情况转化为第五种情况
    318. 				Node* replace = delNode->_left != nullptr ? delNode->_left : delNode->_right;
    319. 				delNode->_data = replace->_data;
    320. 				delNode = replace;
    321. 			}
    322. 			if(delNode->_left == nullptr
    323. 				&&delNode->_right == nullptr)
    324. 			{
    325. 				//走到这里说明删除的这个节点是叶子节点，如果叶子节点是红色的那么直接删除就好了，
    326. 				//但是叶子节点是黑色的话就需要进行旋转处理了
    327. 				if (delNode->_col == BLACK)
    328. 				{
    329. 					//对黑色叶子节点进行处理
    330. 					AdjustDown(delNode);//调用函数进行处理
    331. 				}
    332. 				//删除节点
    333. 				Node* parent = delNode->_parent;
    334. 				if (parent->_left == delNode)
    335. 				{
    336. 					parent->_left = nullptr;
    337. 				}
    338. 				else
    339. 				{
    340. 					parent->_right = nullptr;
    341. 				}
    342. 				delNode->_parent = nullptr;
    343. 				delete delNode;
    344. 				delNode = nullptr; 
    345. 			}
    346. 			return true;
    347. 		}
    348.  
    349. 		//在删除的节点是叶子节点且节点是红色的情况下的调整逻辑
    350. 		void AdjustDown(Node* delNode)
    351. 		{
    352. 			//分成三种大的情况:
    353. 			//情况1：如果这个节点是根节点，将它变黑返回就行了
    354. 			//情况2：它的兄弟节点为黑色
    355. 			//情况3：它的兄弟节点为红色
    356. 			Node* parent = delNode->_parent;
    357. 			Node* brother = (delNode == parent->_left ? parent->_right : parent->_right);
    358. 			if (_root == delNode)
    359. 			{
    360. 				//情况1：如果这个节点是根节点，将它变黑返回就行了
    361. 				_root->_col = BLACK;
    362. 				return;
    363. 			}
    364. 			else if (brother && brother->_col == BLACK)
    365. 			{
    366. 				//情况2：它的兄弟节点为黑色
    367. 				//这个又要分为两种情况
    368. 				//情况1：brother不存在左右孩子
    369. 				//情况2：brother存在左孩子或者右孩子，这时候brother的孩子肯定是红节点
    370.  
    371. 				if (brother->_left == nullptr
    372. 					&& brother->_right == nullptr)//情况1：brother不存在左右孩子
    373. 				{
    374. 					//这时候又要分成两种情况
    375. 					//情况1：parent为红色,这时候只需要将brother变为红色，parent变为黑色即可
    376. 					//情况2：parent为黑色,这时候就需要以parent为调整节点继续向上进行调整
    377. 					if (parent->_col == RED)
    378. 					{
    379. 						parent->_col = BLACK;
    380. 						brother->_col = RED;
    381. 					}
    382. 					else//情况2：parent为黑色,这时候就需要以parent为调整节点继续向上进行调整
    383. 					{
    384. 						if (parent == _root && brother->_col == BLACK)
    385. 						{
    386. 							//说明此时只有三个节点且全部为黑
    387. 							//将brother变红然后返回
    388. 							brother->_col = RED;
    389. 							return;
    390. 						}
    391. 						else
    392. 						{
    393. 							//需要将brother变为红色，
    394. 							//以parent为调整节点继续调整
    395. 							brother->_col = RED;
    396. 							AdjustDown(parent);
    397. 						}
    398. 					}
    399. 				 }
    400. 				else//情况2：brother存在左孩子或者右孩子，这时候brother的孩子肯定是红节点
    401. 				{
    402. 					//这时候因为brother是红色的，delNode也是红色的，且brother存在孩子
    403. 					//那么这时候就有四种情况:
    404. 					//情况1：brother是parent的左孩子，并且brother存在左孩子
    405. 					//情况2：brother是parent的左孩子，并且brother存在右孩子
    406. 					//情况3：brother是parent的右孩子，并且brother存在右孩子
    407. 					//情况4：brother是parent的右孩子，且brother存在右孩子
    408. 					if (brother == parent->_left && brother->_left)
    409. 					{
    410. 						//情况1：brother是parent的左孩子，并且brother存在左孩子
    411. 						Node* brotherLeft = brother->_left;
    412. 						if(brotherLeft)
    413. 						{
    414. 							//在parent的位置右旋
    415. 							//brother的颜色变为parent的颜色
    416. 							//brotherLeft和parent都变为黑色
    417. 							brother->_col = parent->_col;
    418. 							parent->_col = brotherLeft->_col = BLACK;
    419. 							RotateR(parent);
    420. 						}
    421. 						else if (brother->_right) // 情况2：brother是parent的左孩子，并且brother存在右孩子
    422. 						{
    423. 							Node* brotherRight = brother->_right;
    424. 							//这时候要进行双旋，先左旋再右旋，在进行变色
    425. 							//在brother的位置进行左旋，然后在parent的位置进行右旋
    426. 							//brotherRight变成parent的颜色，parent变成黑色
    427. 							brotherRight->_col = parent->_col;
    428. 							parent->_col = BLACK;
    429. 							RotateL(brother);
    430. 							RotateR(parent);
    431. 						}
    432. 					}
    433. 					else if(brother == parent->_right && brother->_right)
    434. 					{
    435. 						//情况3：brother是parent的右孩子，并且brother存在右孩子
    436. 						Node* brotherRight = brother->_right;
    437. 						if(brotherRight)
    438. 						{
    439. 							//brother是parent的右孩子，且brother存在右孩子，进行左旋在parent的位置
    440. 							//brother的颜色变为parent的颜色，
    441. 							//parent和brotherRight变为黑色
    442. 							brother->_col = parent->_col;
    443. 							parent->_col = brotherRight->_col = BLACK;
    444. 							RotateL(parent);
    445. 						}
    446. 						else if (brother->_left)//情况4：brother是parent的右孩子，且brother存在左孩子
    447. 						{
    448. 							Node* britherLeft = brother->_left;
    449. 							//brother是parent的右孩子，且brother存在左孩子，
    450. 							//先在brither处右旋，再在parent处左旋
    451. 							//变色：parent变黑，brotherLeft变为parent的颜色
    452. 							britherLeft->_col = parent->_col;
    453. 							parent->_col = BLACK;
    454. 							RotateR(brother);
    455. 							RotateL(parent);
    456. 						}
    457. 					}
    458. 				}
    459. 			}
    460. 			else if (brother && brother->_col == RED)
    461. 			{
    462. 				//情况3：它的兄弟节点为红色
    463. 				//如果brother是红色的，那么它肯定存在两个孩子并且两个孩子都是黑色的，
    464. 				//不然就不符合红黑树的性质
    465. 				// 这时候又分成两种情况：
    466. 				//如果brother在parent的左边就右旋，然后将brother变黑，brother的right变红
    467. 				//如果brother在parent的右边就右旋,然后brother变黑，brother的left变红
    468. 				if (brother == parent->_left)
    469. 				{
    470. 					Node* brotherRight = brother->_right;
    471. 					brotherRight->_col = RED;
    472. 					brother->_col = BLACK;
    473. 					RotateR(parent);//右旋
    474. 				}
    475. 				else
    476. 				{
    477. 					Node* brotherLeft = brother->_left;
    478. 					brotherLeft->_col = RED;
    479. 					brother->_col = BLACK;
    480. 					RotateL(parent);
    481. 				}
    482. 			}
    483. 		}
    484. 		//找一个节点的前驱
    485. 		Node* prevNode(Node* root)
    486. 		{
    487. 			Node* cur = root->_left;//前驱是左子树中的最大节点，也就是左子树中的最右节点
    488. 			while (cur && cur->_right)
    489. 			{
    490. 				cur = cur->_right;
    491. 			}
    492. 			return cur;
    493. 		}
    494. 		//找一个节点的后继
    495. 		Node* successNode(Node* root)
    496. 		{
    497. 			Node* cur = root->_right;//后继是右子树中的最小节点，也就是右子树中的最左子树
    498. 			while (cur && cur->_left)
    499. 			{
    500. 				cur = cur->_left;
    501. 			}
    502. 			return cur;
    503. 		}
    504. 		//找替代节点
    505. 		//替代节点可以选前驱节点中符合条件的，如果前驱节点不符合条件就返回后继节点
    506. 		Node* getReplaceNode(Node* delNode)
    507. 		{
    508. 			Node* replace = prevNode(delNode);
    509. 			if (replace->_col == RED)
    510. 			{
    511. 				//如果替代节点是红节点直接返回就可以了，这种情况说明这个找到的替代节点是叶子节点
    512. 				return replace;
    513. 			}
    514. 			else if(replace->_left)//如果这个替代节点是黑色的，但是它的左节点存在，
    515. 								//那么左节点一定是红色的,因为我们判断的是这棵子树的最右节点,
    516. 								//如果左孩子是黑色的,就不满足红黑色，每条路径黑节点的数量相等这个属性
    517. 			{
    518. 				return replace->_left;
    519. 			}
    520. 			return successNode(delNode);
    521. 		}
    522. 		void _Inorder(Node* root)
    523. 		{
    524. 			if (root == nullptr)
    525. 			{
    526. 				return;
    527. 			}
    528. 			_Inorder(root->_left);
    529. 			cout << root->_data << endl;
    530. 			_Inorder(root->_right);
    531. 		}
    532. 		void Inorder()
    533. 		{
    534. 			_Inorder(_root);
    535. 		}
    536. 		Node* Find(const K& key)
    537. 		{
    538. 			if (_root == nullptr)
    539. 			{
    540. 				return _root;
    541. 			}
    542. 			Node* cur = _root;
    543. 			while (cur)
    544. 			{
    545. 				if (cur->_data == key)
    546. 				{
    547. 					break;
    548. 				}
    549. 				else if (key > cur->_data)
    550. 				{
    551. 					//去右边找
    552. 					cur = cur->_right;
    553. 				}
    554. 				else
    555. 				{
    556. 					//去左边找
    557. 					cur = cur->_left;
    558. 				}
    559. 			}
    560. 			//找不到返回cur,cur此时走到nullptr
    561. 			return cur;
    562. 		}
    563. 		Node* GetRoot()//获取根节点
    564. 		{
    565. 			return _root;
    566. 		}
    567. 		bool IsValidRBTree()
    568. 		{
    569. 			Node* root = GetRoot();
    570. 			if (root == nullptr)
    571. 			{
    572. 				return true;//空树也是红黑树
    573. 			}
    574. 			if (_root->_col != BLACK)
    575. 			{
    576. 				cout << "违反性质2" << endl;
    577. 				return false;
    578. 			}
    579. 			//获取任何一条路径上的黑色节点数
    580. 			Node* cur = root;
    581. 			size_t blackSize = 0;
    582. 			while (cur)
    583. 			{
    584. 				if (cur->_col == BLACK)
    585. 				{
    586. 					++blackSize;
    587. 				}
    588. 				cur = cur->_right;
    589. 			}
    590. 			size_t k = 0;
    591. 			return _IsValidRBTree(root, k, blackSize);
    592. 		}
    593. 		bool _IsValidRBTree(Node* pRoot, size_t k, size_t blackSize)
    594. 		{
    595. 			//走到空的时候判断k和black和是否相等
    596. 			if (pRoot == nullptr)
    597. 			{
    598. 				if (k != blackSize)
    599. 				{
    600. 					cout << "违反性质4" << endl;
    601. 					cout << k << " " << blackSize << endl;
    602. 					return false;
    603. 				}
    604. 				return true;
    605. 			}
    606. 			if (BLACK == pRoot->_col)
    607. 			{
    608. 				++k;
    609. 			}
    610. 			//检测当前节点与其双亲节点是否为红色
    611. 			Node* parent = pRoot->_parent;
    612. 			if (parent && parent->_col == RED && pRoot->_col == RED)
    613. 			{
    614. 				cout << "违反性质3：没有连在一起的红节点" << endl;
    615. 				return false;
    616. 			}
    617. 			return _IsValidRBTree(pRoot->_left, k, blackSize) 
    618. 				&& _IsValidRBTree(pRoot->_right, k, blackSize);
    619. 		}
    620. 	private:
    621. 		Node* _root;
    622. 	};
    623. }

    4.红黑树与AVL树的比较  

             红黑树和AVL树都是高度平衡的二叉搜索树，增删查改的时间复杂度都是O(logN),红黑色不追求绝对的平衡，其只需要保证最长路径不超过最短路径的两倍即可，相对而言，红黑树降低了插入和删除时旋转的次数，所以在经常需要增删的的结构中比AVL树更优，而且红黑树的实现较为简单，所以在实际中红黑树用的更多一些。

    5.红黑树的应用

            红黑树作为一种高效搜索的数据结构，在很多地方都有它的运用，比如在C++STL库里面的map/set，mutil_map/mutil_set。其他语言比如Java的库里面也用了红黑树，比如著名的开源操作系统linux中也用到了红黑树等等... 

     

  • 相关阅读:
    汇编语言（6）使用JCC指令构造分支与循环
    高并发架构设计经验
    C语言，洛谷题，赦免战俘
    EasyCVR平台设备在线，播放视频却提示离线是什么原因？
    LeetCode-1710. 卡车上的最大单元数【自定义排序，贪心】
    【UiBot科普】什么是RPA企业级框架？
    ECCV 2022｜经典算法老当益壮，谷歌提出基于k-means聚类的视觉Transformer
    性能优化总纲
    apifox怎么测试API，你学会了吗？
    dubbo telnet使用
  • 原文地址：https://blog.csdn.net/m0_68641696/article/details/133269565