2024年最新红黑树（C++实现）_c+(1)，2024年最新看完我工资从12K变成了20K

2401_85014040

于 2024-05-14 08:36:32 发布

阅读量597

点赞数 8

分类专栏：程序员文章标签：物联网嵌入式硬件学习

本文链接：https://blog.csdn.net/2401_85014040/article/details/138835862

版权

程序员专栏收录该内容

16 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

}
else //新结点的key值大于parent的key值
{
	//插入到parent的右边
	parent->_right = cur;
	cur->_parent = parent;
}

//3、若插入结点的父结点是红色的，则需要对红黑树进行调整
while (parent&&parent->_col == RED)
{
	Node\* grandfather = parent->_parent; //parent是红色，则其父结点一定存在
	if (parent == grandfather->_left) //parent是grandfather的左孩子
	{
		Node\* uncle = grandfather->_right; //uncle是grandfather的右孩子
		if (uncle&&uncle->_col == RED) //情况1：uncle存在且为红
		{
			//颜色调整
			parent->_col = uncle->_col = BLACK;
			grandfather->_col = RED;

			//继续往上处理
			cur = grandfather;
			parent = cur->_parent;
		}
		else //情况2+情况3：uncle不存在 + uncle存在且为黑
		{
			if (cur == parent->_left)
			{
				RotateR(grandfather); //右单旋

				//颜色调整
				grandfather->_col = RED;
				parent->_col = BLACK;
			}
			else //cur == parent->\_right
			{
				RotateLR(grandfather); //左右双旋

				//颜色调整
				grandfather->_col = RED;
				cur->_col = BLACK;
			}
			break; //子树旋转后，该子树的根变成了黑色，无需继续往上进行处理
		}
	}
	else //parent是grandfather的右孩子
	{
		Node\* uncle = grandfather->_left; //uncle是grandfather的左孩子
		if (uncle&&uncle->_col == RED) //情况1：uncle存在且为红
		{
			//颜色调整
			uncle->_col = parent->_col = BLACK;
			grandfather->_col = RED;

			//继续往上处理
			cur = grandfather;
			parent = cur->_parent;
		}
		else //情况2+情况3：uncle不存在 + uncle存在且为黑
		{
			if (cur == parent->_left)
			{
				RotateRL(grandfather); //右左双旋

				//颜色调整
				cur->_col = BLACK;
				grandfather->_col = RED;
			}
			else //cur == parent->\_right
			{
				RotateL(grandfather); //左单旋

				//颜色调整
				grandfather->_col = RED;
				parent->_col = BLACK;
			}
			break; //子树旋转后，该子树的根变成了黑色，无需继续往上进行处理
		}
	}
}
_root->_col = BLACK; //根结点的颜色为黑色（可能被情况一变成了红色，需要变回黑色）
return make\_pair(newnode, true); //插入成功

}

//左单旋
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
Node* parentParent = parent->_parent;

//建立subRL与parent之间的联系
parent->_right = subRL;
if (subRL)
	subRL->_parent = parent;

//建立parent与subR之间的联系
subR->_left = parent;
parent->_parent = subR;

//建立subR与parentParent之间的联系
if (parentParent == nullptr)
{
	_root = subR;
	_root->_parent = nullptr;
}
else
{
	if (parent == parentParent->_left)
	{
		parentParent->_left = subR;
	}
	else
	{
		parentParent->_right = subR;
	}
	subR->_parent = parentParent;
}

}

//右单旋
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
Node* parentParent = parent->_parent;

//建立subLR与parent之间的联系
parent->_left = subLR;
if (subLR)
	subLR->_parent = parent;

//建立parent与subL之间的联系
subL->_right = parent;
parent->_parent = subL;

//建立subL与parentParent之间的联系
if (parentParent == nullptr)
{
	_root = subL;
	_root->_parent = nullptr;
}
else
{
	if (parent == parentParent->_left)
	{
		parentParent->_left = subL;
	}
	else
	{
		parentParent->_right = subL;
	}
	subL->_parent = parentParent;
}

}

//左右双旋
void RotateLR(Node* parent)
{
RotateL(parent->_left);
RotateR(parent);
}

//右左双旋
void RotateRL(Node* parent)
{
RotateR(parent->_right);
RotateL(parent);
}


