• 数据结构——红黑树

    目录

    红黑树的概念

    红黑树的性质

    红黑树的插入

    红黑树的查找

    红黑树的验证

    红黑树的删除操

    为什么有了AVL树还需要红黑树？

    AVL树的出现解决了二叉树会退化为单链表的情况，能把搜索时间控制在O（logN)，不过却不是最佳的。因为AVL树的插入和删除，可能会破坏AVL树中的左子树和右子树高度差不超过1的规则，即大量的插入结点和删除结点可能会引发频繁的旋转操作。使得AVL树的性能大打折扣，为了解决AVL树会频繁旋转的问题，又发明了红黑树。

    红黑树的概念


    红黑树是二叉搜索树中的一种，是在搜索二叉树的基础上在每个结点中增加了1个存储位，用于表示结点的颜色，颜色可以是红色，也可以是黑色。因此称红黑树。红黑树是通过对任何一条从根结点到叶子结点的路径上的各个结点的颜色进行限制，确保最长路径的结点数不超过最短路径的结点数的两倍，所以红黑树还是近似平衡的。

    红黑树的性质

    1.每个结点不是红色就是黑色。
    2. 红黑树的根结点是黑色的。
    3.如果一个结点是红色的，那么它的孩子结点都是黑色的，即一条路径上不能同时出现两个连续的红色结点。

    4.对于每个结点，从该结点到其所有后代的叶子结点的简单路径上，均包含相同数目的黑色结点。
    5、每个叶子结点都是黑色的(指空结点)。

    为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

    从红黑树的性质3可以得出，红黑树中不会出现连续的红色结点，而根据性质4，可以从任何一个结点其后代叶子结点的所有路径土包含的黑色结点数相同。
    假设有一个结点其到叶子结点的最短路径上的结点全部为黑色结点设黑色结点数为N，而最长路径可能是由一黑一红构成的路径，其路径上的黑色结点树也为N，红色结点也N总结点数为2N，因此最长路径不会超过最短路径的两位倍。

    思考：在向红黑树插入新增结点时，默认应该没为红色还是黑色？

    在未插入新增结点前，红黑树中，任何一个结点到叶子结点的路径上的黑色结点数目都是一样的。

    若新增结点默认为黑色，就一定破坏这个规则，即违反红黑树的性质4，此时就需要对红黑树进行调整。

    若新增结点默认为红色，如果此时父结点也是红色的，那么就出现了连续的红色结点，即违反了红黑树的性质3，此时也需要对红黑树进行调整。但如果新增结点的父结点是黑色的就不需要进行调整，也就是说如果新结点默认为黑色就，一定会破坏性质4，必须进行调整处理。新增结点默认为红色，可能会违反性质3，可能要进行调整处理。

    即默认黑色一定要进行调整，默认红色不一定要调整，因此在构选新增结点时，我们将默颜色设为红色。
    结点构造

    1. enum clour
    2. {
    3. 	RED,
    4. 	BLACK
    5. };
    6. template<class k, class v>
    7. struct RBTreeNode
    8. {
    9. 	//三叉链
    10. 	RBTreeNode* _left;
    11. 	RBTreeNode* _right;
    12. 	RBTreeNode* _parent;
    13. 	pair _kv;
    14. 	//存储的键对值
    15. 	
    16.  
    17. 	//结点的颜色
    18. 	int _col;//红or黑
    19.  
    20. 	//构造函数
    21. 	RBTreeNode(const pair& kv)
    22. 		:_left(nullptr)
    23. 		, _right(nullptr)
    24. 		, _parent(nullptr)
    25. 		, _kv(kv),_col(RED)//默认红色
    26. 	{}
    27.  
    28.  
    29. };


    红黑树的插入


    其步骤为三步：
    1.按照新增结点中的key值与前结点的ken值相比，小于则往该结点的左子树走，大于则往该结点右边走，等于则插入失则，走到空就是找到了插入的置位。
    2.进行插入操作。
    3.插入后进行判断是否要进行调整操作。
    红黑树的调整操作
    当插入新增结点后，如果新增结的父结点颜色为黑色则不需要调整操作，因为此时并不违反红黑树性质。

    如果插入新增结的父结点颜色为红色则需要进行调整操作，即出现了连续红色结点违反了规则3。 ，

    当新增结点的父结点颜色是红色时说明其父结点不是树的根结点，红黑树的根结点是黑色的。因此说明新增经点的祖父结点一定存在，红黑树的调整操作是根据新增结点的叔叔结点（父结点的兄弟结点）的颜色和是否存在的情况进行相应的调整操作的。
    叔叔结点的存在与否和颜色情况可以分为三种：
    1.叔叔结点存在且颜色为红色。
    2.叔叔结点存在且颜色为黑色。
    3.叔叔结点不存在。
    情况一：叔对结点存在且颜色为红色。
    当叔叔存在为红色时，将新增结点的父结点的颜色变为黑色，将祖父结点变红色，再将叔叔结点的颜色变为黑色，这样即保持了每条是各径上的黑色结点数目都保持不变，也解决的出现连续红色结点的问题。


    但调整并没有结束，因为祖父结点的颜色为红色，如果组父结点为整棵树的根结点时，祖父结点变为红色，就违反了红黑树根为黑的性质。此时我们直接将祖文结点的颜色改为黑色即可，相当于每条路径都增加了一个黑色结点。


    但如果祖父结点不是红黑树的根结点时，我们就要将不结点传为新增结点，再判断祖父结点的父结点颜色是否为红色，若为红色，则又根据祖父结点的叔叔结点颜色及存在情况再进行调整操作。所以叔叔结点存在且颜色为红色的调整操作如图：


    注意，新增结点的叔叔结点存在时，不管新增结点是左孩子结点，还是右孩子结点其操作都是一样的。


    情况二：叔叔结点存在且颜色为黑色。
    这种情况是因为情况一向上调整出现的，即这种情况下的cur结点不是新增结点，我们可以通过下图分析。


    我们将红黑树根结点到图中的祖父结点之间的黑色结点数目设为x(不包含祖父结点)，将叔叔结点之下的黑色结点数目设为y，所以两条路径上的黑色结点数盼别为x+1、x+2+y，很显然x+1一定不等于x+2+y，不满足红黑树的要求，即不存在新增结点的叔叔存在且颜色为黑色的情况，这种情况是情况一在调整过程中出现的。


    注意：这里说的路径指的是从根结点到指针指向空的位置，而不是只有从根结点到叶子结点才能算路径。

    当出现情况二时，使用单纯的变色已无法处理，这时就要通过先旋转再变色完调整。
    若cur结点位于父结点的左子树，父结点位于祖父结点的左子树，则进行右单旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

    若cur结点位于父结点的右子树，父结点位于祖父结点的右子树，则进行左单旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

    若cur结点位于父结点的右子树，父结点位于祖父结点的左子树，则进行左右双旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

    若cur结点位于父结点的左子树，父结点位于祖父结点的右子树，则进行右左双旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

    旋转完后将新的根结点颜色变为黑色，这时就不再需要继续向上调整了。


    情况三：新增结点的叔叔结点不存在。
    这种情况不可能是由情况一调整而来的，因为叔叔结点不存在说明parent下面没有黑色结点了，不然就违返了路径的黑色结点数目相同原则，所以cur一定是新增结点。

    若cur结点位于父结点的左子树，父结点位于祖父结点的左子树，则进行右单旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

    右单旋代码

    1.  
    2. 	void RotateR(Node* parent)
    3. 	{
    4. 		Node* subL = parent->_left;
    5. 		Node* subLR = subL->_right;
    6. 		Node* pparent = parent->_parent;
    7.         //1、将subRL链接称为parent的右子树。
    8.  
    9. 		parent->_left = subLR;
    10. 		if (subLR)
    11. 		{
    12. 			subRL->_parent = parent;
    13. 		}
    14.  
    15.         //2、让parent成为subR的左子树。
    16.  
    17. 		subL->_right = parent;
    18. 		parent->_parent = subL;
    19.  
    20.         //3、让subR成为这颗最小不平衡子树的根。
    21.  
    22. 		if (pparent==nullptr)
    23. 		{
    24. 			_root = subL;
    25. 			_root->_parent = nullptr;
    26. 		}
    27. 		else
    28. 		{
    29. 			if (pparent->_left == parent)
    30. 			{
    31. 				pparent->_left = subL;
    32. 				subL->_parent = pparent;
    33. 			}
    34. 			if (pparent->_right == pparent)
    35. 			{
    36. 				pparent->_right = subL;
    37. 				subL->_parent = pparent;
    38. 			}
    39. 		}
    40.        
    41. 	}

    若cur结点位于父结点的右子树，父结点位于祖父结点的右子树，则进行左单旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

    左单旋代码 

    1. void RotateL(Node* parent)
    2. 	{
    3. 		Node* subR = parent->_right;
    4. 		Node* subRL = subR->_left;
    5. 		Node* pparent = parent->_parent;
    6.         
    7.  
    8.        // 1、将subRL链接称为parent的右子树。
    9. 		parent->_right = subRL;
    10. 		if (subRL)
    11. 		{
    12. 			subRL->_parent = parent;
    13. 		}
    14.         //2、让parent成为subR的左子树。
    15. 		subR->_left = parent;
    16. 		parent->_parent = subR;
    17.         //3、让subR成为这颗最小不平衡子树的根。
    18. 		if (pparent == nullptr)//parent为根结点
    19. 		{
    20. 			_root = subR;//更新subR为根结点
    21. 			_root->_parent = nullptr;
    22. 		}
    23.  
    24. 		else//parent不为根结点
    25. 		{
    26. 			if (pparent->_left == parent)
    27. 			{
    28. 				subR->_parent==pparent;
    29. 				pparent->_left = subR;
    30. 			}
    31. 			else
    32. 			{
    33.  
    34. 				subR->_parent == pparent;
    35. 				pparent->_right = subR;
    36. 			}
    37. 			
    38. 		}
    39. 	}

    若cur结点位于父结点的右子树，父结点位于祖父结点的左子树，则进行左右双旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

    左右双旋代码 

    1.  
    2. 	void RotateLR(Node* parent)
    3. 	{
    4. 		RotateL(parent->_left);
    5. 		RotateR(parent);
    6. 	}

     若cur结点位于父结点的左子树，父结点位于祖父结点的右子树，则进行右左双旋，旋转完后将父结点颜色变为黑色，将祖父结点的颜色变为红色，这时就不再需要继续向上调整了。

     右左双旋代码

    1.  
    2. 	//右左双旋
    3. 	void RotateRL(Node* parent)
    4. 	{
    5. 		RotateR(parent->_right);
    6. 		RotateL(parent);
    7. 	}

    插入函数代码：

    1. //插入函数
    2. 	pairbool> Insert(const pair& kv)
    3. 	{
    4. 		if (_root == nullptr) //若红黑树为空树，则插入结点直接作为根结点
    5. 		{
    6. 			_root = new Node(kv);
    7. 			_root->_col = BLACK; //树的根结点的颜色必须是黑色
    8. 			return make_pair(_root, true); 
    9. 		}
    10. 		//1、按照key值小于当前结点的key值往左走
    11. 		//key值大于当前结点的key值往右走，找到待插入的位置
    12. 		Node* cur = _root;
    13. 		Node* parent = nullptr;
    14. 		while (cur)
    15. 		{
    16. 			if (kv.first < cur->_kv.first) //待插入结点的key值小于当前结点的key值
    17. 			{
    18. 				//往该结点的左子树走
    19. 				parent = cur;
    20. 				cur = cur->_left;
    21. 			}
    22. 			else if (kv.first > cur->_kv.first) //待插入结点的key值大于当前结点的key值
    23. 			{
    24. 				//往该结点的右子树走
    25. 				parent = cur;
    26. 				cur = cur->_right;
    27. 			}
    28. 			else //key值冗余插入失败
    29. 			{
    30. 				return make_pair(cur, false); 
    31. 			}
    32. 		}
    33. 		//找到了
    34.  
    35. 		//2、新增结点插入到树中
    36. 		cur = new Node(kv); //构造新结点
    37. 		Node* newnode = cur; 
    38. 		if (kv.first < parent->_kv.first) //新增结点的key值小于parent的key值
    39. 		{
    40. 			//新增结点插入到parent的左边
    41. 			parent->_left = cur;
    42. 			cur->_parent = parent;
    43. 		}
    44. 		else //新增结点的key值大于parent的key值
    45. 		{
    46. 			//新增结点插入到parent的右边
    47. 			parent->_right = cur;
    48. 			cur->_parent = parent;
    49. 		}
    50.  
    51. 		//3、若插入结点的父结点是红色的，对红黑树进行调整
    52. 		while (parent && parent->_col == RED)
    53. 		{
    54. 			Node* grandfather = parent->_parent; //parent的颜色是红色，则parent不是根结点
    55. 			if (parent == grandfather->_left) //parent是grandfather的左孩子
    56. 			{
    57. 				Node* uncle = grandfather->_right; //uncle是grandfather的右孩子
    58. 				if (uncle && uncle->_col == RED) //情况1：uncle存在且为红
    59. 				{
    60. 					//调整颜色
    61. 					parent->_col = uncle->_col = BLACK;
    62. 					grandfather->_col = RED;
    63.  
    64. 					//继续往上调整
    65. 					cur = grandfather;
    66. 					parent = cur->_parent;
    67. 				}
    68. 				else //uncle不存在和uncle存在且为黑
    69. 				{
    70. 					if (cur == parent->_left)
    71. 					{	
    72. 						//先进行右单旋再调整颜色
    73. 						RotateR(grandfather); 
    74. 						grandfather->_col = RED;
    75. 						parent->_col = BLACK;
    76. 					}
    77. 					else 
    78. 					{
    79. 						//先进行左右双旋再调整颜色
    80. 						RotateLR(grandfather); 
    81. 						grandfather->_col = RED;
    82. 						cur->_col = BLACK;
    83. 					}
    84. 					break; //子树旋转后，该子树的根变成了黑色，无需继续往上进行处理
    85. 				}
    86. 			}
    87. 			else //parent是grandfather的右孩子
    88. 			{
    89. 				Node* uncle = grandfather->_left; //uncle是grandfather的左孩子
    90. 				if (uncle && uncle->_col == RED) //uncle存在且为红
    91. 				{
    92. 					//调整颜色
    93. 					uncle->_col = parent->_col = BLACK;
    94. 					grandfather->_col = RED;
    95.  
    96. 					//继续往上调整
    97. 					cur = grandfather;
    98. 					parent = cur->_parent;
    99. 				}
    100. 				else //uncle不存在和uncle存在且为黑
    101. 				{
    102. 					if (cur == parent->_left)
    103. 					{
    104. 						//先进行右左双旋再调整颜色
    105. 						RotateRL(grandfather); 
    106. 						cur->_col = BLACK;
    107. 						grandfather->_col = RED;
    108. 					}
    109. 					else 
    110. 					{
    111. 						//先进行左单旋再调整颜色
    112. 						RotateL(grandfather); 
    113. 						grandfather->_col = RED;
    114. 						parent->_col = BLACK;
    115. 					}
    116. 					break; //该子树的根变成了黑色，无需继续往上进行处理
    117. 				}
    118. 			}
    119. 		}
    120. 		_root->_col = BLACK; //根结点的颜色为黑色（可能被情况一变成了红色，需要变回黑色）
    121. 		return make_pair(newnode, true); //插入成功
    122. 	}

    红黑树的查找


    红黑树的查找函数与二叉搜索树的查找方式一模一样，逻辑如下：

    若树为空树，则查找失败，返回nullptr。
    若key值小于当前结点的值，则应该在该结点的左子树当中进行查找。
    若key值大于当前结点的值，则应该在该结点的右子树当中进行查找。
    若key值等于当前结点的值，则查找成功，返回对应结点。

    查找函数代码

    1.  
    2. 	Node* Find(const K& key)
    3. 	{
    4. 		//从根结点开始，若树为空树，
    5. 		Node* cur = _root;
    6. 		while (cur)
    7. 		{
    8. 			if (key < cur->_kv.first) //若key值小于当前结点的值，则往当前结点的左子树当中进行查找。
    9. 			{
    10. 				cur = cur->_left; //在该结点的左子树当中查找
    11. 			}
    12. 			else if (key > cur->_kv.first) //若key值大于当前结点的值，则往当前结点的右子树当中进行查找。
    13. 			{
    14. 				cur = cur->_right; //在该结点的右子树当中查找
    15. 			}
    16. 			else //若key值等于当前结点的值，则查找成功，返回对应结点。
    17. 			{
    18. 				return cur; //返回该结点
    19. 			}
    20. 		}
    21. 		return nullptr; //树中没有key值查找失败，返回nullptr。
    22. 	}


    红黑树的验证

    1.  
    2. bool ISRBTree()
    3. {
    4. 	if (_root == nullptr) //空树是红黑树
    5. 	{
    6. 		return true;
    7. 	}
    8. 	if (_root->_col == RED)
    9. 	{
    10. 		cout << "error：根结点为红色" << endl;
    11. 		return false;
    12. 	}
    13. 	
    14. 	Node* cur = _root;
    15. 	int BlackCount = 0;
    16. 	while (cur)
    17. 	{
    18. 		if (cur->_col == BLACK)
    19. 			BlackCount++;
    20. 		cur = cur->_left;
    21. 	}
    22.  
    23. 	int count = 0;
    24. 	return _ISRBTree(_root, count, BlackCount);
    25. }
    26.  
    27. bool _ISRBTree(Node* root, int count, int BlackCount)
    28. {
    29. 	if (root == nullptr) 
    30. 	{
    31. 		if (count != BlackCount)
    32. 		{
    33. 			cout << "error：黑色结点的数目不相等" << endl;
    34. 			return false;
    35. 		}
    36. 		return true;
    37. 	}
    38.  
    39. 	if (root->_col == RED&&root->_parent->_col == RED)
    40. 	{
    41. 		cout << "error：存在连续的红色结点" << endl;
    42. 		return false;
    43. 	}
    44. 	if (root->_col == BLACK)
    45. 	{
    46. 		count++;
    47. 	}
    48. 	return _ISRBTree(root->_left, count, BlackCount) && _ISRBTree(root->_right, count, BlackCount);
    49. }

    红黑树的删除操


    查找并进行删除操。
    查找的逻辑与查找函数一致，找到待删除结点后，若待删除结点的左右子树均不为空，需要先找到“替代结点N”来替代待删除结点而被实际的删除，也就是说删除的是替代点，而替代结点至少有一个子结点为空。

    若替代结点N为红色，则两个子结点一定都空，直接将替代结点删除，不违反红黑树任何性质，此时删除操作结束。

    若替代结点为黑色， 替代结点N的一个子结点不为空，则这个子结点一定是红色的，且这个子结点的子结点都是空（黑高性质），那么将这个子结点占有替代结点的位置，并且这个结点的颜色变为黑色，删除替代结点。不违反红黑树性质，删除操作结束。

    若替代结点N为黑色，另一个子结点也为空，把替代结点N删除后，违反黑高，那么此时就要以替代结点为起点进行情况分析，然后执行相应操作。这里将替代结点叫N结点，P为父结点 S为N的兄弟结点。
    情况一：S为红色(那么P为黑色，子节点也黑)。


    操作以P为根结点将子树进行左单旋，然后变P红，S变黑。


    解析：

    在这种情况下：P左边少了一个黑色结点，旋转后N头上增加一个红色结点，但通过N的路径仍少一个黑结点需要再对N的情况进一步分析。

    情形2：P、S及S的孩子们都为黑。

    操作：S改为红色，未结束。


    解析：S变为红色后经过S节点的路径的黑节点数目也减少了1，那个从P出发到其叶子节点到所有路径所包含的黑节点数目（记为num）相等了。但是这个num比之前少了1，因为左右子树中的黑节点数目都减少了！一般地，P是他父节点G的一个孩子，那么由G到其叶子节点的黑节点数目就不相等了，所以说没有结束，需把P当做新的起始点开始向上检索。

    情形3：P为红（S一定为黑），S的孩子们都为黑。

    操作：P该为黑，S改为红，结束。

    解析：这种情况最简单了，既然N这边少了一个黑节点，那么S这边就拿出了一个黑节点来共享一下，这样一来，S这边没少一个黑节点，而N这边便多了一个黑节点，这样就恢复了平衡，多么美好的事情哈！


     

    情形4：P任意色，S为黑，N是P的左孩子，S的右孩子SR为红，S的左孩子任意（或者是N是P的右孩子，S的左孩子为红，S的右孩子任意）。


    操作：SR（SL）改为黑，P改为黑，S改为P的颜色，P、S变换--这里相对应于AVL中的右右中的旋转（或者是AVL中的左左旋转），结束。
    解析：P、S旋转有变色，等于给N这边加了一个黑节点，P位置（是位置而不是P）的颜色不变，S这边少了一个黑节点；SR有红变黑，S这边又增加了一个黑节点；这样一来又恢复了平衡，结束。

    情形5：P任意色，S为黑，N是P的左孩子，S的左孩子SL为红，S的右孩子SR为黑（或者N是P的有孩子，S的右孩子为红，S的左孩子为黑）。

    操作：SL（或SR）改为黑，S改为红，SL（SR）、S变换；此时就回到了情形4，SL（SR）变成了黑S，S变成了红SR（SL），做情形4的操作即可，这两次变换，其实就是对应AVL的右左的两次旋转（或者是AVL的左右的两次旋转）。
    解析：这种情况如果你按情形4的操作的话，由于SR本来就是黑色，你无法弥补由于P、S的变换（旋转）给S这边造成的损失！所以我没先对S、SL进行变换之后就变为情形4的情况了，何乐而不为呢？

    以下代码参考：2021dragon

    1. bool Erase(const K& key)
    2. 	{
    3. 		
    4. 		Node* parent = nullptr;
    5. 		Node* cur = _root;
    6. 		
    7. 		Node* delParentPos = nullptr;
    8. 		Node* delPos = nullptr;
    9. 		while (cur)
    10. 		{
    11. 			if (key < cur->_kv.first) 
    12. 			{
    13. 				
    14. 				parent = cur;
    15. 				cur = cur->_left;
    16. 			}
    17. 			else if (key > cur->_kv.first) 
    18. 			{
    19. 			
    20. 				parent = cur;
    21. 				cur = cur->_right;
    22. 			}
    23. 			else 
    24. 			{
    25. 				if (cur->_left == nullptr) 
    26. 				{
    27. 					if (cur == _root) 
    28. 					{
    29. 						_root = _root->_right; 
    30. 						if (_root)
    31. 						{
    32. 							_root->_parent = nullptr;
    33. 							_root->_col = BLACK; 
    34. 						}
    35. 						delete cur; 
    36. 						return true;
    37. 					}
    38. 					else
    39. 					{
    40. 						delParentPos = parent; 
    41. 						delPos = cur; 
    42. 					}
    43. 					break;
    44. 				}
    45. 				else if (cur->_right == nullptr)
    46. 				{
    47. 					if (cur == _root) 
    48. 					{
    49. 						_root = _root->_left; 
    50. 						if (_root)
    51. 						{
    52. 							_root->_parent = nullptr;
    53. 							_root->_col = BLACK; //根结点为黑色
    54. 						}
    55. 						delete cur; //删除原根结点
    56. 						return true;
    57. 					}
    58. 					else
    59. 					{
    60. 						delParentPos = parent; //标记实际删除结点的父结点
    61. 						delPos = cur; //标记实际删除的结点
    62. 					}
    63. 					break; //进行红黑树的调整以及结点的实际删除
    64. 				}
    65. 				else //待删除结点的左右子树均不为空
    66. 				{
    67. 					//替换法删除
    68. 					//寻找待删除结点右子树当中key值最小的结点作为实际删除结点
    69. 					Node* minParent = cur;
    70. 					Node* minRight = cur->_right;
    71. 					while (minRight->_left)
    72. 					{
    73. 						minParent = minRight;
    74. 						minRight = minRight->_left;
    75. 					}
    76. 					cur->_kv.first = minRight->_kv.first; //将待删除结点的key改为minRight的key
    77. 					cur->_kv.second = minRight->_kv.second; //将待删除结点的value改为minRight的value
    78. 					delParentPos = minParent; //标记实际删除结点的父结点
    79. 					delPos = minRight; //标记实际删除的结点
    80. 					break; //进行红黑树的调整以及结点的实际删除
    81. 				}
    82. 			}
    83. 		}
    84. 		if (delPos == nullptr) //delPos没有被修改过，说明没有找到待删除结点
    85. 		{
    86. 			return false;
    87. 		}
    88.  
    89. 		
    90. 		Node* del = delPos;
    91. 		Node* delP = delParentPos;
    92.  
    93. 		
    94. 		if (delPos->_col == BLACK) 
    95. 		{
    96. 			if (delPos->_left) 
    97. 			{
    98. 				delPos->_left->_col = BLACK; 
    99. 			}
    100. 			else if (delPos->_right) 
    101. 			{
    102. 				delPos->_right->_col = BLACK;
    103. 			}
    104. 			else
    105. 			{
    106. 				while (delPos != _root) 
    107. 				{
    108. 					if (delPos == delParentPos->_left) 
    109. 					{
    110. 						Node* brother = delParentPos->_right; 
    111. 						
    112. 						if (brother->_col == RED)
    113. 						{
    114. 							delParentPos->_col = RED;
    115. 							brother->_col = BLACK;
    116. 							RotateL(delParentPos);
    117. 						
    118. 							brother = delParentPos->_right; 
    119. 						}
    120. 						
    121. 						if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
    122. 							&& ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
    123. 						{
    124. 							brother->_col = RED;
    125. 							if (delParentPos->_col == RED)
    126. 							{
    127. 								delParentPos->_col = BLACK;
    128. 								break;
    129. 							}
    130. 							
    131. 							delPos = delParentPos;
    132. 							delParentPos = delPos->_parent;
    133. 						}
    134. 						else
    135. 						{
    136. 							
    137. 							if ((brother->_right == nullptr) || (brother->_right->_col == BLACK))
    138. 							{
    139. 								brother->_left->_col = BLACK;
    140. 								brother->_col = RED;
    141. 								RotateR(brother);
    142. 							
    143. 								brother = delParentPos->_right; 
    144. 							}
    145. 							
    146. 							brother->_col = delParentPos->_col;
    147. 							delParentPos->_col = BLACK;
    148. 							brother->_right->_col = BLACK;
    149. 							RotateL(delParentPos);
    150. 							break; 
    151. 						}
    152. 					}
    153. 					else
    154. 					{
    155. 						Node* brother = delParentPos->_left; 
    156. 						
    157. 						if (brother->_col == RED) 
    158. 						{
    159. 							delParentPos->_col = RED;
    160. 							brother->_col = BLACK;
    161. 							RotateR(delParentPos);
    162. 							
    163. 							brother = delParentPos->_left; 
    164. 						}
    165. 						
    166. 						if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
    167. 							&& ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
    168. 						{
    169. 							brother->_col = RED;
    170. 							if (delParentPos->_col == RED)
    171. 							{
    172. 								delParentPos->_col = BLACK;
    173. 								break;
    174. 							}
    175. 						
    176. 							delPos = delParentPos;
    177. 							delParentPos = delPos->_parent;
    178. 						}
    179. 						else
    180. 						{
    181. 							//情况三：brother为黑色，且其右孩子是红色结点，左孩子是黑色结点或为空
    182. 							if ((brother->_left == nullptr) || (brother->_left->_col == BLACK))
    183. 							{
    184. 								brother->_right->_col = BLACK;
    185. 								brother->_col = RED;
    186. 								RotateL(brother);
    187. 								//需要继续处理
    188. 								brother = delParentPos->_left; //更新brother（否则执行下面情况四的代码会出错）
    189. 							}
    190. 							//情况四：brother为黑色，且其左孩子是红色结点
    191. 							brother->_col = delParentPos->_col;
    192. 							delParentPos->_col = BLACK;
    193. 							brother->_left->_col = BLACK;
    194. 							RotateR(delParentPos);
    195. 							break; //情况四执行完毕后调整一定结束
    196. 						}
    197. 					}
    198. 				}
    199. 			}
    200. 		}
    201. 		//进行实际删除
    202. 		if (del->_left == nullptr) //实际删除结点的左子树为空
    203. 		{
    204. 			if (del == delP->_left) //实际删除结点是其父结点的左孩子
    205. 			{
    206. 				delP->_left = del->_right;
    207. 				if (del->_right)
    208. 					del->_right->_parent = delP;
    209. 			}
    210. 			else 
    211. 			{
    212. 				delP->_right = del->_right;
    213. 				if (del->_right)
    214. 					del->_right->_parent = delP;
    215. 			}
    216. 		}
    217. 		else
    218. 		{
    219. 			if (del == delP->_left)
    220.  
    221. 			{
    222. 				delP->_left = del->_left;
    223. 				if (del->_left)
    224. 					del->_left->_parent = delP;
    225. 			}
    226. 			else
    227. 			{
    228. 				delP->_right = del->_left;
    229. 				if (del->_left)
    230. 					del->_left->_parent = delP;
    231. 			}
    232. 		}
    233. 		delete del;
    234. 		return true;
    235. 	}

  • 相关阅读:
    什么是设计模式？你了解的设计模式是什么？
    固态存储是未来｜浅析SSD架构的演进与创新技术-1
    乘法器设计（流水线）verilog code
    笔记本电脑坏了硬盘数据会丢失吗 笔记本电脑坏了如何取出硬盘的资料 数据恢复软件
    代码随想录day58|739. 每日温度496. 下一个更大元素 I
    APEX：开启Android系统新篇章的应用扁平化技术
    js 找出两个数组中的重复元素
    Clion连接MySQL数据库：实现C/C++语言与MySQL交互
    一次清理全屋地面，一键清洁烘干无异味，KEEWOO启为C260 Pro洗地机上手
    Blazor 国际化多语言界面 (I18nText )
  • 原文地址：https://blog.csdn.net/weixin_66831846/article/details/133621659