**注意：** 在红黑树调整后，需要将根结点的颜色变为黑色，因为红黑树的根结点可能在情况一的调整过程中被变成了红色。


## 红黑树的验证


红黑树也是一种特殊的二叉搜索树，因此我们可以先获取二叉树的中序遍历序列，来判断该二叉树是否满足二叉搜索树的性质。


**代码如下：**

//中序遍历
void Inorder()
{
_Inorder(_root);
}
//中序遍历子函数
void _Inorder(Node* root)
{
if (root == nullptr)
return;
_Inorder(root->_left);
cout << root->_kv.first << " ";
_Inorder(root->_right);
}


但中序有序只能证明是二叉搜索树，要证明二叉树是红黑树还需验证该二叉树是否满足红黑树的性质。


**代码如下：**

//判断是否为红黑树
bool ISRBTree()
{
if (_root == nullptr) //空树是红黑树
{
return true;
}
if (_root->_col == RED)
{
cout << “error：根结点为红色” << endl;
return false;
}

//找最左路径作为黑色结点数目的参考值
Node\* cur = _root;
int BlackCount = 0;
while (cur)
{
	if (cur->_col == BLACK)
		BlackCount++;
	cur = cur->_left;
}

int count = 0;
return \_ISRBTree(_root, count, BlackCount);

}
//判断是否为红黑树的子函数
bool _ISRBTree(Node* root, int count, int BlackCount)
{
if (root == nullptr) //该路径已经走完了
{
if (count != BlackCount)
{
cout << “error：黑色结点的数目不相等” << endl;
return false;
}
return true;
}

if (root->_col == RED&&root->_parent->_col == RED)
{
	cout << "error：存在连续的红色结点" << endl;
	return false;
}
if (root->_col == BLACK)
{
	count++;
}
return \_ISRBTree(root->_left, count, BlackCount) && \_ISRBTree(root->_right, count, BlackCount);

}


## 红黑树的查找


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


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


**代码如下：**

//查找函数
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (key < cur->_kv.first) //key值小于该结点的值
{
cur = cur->_left; //在该结点的左子树当中查找
}
else if (key > cur->_kv.first) //key值大于该结点的值
{
cur = cur->_right; //在该结点的右子树当中查找
}
else //找到了目标结点
{
return cur; //返回该结点
}
}
return nullptr; //查找失败
}


## 红黑树的删除


红黑树的删除要比插入更加难以理解，但是只要仔细一点也还行。



> 
> 第一步：找到实际待删除的结点
> 
> 
> 


找结点的过程与二叉搜索树寻找待删除结点的方法一样，若找到的待删除结点的左右子树均不为空，则需要使用替换法进行删除。因此我们最终需要删除的都是左右子树至少有一个为空的结点。


找到实际待删除结点后，先不删除该结点，否则调整红黑树时不容易控制，找到实际待删除结点后立即进行红黑树的调整。



> 
> 第二步：调整红黑树
> 
> 
> 


调整红黑树之前，我们先判断一下本次结点的删除是否会破坏了红黑树的性质，若破坏了我们才需要对红黑树进行调整。


若实际删除的结点是红色结点，那么本次删除操作不会破坏红黑树的性质，因此我们不需要对红黑树进行调整。反之，若删除的结点是黑色结点，我们就需要对红黑树进行调整，因为黑色结点的删除将会使得一些路径中黑色结点的数目减少，此时便破坏了红黑树的性质四。



> 
> 我们先来说最简单的一种情况，即待删除结点只有一个孩子为空的情况。
> 
> 
> 


在这种情况下，待删除结点要么是只有左孩子，要么是有只右孩子，但不管是左孩子还是右孩子，这个孩子一定是红色的，因为若这个孩子是黑色的，那么此时图示长蓝色路径的黑色结点数目比短蓝色路径的黑色结点数目多，不符合红黑树的性质。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/4b8e5b0d93cb4819a8bd3de0e06332ec.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAMjAyMWRyYWdvbg==,size_20,color_FFFFFF,t_70,g_se,x_16)  
 又因为红黑树当中不允许出现连续的红色结点，因此在这种情况下实际上就只有图示两种实际情况，这时我们直接将待删除结点的那个红孩子变成黑色就行了，因为在后面实际删除结点时会将这个孩子连接到删除结点的父结点下面，连接后相当于我们删除的是一个红色结点，红黑树调整完成。



> 
> 下面再来说比较复杂的情况，即待删除结点的左右孩子均为空。
> 
> 
> 


我们以待删除结点是其父结点的左孩子为例，分为以下四种情况：



> 
> 图示说明：
> 
> 
> 1. 若parent结点为白色，表明parent结点可能是红色结点也可能是黑色结点。
> 2. 若bL或bR结点为白色，表明其可能是红色结点或黑色结点甚至该结点不存在。
> 3. bL和bR结点为黑色时，表明他们可能是黑色结点或该结点不存在。
> 
> 
> 


**情况一：brother为红色。**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/e27206ce692a44a583d84570eafcfac1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAMjAyMWRyYWdvbg==,size_20,color_FFFFFF,t_70,g_se,x_16)  
 当待删除结点的brother为红色时，我们先以parent为旋转点进行一次左单旋，再将brother的颜色变为黑色，将parent的颜色变为红色，此时我们再对待删除结点cur进行情况分析，情况一就转换成了情况二、三或四。


**情况二：brother为黑色，且其左右孩子都是黑色结点或为空。**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/edf85852313e42e3bc8f1c626b56ffe4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAMjAyMWRyYWdvbg==,size_20,color_FFFFFF,t_70,g_se,x_16)  
 在该情况下，我们直接将brother的颜色变成红色，此时根据parent的颜色决定红黑树的调整是否结束，若parent的颜色是红色，则我们将parent变为黑色后即可结束红黑树的调整；若parent的颜色原本就是黑色，则我们需要将parent结点当作下一次调整时的cur结点进行情况分析，并且情况二在下一次调整时可能会是情况一、二、三、四当中的任何一种。


**情况三：brother为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空。**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/986d7256dbe84b77a46017973a129974.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAMjAyMWRyYWdvbg==,size_20,color_FFFFFF,t_70,g_se,x_16)  
 出现该情况时，我们先以brother为旋转点进行一次右单旋，再将brother结点变为红色，将brotherLeft变为黑色，此时我们再对待删除结点cur进行情况分析，情况三就转换成了情况四。


**情况四：brother为黑色，且其右孩子是红色结点。**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/2d9ad5f1358745ffba4da7be115d2e10.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAMjAyMWRyYWdvbg==,size_20,color_FFFFFF,t_70,g_se,x_16)  
 经过情况四的处理后，红黑树就一定调整结束了。在情况四当中，我们先以parent为旋转点进行一次左单旋，然后将parent的颜色赋值给brother，再将parent的颜色变为黑色，最后将brotherRight变为黑色，此时红黑树的调整便结束了。



> 
> 说明一下：
> 
> 
> 1. 待删除结点是其父结点的右孩子时的四种情况与上面四种情况类似，这里就不列举出来了。
> 2. 若待删除结点没有父结点，即待删除结点是根结点时，在找到该结点时就进行了删除，这里不用考虑，具体看代码。
> 
> 
> 


这里有必要对各种情况的切换进行说明，你可能会担心调整红黑树时在这四种情况当中一直来回切换而不能跳出，下面我们来对此进行分析：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/44589ddbee024514aeac16c98733dfbc.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAMjAyMWRyYWdvbg==,size_20,color_FFFFFF,t_70,g_se,x_16)  
 首先，进入情况四后红黑树就一定调整结束了。其次，进入情况三后，下次也一定会进入情况四，红黑树的调整也会结束。所以情况三和情况四是没有问题的，你们最纠结的只能是情况一和情况二了。


情况一又会切换为情况二、三、四，因此只要情况二能够有办法退出，那么所有情况就都能退出了。


在情况二当中我们说，如果parent的颜色是红色，那么我们将parent变为黑色后就可以结束红黑树的调整，那会不会每次进入情况二时parent的颜色都不是红色，而一直是黑色的呢？


当然有可能，但是我们若一直往上进行调整时，那么总会调整到红黑树的根结点，当调整到根结点后我们便不用进行调整了，此时根结点虽然是黑色的，但是不影响，这仅仅意味着每条从根到叶子的路径上包含的黑色结点的个数都减少了一个，此时也没有破坏红黑树的性质，也就完成了红黑树的调整，因此在调整过程中不会出现一直在这四种情况来回切换而不能跳出的问题。



> 
> 第三步：进行结点的实际删除
> 
> 
> 


在红黑树调整完毕后，我们就可以进行结点的删除了，删除结点的方式很简单，若待删除结点有左孩子或右孩子，我们将其左孩子或右孩子连接到待删除结点父结点的下面即可，之后便可以将待删除结点删除了。


**代码如下：**

//删除函数
bool Erase(const K& key)
{
//用于遍历二叉树
Node* parent = nullptr;
Node* cur = _root;
//用于标记实际的待删除结点及其父结点
Node* delParentPos = nullptr;
Node* delPos = nullptr;
while (cur)
{
if (key < cur->_kv.first) //所给key值小于当前结点的key值
{
//往该结点的左子树走
parent = cur;
cur = cur->_left;
}
else if (key > cur->_kv.first) //所给key值大于当前结点的key值
{
//往该结点的右子树走
parent = cur;
cur = cur->_right;
}
else //找到了待删除结点
{
if (cur->_left == nullptr) //待删除结点的左子树为空
{
if (cur == _root) //待删除结点是根结点
{
_root = _root->_right; //让根结点的右子树作为新的根结点
if (_root)
{
_root->_parent = nullptr;
_root->_col = BLACK; //根结点为黑色
}
delete cur; //删除原根结点
return true;
}
else
{
delParentPos = parent; //标记实际删除结点的父结点
delPos = cur; //标记实际删除的结点
}
break; //进行红黑树的调整以及结点的实际删除
}
else if (cur->_right == nullptr) //待删除结点的右子树为空
{
if (cur == _root) //待删除结点是根结点
{
_root = _root->_left; //让根结点的左子树作为新的根结点
if (_root)
{
_root->_parent = nullptr;
_root->_col = BLACK; //根结点为黑色
}
delete cur; //删除原根结点
return true;
}
else
{
delParentPos = parent; //标记实际删除结点的父结点
delPos = cur; //标记实际删除的结点
}
break; //进行红黑树的调整以及结点的实际删除
}
else //待删除结点的左右子树均不为空
{
//替换法删除
//寻找待删除结点右子树当中key值最小的结点作为实际删除结点
Node* minParent = cur;
Node* minRight = cur->_right;
while (minRight->_left)
{
minParent = minRight;
minRight = minRight->_left;
}
cur->_kv.first = minRight->_kv.first; //将待删除结点的key改为minRight的key
cur->_kv.second = minRight->_kv.second; //将待删除结点的value改为minRight的value
delParentPos = minParent; //标记实际删除结点的父结点
delPos = minRight; //标记实际删除的结点
break; //进行红黑树的调整以及结点的实际删除
}
}
}
if (delPos == nullptr) //delPos没有被修改过，说明没有找到待删除结点
{
return false;
}

//记录待删除结点及其父结点（用于后续实际删除）
Node\* del = delPos;
Node\* delP = delParentPos;

//调整红黑树
if (delPos->_col == BLACK) //删除的是黑色结点
{
	if (delPos->_left) //待删除结点有一个红色的左孩子（不可能是黑色）
	{
		delPos->_left->_col = BLACK; //将这个红色的左孩子变黑即可
	}
	else if (delPos->_right) //待删除结点有一个红色的右孩子（不可能是黑色）
	{
		delPos->_right->_col = BLACK; //将这个红色的右孩子变黑即可
	}
	else //待删除结点的左右均为空
	{
		while (delPos != _root) //可能一直调整到根结点
		{
			if (delPos == delParentPos->_left) //待删除结点是其父结点的左孩子
			{
				Node\* brother = delParentPos->_right; //兄弟结点是其父结点的右孩子
				//情况一：brother为红色
				if (brother->_col == RED)
				{
					delParentPos->_col = RED;
					brother->_col = BLACK;
					RotateL(delParentPos);
					//需要继续处理
					brother = delParentPos->_right; //更新brother（否则在本循环中执行其他情况的代码会出错）
				}
				//情况二：brother为黑色，且其左右孩子都是黑色结点或为空
				if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
					&& ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
				{
					brother->_col = RED;
					if (delParentPos->_col == RED)
					{
						delParentPos->_col = BLACK;
						break;
					}
					//需要继续处理
					delPos = delParentPos;
					delParentPos = delPos->_parent;
				}
				else
				{
					//情况三：brother为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空
					if ((brother->_right == nullptr) || (brother->_right->_col == BLACK))
					{
						brother->_left->_col = BLACK;
						brother->_col = RED;
						RotateR(brother);
						//需要继续处理
						brother = delParentPos->_right; //更新brother（否则执行下面情况四的代码会出错）
					}
					//情况四：brother为黑色，且其右孩子是红色结点
					brother->_col = delParentPos->_col;
					delParentPos->_col = BLACK;
					brother->_right->_col = BLACK;
					RotateL(delParentPos);
					break; //情况四执行完毕后调整一定结束
				}
			}
			else //delPos == delParentPos->\_right //待删除结点是其父结点的左孩子
			{
				Node\* brother = delParentPos->_left; //兄弟结点是其父结点的左孩子
				//情况一：brother为红色
				if (brother->_col == RED) //brother为红色
				{
					delParentPos->_col = RED;
					brother->_col = BLACK;
					RotateR(delParentPos);
					//需要继续处理
					brother = delParentPos->_left; //更新brother（否则在本循环中执行其他情况的代码会出错）
				}
				//情况二：brother为黑色，且其左右孩子都是黑色结点或为空
				if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
					&& ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
				{
					brother->_col = RED;
					if (delParentPos->_col == RED)
					{
						delParentPos->_col = BLACK;
						break;
					}
					//需要继续处理
					delPos = delParentPos;
					delParentPos = delPos->_parent;
				}
				else
				{
					//情况三：brother为黑色，且其右孩子是红色结点，左孩子是黑色结点或为空
					if ((brother->_left == nullptr) || (brother->_left->_col == BLACK))
					{
						brother->_right->_col = BLACK;
						brother->_col = RED;
						RotateL(brother);
						//需要继续处理
						brother = delParentPos->_left; //更新brother（否则执行下面情况四的代码会出错）
					}
					//情况四：brother为黑色，且其左孩子是红色结点
					brother->_col = delParentPos->_col;
					delParentPos->_col = BLACK;
					brother->_left->_col = BLACK;
					RotateR(delParentPos);
					break; //情况四执行完毕后调整一定结束
				}
			}
		}
	}
}
//进行实际删除
if (del->_left == nullptr) //实际删除结点的左子树为空
{
	if (del == delP->_left) //实际删除结点是其父结点的左孩子
	{
		delP->_left = del->_right;
		if (del->_right)
			del->_right->_parent = delP;
	}
	else //实际删除结点是其父结点的右孩子
	{
		delP->_right = del->_right;
		if (del->_right)
			del->_right->_parent = delP;
	}
}
else //实际删除结点的右子树为空
{
	if (del == delP->_left) //实际删除结点是其父结点的左孩子
	{
		delP->_left = del->_left;
		if (del->_left)
			del->_left->_parent = delP;
	}
	else //实际删除结点是其父结点的右孩子
	{
		delP->_right = del->_left;
		if (del->_left)
			del->_left->_parent = delP;
	}
}
delete del; //实际删除结点
return true;

}


## 红黑树与AVL树的比较


红黑树和AVL树都是高效的平衡二叉树，增删查改的时间复杂度都是 
 
 
 
 
 O 
 
 
 ( 
 
 
 l 
 
 
 o 
 
 
 g 
 
 
 N 
 
 
 ) 
 
 


**收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。**
![img](https://img-blog.csdnimg.cn/img_convert/a6a3960f06f75281f1605c62ff7d881b.png)
![img](https://img-blog.csdnimg.cn/img_convert/0d55c05f026468fb739598d8f74274e1.png)

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人**

**都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

delP->_left = del->_left;
			if (del->_left)
				del->_left->_parent = delP;
		}
		else //实际删除结点是其父结点的右孩子
		{
			delP->_right = del->_left;
			if (del->_left)
				del->_left->_parent = delP;
		}
	}
	delete del; //实际删除结点
	return true;
}

红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删查改的时间复杂度都是

(

)

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
[外链图片转存中…(img-GwEfSO8I-1715646969127)]
[外链图片转存中…(img-T6lSO5Kg-1715646969128)]

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_85014040

关注

8
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
2024年最新红黑树（C++实现）_c+(1)，2024年最新看完我工资从12K变成了20K

/左单旋//右单旋//左右双旋//右左双旋//中序遍历//中序遍历子函数return;//判断是否为红黑树if (_root == nullptr) //空树是红黑树cout
复制链接

扫一扫