红黑树介绍与实现

最新推荐文章于 2023-06-01 10:37:59 发布
最新推荐文章于 2023-06-01 10:37:59 发布
阅读量518 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 算法 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47812603/article/details/121735893
版权

红黑树介绍与实现


尽力做好一件事，实乃人生之首务。

红黑树的概念

红黑树是指每个节点都带有颜色属性的二叉搜索树，其颜色不是红色就是黑色，并且要在二叉搜索树的基础上要满足一些特殊的性质，因此被我们称之为红黑树。

红黑树的性质

一棵红黑树是满足下面红黑性质的二叉搜索树：

  1. 每个结点不是红色就是黑色。
  2. 根结点是黑色的。
  3. 如果一个结点是红色的，则它的两个子结点都是黑色的 (即不能出现连续的红结点)。
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。
  5. 每个叶节点(NIL)是黑色的 （此处的叶子结点指的是空结点）。

    推论：
    最短路径：全部都是由黑色结点构成。
    最长路径：一黑一红，红色结点的数量和黑色结点的数量相同。
    注意：正常红黑树中，不一定有全黑的最短路径和一黑一红的最长路径。

红黑树结点的定义

这里我们使用枚举类型来定义红黑树的颜色，当然也可以利用如bool类型来表示都是可以的。其中这里我们将结点定义成K-V模型，这是为了后面的博客中我们要用这同一颗红黑树来模拟实现map与set容器。

代码如下：

//节点的颜色
enum class Color
{
	RED,
	BLACK
};

//K-V模型
template<class K,class V>
struct RBTreeNode	//三叉链
{
	RBTreeNode<K,V>* m_left;	//左节点
	RBTreeNode<K,V>* m_right;   //右节点
	RBTreeNode<K,V>* m_parent;  //节点的父结点(红黑树需要 旋转 ，为了实现简单给出的该字段)

	pair<K, V>m_kv; //节点数据
	Color m_col;	//节点颜色


	RBTreeNode(const pair<K, V>& kv)
		: m_left(nullptr), m_right(nullptr), m_parent(nullptr)
		, m_kv(kv),m_col(Color::RED)
	{}
};

红黑树的插入操作

在我们要进行插入操作时，我们要想一个问题我们是插入黑色结点好，还是插入红色结点好呢？下面我们进行分析：

  1. 新插入的结点是红色，可能会破坏性质3，这导致有连续的红色结点，但也只影响这一条路径，影响不大。
  2. 新插入的结点是黑色，一定会破坏性质4，这导致每条路径的黑色结点数目不相同，破坏性强！！！

综上所述，我们选择新插入结点时插入红色结点。

红黑树是在二叉搜索树的基础上加上一些特殊的平衡限制性质，因此红黑树的插入与二叉搜索树插入类似，具体红黑树插入可分为两步：

  1. 先按照二叉搜索树的规则先找到插入位置，并插入。
  2. 再检测这个新插入的结点插入后，红黑树的性质是否遭到破坏。

由于新结点插入的颜色默认是红色，因此如果双亲parent为黑色，则不需要调整，直接插入完成，退出插入操作。
但如果双亲parent为红色时，这样就违反了性质3不能存在连续的红色结点的情况，因此需要对红黑树来进行调整，具体情况如下所示

  • 情况一：cur为红(新增结点)，parent为红，grandfather为黑，uncle存在且为红。
    处理方案为：parent和uncle变为黑色，grandfather变为红，但调整还没有结束，因为此时祖父结点变成了红色，我们要再判断祖父的父结点是否为红色，若其父结点也是红色，那么又需要根据其叔叔的不同，进而进行不同的调整操作。然后继续向上处理，直到parent存在且为黑的时候停止，或者parent不存在停止，如果grandfather是根，那么将根变黑。
    在这里插入图片描述
    在这里插入图片描述
  • 情况二：cur为红(新增结点),parent为红，且cur与parent为直线的时候，uncle不存在或者存在且为黑。
    处理方案为：旋转加变色处理，grandfather变红，parent变黑。
    并且uncle存在，一定是黑色，那么cur结点原来的颜色一定也是黑色的，现在看到是红色的原因是因为cur的子树再颜色调整的过程中将cur结点的颜色由黑色改变成红色，即从情况1向上处理后碰到情况2的情况，具体如下图中的例2所示：
    在这里插入图片描述
  • 情况三：cur为红(新增结点),parent为红，且cur与parent为折线的时候，uncle不存在或者存在且为黑。
    处理方案为：双旋加变色处理，cur变黑，grandfather变红。
    在这里插入图片描述
    代码如下：
	//传进来的是不平衡的结点的指针
	void RotateL(Node* parent)	//左旋
	{
		Node* subR = parent->m_right;	//出问题的右结点
		Node* subRL = subR->m_left;		//出问题的右结点的左结点

		parent->m_right = subRL;		//首先先将我们的parent的右指向subRL
		if (subRL != nullptr)			//再将subRL的父亲指向parent结点，但这样要判断一下是否是空指针，如果subRL是空指针的话，
										//那么解引用它会出现问题
		{
			subRL->m_parent = parent;
		}

		Node* curParent = parent->m_parent;	//拿一个结点存储parent的父亲
		parent->m_parent = subR;			//再使得parent的父亲指针指向它原先的右结点(subR)

		subR->m_left = parent;				//在让subR的左指向parent
		if (parent == m_root)				//在这里得判断一下它是否为根，如果parent为根的话，那么我们的根结点指针也得改变
											//并且将subR的父亲指针置为空，此时subR此时为根结点
		{
			m_root = subR;
			subR->m_parent = nullptr;
		}
		else
		{									//如果不为头节点，那么我们只需要将subR的父亲指针指向parent之前的父亲结点
			if (curParent->m_left == parent)
			{
				curParent->m_left = subR;
			}
			else
			{
				curParent->m_right = subR;
			}
			subR->m_parent = curParent;
		}
	}



	void RotateR(Node* parent)	//右旋
	{
		Node* subL = parent->m_left;
		Node* subLR = subL->m_right;

		parent->m_left = subLR;
		if (subLR != nullptr)
		{
			subLR->m_parent = parent;
		}

		Node* curParent = parent->m_parent;
		parent->m_parent = subL;

		subL->m_right = parent;
		if (parent == m_root)
		{
			m_root = subL;
			subL->m_parent = nullptr;
		}
		else
		{
			if (curParent->m_left == parent)
			{
				curParent->m_left = subL;
			}
			else
			{
				curParent->m_right = subL;
			}
			subL->m_parent = curParent;
		}

	}
	//插入看叔叔
	std::pair<Node*, bool> insert(const std::pair<K, V>& kv)
	{
		if (m_root == nullptr) //如果红黑树为空树，直接插入结点并将该结点作为根结点即可
		{
			m_root = new Node(kv);
			m_root->m_col = Color::BLACK;
			return std::make_pair(m_root, true);
		}
		//按照二叉搜索树的插入方法，找到要插入的位置
		Node* parent = nullptr;
		Node* cur = m_root;
		while (cur != nullptr)
		{
			if (cur->m_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->m_left;
			}
			else if (cur->m_kv.second < kv.first)
			{
				parent = cur;
				cur = cur->m_right;
			}
			else
			{
				return std::make_pair(cur, false);
			}
		}
		//判断新增结点这个位置是在该位置parent的左边还是右边
		//并将其链接起来
		Node* newNode = new Node(kv);
		if (parent->m_kv.first > kv.first)
		{
			parent->m_left = newNode;
			newNode->m_parent = parent;
		}
		else
		{
			parent->m_right = newNode;
			newNode->m_parent = parent;
		}
		cur = newNode;
		
		//3、调颜色，如果插入的结点的父亲是红色得到我们就需要进行调整
		while (parent != nullptr && parent->m_col == Color::RED)
		{
			Node* grandFather = parent->m_parent;
			if (parent == grandFather->m_left) //情况一：叔叔存在且为红
			{
				Node* uncle = grandFather->m_right;
				if (uncle != nullptr && uncle->m_col == Color::RED)
				{
					uncle->m_col = parent->m_col = Color::BLACK;
					grandFather->m_col = Color::RED;
					cur = grandFather;
					parent = cur->m_parent;
				}
				else
				{
					if (cur == parent->m_left) //情况二：叔叔存在且为黑直线或者不存
					{
						RotateR(grandFather);
						grandFather->m_col = Color::RED;
						parent->m_col = Color::BLACK;
					}
					else //情况三：叔叔存在且为黑折线或者不存
					{
						RotateL(parent);
						RotateR(grandFather);
						cur->m_col = Color::BLACK;
						grandFather->m_col = Color::RED;
					}
					break;
				}

			}
			else
			{
				Node* uncle = grandFather->m_left;
				if (uncle != nullptr && uncle->m_col == Color::RED)
				{
					uncle->m_col = parent->m_col = Color::BLACK;
					grandFather->m_col = Color::RED;
					cur = grandFather;
					parent = cur->m_parent;
				}
				else
				{
					if (cur == parent->m_left)
					{
						RotateR(parent);
						RotateL(grandFather);
						grandFather->m_col = Color::RED;
						cur->m_col = Color::BLACK;
					}
					else
					{
						RotateL(grandFather);
						grandFather->m_col = Color::RED;
						parent->m_col = Color::BLACK;
					}
					break;
				}
			}
		}
		m_root->m_col = Color::BLACK; //始终让根结点为黑色
		return std::make_pair(newNode, true);
	}

在插入中的旋转方式，在这里就不在叙述了，看不懂的话可以看我的AVL树的博客在哪里有具体的讲解。

红黑树的验证

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

其中中序遍历的代码如下：

private:
	void _Inorder(Node*& root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->m_left);
		cout << root->m_kv.first << " : " << root->m_kv.second << endl;
		_Inorder(root->m_right);
	}
public:
	void Inorder()
	{
		_Inorder(m_root);
		cout << endl;
	}

在这里我们利用两个函数来进行书写，这样做的好处是，外层用户不会直接去使用到根结点，它只需要看到结果即可。但中序遍历出来有序，只能保证它是一棵二叉搜索树，并不能保证它是满足红黑树树的性质。
故我们还要验证是否满足红黑树的五条性质,原理是先从根开始计算最左路黑色结点个数，那么只需要从根开始遍历只要每条路径到空位置，黑色结点个数相同即可直到是否满足每条路径都有相同数量的黑色结点。
代码如下：

public:
	//判断是否为红黑树
	bool IsRBTree()
	{
		if (m_root == nullptr) //空树是红黑树
		{
			return true;
		}
		if (m_root->m_col == Color::RED)
		{
			cout << "error：根结点为红色" << endl;
			return false;
		}

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

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

		if (root->m_col == Color::RED && root->m_parent->m_col == Color::RED)
		{
			cout << "error：存在连续的红色结点" << endl;
			return false;
		}
		if (root->m_col == Color::BLACK)
		{
			count++;
		}
		return _IsRBTree(root->m_left, count, BlackCount) && _IsRBTree(root->m_right, count, BlackCount);
	}

故红黑树的验证分为以下两步：

  1. 通过中序遍历来判断是否是二叉搜索树，因为首先要满足是搜索树这是红黑树的前提。
  2. 在搜索树的前提下，再通过验证是否满足红黑树的性质来判断是否是红黑树。

红黑树的删除

红黑树的删除大致和AVL树的删除差不多，只是在AVL树删除是要调节平衡因子，而红黑树删除是要调节使其满足红黑树的五条性质。
与AVL树删除同样。

  • 首先都是先找到要删除的结点，并用替代法将结点删除。因此我们最终需要删除的都是左右子树至少有一个为空的结点。找到实际待删除结点后，先不直接删除该结点，我们先调整红黑树让其删除后任然满足红黑性质，所以我们找到实际待删除结点之后立即对红黑树进行调整。
  • 其次就是调整红黑树，使其删除该结点之后仍然满足红黑树的性质。最后就是删除，并把链接关系建立好即可。

我们先从最简单的出发，如果要删除的节点是 a，它只有一个子节点 b，那我们就依次进行下面的操作。
处理方式为：删除节点 b，并且把节点 b的数据替换到节点 a 的位置。并且这个节点 a 只能是黑色，节点 b 也只能是红色，其他情况均不符合红黑树的性质。这种调整结束后不需要进行二次调整，直接退出即可。
在这里插入图片描述

这里需要注意一下，红黑树的定义中“只包含红色节点和黑色节点”，经过初步调整之后，为了保证满足红黑树定义的最后一条要求，有些节点会被标记成两种颜色，“红 - 黑”或者“黑 - 黑”。如果一个节点被标记为了“黑 - 黑”，那在计算黑色节点个数的时候，要算成两个黑色节点。

在下面的讲解中，如果一个节点既可以是红色，也可以是黑色，在画图的时候，我会用一半红色一半黑色来表示。如果一个节点是“红 - 黑”或者“黑 -黑”，我会用左上角的一个小黑点来表示额外的黑色。 其中x、y、z、w、p、q等都是表示子树，可以只为NIL结点。

CASE 1：如果关注节点是 a，它的兄弟节点 c 是红色的，我们就依次进行下面的操作：

  1. 围绕关注节点 a 的父节点 b 左旋；
  2. 关注节点 a 的父节点 b 和祖父节点 c 交换颜色，关注节点不变，更新兄弟结点，此时兄弟结点就变为了d；

这样就从CASE 1 转变为 后面的CASE 2、3、4这三种情况继续进行调整。
在这里插入图片描述

CASE 2 : 如果关注节点是 a，它的兄弟节点 c 是黑色的，并且节点 c 的左右子节点 d、e 都是黑色的，我们就依次进行下面的操作：

  1. 将关注节点 a 的兄弟节点 c 的颜色变成红色；
  2. 从关注节点 a 中去掉一个黑色，这个时候节点 a 就是单纯的红色或者黑色；
  3. 给关注节点 a 的父节点 b 添加一个黑色，这个时候节点 b 就变成了“红 - 黑”或者“黑 - 黑”；
    3.1 此时结点b变为了“红 - 黑”，即b的颜色原来是单纯的红色时，我们将b的颜色变成黑色后结束调整；
    3.2 此时结点b变为了“黑 - 黑”，即b的颜色原来是单纯的黑色时，我们继续向上更新，最后我们将关注节点从 a 变成其父节点 b；

这样我们就继续从四种情况中选择符合的规则来进行调整。
在这里插入图片描述
CASE 3：如果关注节点是 a，它的兄弟节点 c 是黑色，c 的左孩子节点 d 是红色，c 的右孩子节点 e 是黑色，我们就依次进行下面的操作：

  1. 首先我们围绕关注节点 a 的兄弟节点 c 右旋；
  2. 其次是节点 c 和节点 d 交换颜色；关注节点不变，但要和CASE 1 一样要更新关注结点的兄弟结点；

从CASE 3 一定会跳转到 CASE 4，继续调整。在这里插入图片描述

CASE 4：如果关注节点 a 的兄弟节点 c 是黑色的，并且 c 的右子节点是红色的，我们就依次进行下面的操作：

  1. 首先我们围绕关注节点 a 的父节点 b 进行左旋；
  2. 将关注节点 a 的兄弟节点 c 的颜色，跟关注节点 a 的父节点 b 设置成相同的颜色；然后将关注节点 a 的父节点 b 的颜色设置为黑色；从关注节点 a 中去掉一个黑色，节点 a 就变成了单纯的红色或者黑色；将关注节点 a 的叔叔节点 e 设置为黑色；

CASE 4 调整完后就结束调整。
在这里插入图片描述
CASE 1 、3 和4在各自执行常数次数的颜色改变和至多3次旋转后便终止。而CASE 2 是 while 循环可以重复执行的唯一情况，然后指针x沿树上升至多O(logn)次，且不执行任何旋转。

  • 最后就是进行结点的删除。删除该结点判断删除结点是否有孩子，将删除结点的孩子结点的m_parent链接到删除结点的父亲，然后再将删除结点的父亲的m_left或者m_right链接到孩子。

代码如下：

public:
	//删除函数 删除看兄弟
	bool erase(const K& key)
	{
		//用于遍历二叉树
		Node* parent = nullptr;
		Node* cur = m_root;
		//用于标记实际的待删除结点及其父结点
		Node* delParentPos = nullptr;
		Node* delPos = nullptr;
		while (cur != nullptr)
		{
			if (key < cur->m_kv.first) //所给key值小于当前结点的key值
			{
				//往该结点的左子树走
				parent = cur;
				cur = cur->m_left;
			}
			else if (key > cur->m_kv.first) //所给key值大于当前结点的key值
			{
				//往该结点的右子树走
				parent = cur;
				cur = cur->m_right;
			}
			else //找到了待删除结点
			{
				if (cur->m_left == nullptr) //待删除结点的左子树为空
				{
					if (cur == m_root) //待删除结点是根结点
					{
						m_root = m_root->m_right; //让根结点的右子树作为新的根结点
						if (m_root)
						{
							m_root->m_parent = nullptr;
							m_root->m_col = Color::BLACK; //根结点为黑色
						}
						delete cur; //删除原根结点
						return true;
					}
					else
					{
						delParentPos = parent; //标记实际删除结点的父结点
						delPos = cur; //标记实际删除的结点
					}
					break; //进行红黑树的调整以及结点的实际删除
				}
				else if (cur->m_right == nullptr) //待删除结点的右子树为空
				{
					if (cur == m_root) //待删除结点是根结点
					{
						m_root = m_root->m_left; //让根结点的左子树作为新的根结点
						if (m_root)
						{
							m_root->m_parent = nullptr;
							m_root->m_col = Color::BLACK; //根结点为黑色
						}
						delete cur; //删除原根结点
						return true;
					}
					else
					{
						delParentPos = parent; //标记实际删除结点的父结点
						delPos = cur; //标记实际删除的结点
					}
					break; //进行红黑树的调整以及结点的实际删除
				}
				else //待删除结点的左右子树均不为空
				{
					//替换法删除
					//寻找待删除结点右子树当中key值最小的结点作为实际删除结点
					Node* minParent = cur;
					Node* minRight = cur->m_right;
					while (minRight->m_left != nullptr)
					{
						minParent = minRight;
						minRight = minRight->m_left;
					}
					cur->m_kv.first = minRight->m_kv.first; //将待删除结点的key改为minRight的key
					cur->m_kv.second = minRight->m_kv.second; //将待删除结点的value改为minRight的value
					delParentPos = minParent; //标记实际删除结点的父结点
					delPos = minRight; //标记实际删除的结点
					break; //进行红黑树的调整以及结点的实际删除
				}
			}
		}

		if (delPos == nullptr) //delPos没有被修改过，说明没有找到待删除结点
		{
			return false;
		}

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

		//调整红黑树 为了删除黑色结点后来恢复红黑树的性质
		if (delPos->m_col == Color::BLACK) //删除的是黑色结点
		{
			if (delPos->m_left != nullptr) //待删除结点有一个红色的左孩子（不可能是黑色）
			{
				delPos->m_left->m_col = Color::BLACK; //将这个红色的左孩子变黑即可
			}
			else if (delPos->m_right != nullptr) //待删除结点有一个红色的右孩子（不可能是黑色）
			{
				delPos->m_right->m_col = Color::BLACK; //将这个红色的右孩子变黑即可
			}
			else //待删除结点的左右均为空
			{
				while (delPos != m_root) //可能一直调整到根结点
				{
					if (delPos == delParentPos->m_left) //待删除结点是其父结点的左孩子
					{
						Node* brother = delParentPos->m_right; //兄弟结点是其父结点的右孩子
						//情况一：brother为红色
						if (brother->m_col == Color::RED)
						{
							delParentPos->m_col = Color::RED;
							brother->m_col = Color::BLACK;
							RotateL(delParentPos);
							//需要继续处理
							brother = delParentPos->m_right; //更新brother（否则在本循环中执行其他情况的代码会出错）
						}

						//情况二：brother为黑色，且其左右孩子都是黑色结点或者 一边为空一变为黑时
						//甚至两边都为NIL，就是两边都为空时
						if (((brother->m_left == nullptr) || (brother->m_left->m_col == Color::BLACK))
							&& ((brother->m_right == nullptr) || (brother->m_right->m_col == Color::BLACK)))
						{
							brother->m_col = Color::RED;
							if (delParentPos->m_col == Color::RED)
							{
								delParentPos->m_col = Color::BLACK;
								break;
							}
							else
							{
								//需要继续处理
								delPos = delParentPos;
								delParentPos = delPos->m_parent;
							}
						}
						else
						{
							//情况三：brother为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空
							if ((brother->m_right == nullptr) || (brother->m_right->m_col == Color::BLACK))
							{
								brother->m_left->m_col = Color::BLACK;
								brother->m_col = Color::RED;
								RotateR(brother);
								//需要继续处理
								brother = delParentPos->m_right; //更新brother（否则执行下面情况四的代码会出错）
							}

							//情况四：brother为黑色，且其右孩子是红色结点
							brother->m_col = delParentPos->m_col;
							delParentPos->m_col = Color::BLACK;
							brother->m_right->m_col = Color::BLACK;
							RotateL(delParentPos);
							break; //情况四执行完毕后调整一定结束
						}
					}
					else //delPos == delParentPos->m_right //待删除结点是其父结点的右孩子
					{
						Node* brother = delParentPos->m_left; //兄弟结点是其父结点的左孩子
						//情况一：brother为红色
						if (brother->m_col == Color::RED) //brother为红色
						{
							delParentPos->m_col = Color::RED;
							brother->m_col = Color::BLACK;
							RotateR(delParentPos);
							//需要继续处理
							brother = delParentPos->m_left; //更新brother（否则在本循环中执行其他情况的代码会出错）
						}

						//情况二：brother为黑色，且其左右孩子都是黑色结点或为空
						if (((brother->m_left == nullptr) || (brother->m_left->m_col == Color::BLACK))
							&& ((brother->m_right == nullptr) || (brother->m_right->m_col == Color::BLACK)))

						{
							brother->m_col = Color::RED;
							if (delParentPos->m_col == Color::RED)
							{
								delParentPos->m_col = Color::BLACK;
								break;
							}
							else
							{
								//需要继续处理
								delPos = delParentPos;
								delParentPos = delPos->m_parent;
							}
						}
						else
						{
							//情况三：brother为黑色，且其右孩子是红色结点，左孩子是黑色结点或为空
							if ((brother->m_left == nullptr) || (brother->m_left->m_col == Color::BLACK))
							{
								brother->m_right->m_col = Color::BLACK;
								brother->m_col = Color::RED;
								RotateL(brother);
								//需要继续处理
								brother = delParentPos->m_left; //更新brother（否则执行下面情况四的代码会出错）
							}

							//情况四：brother为黑色，且其左孩子是红色结点
							brother->m_col = delParentPos->m_col;
							delParentPos->m_col = Color::BLACK;
							brother->m_left->m_col = Color::BLACK;
							RotateR(delParentPos);
							break; //情况四执行完毕后调整一定结束
						}
					}
				}
			}
		}

		//链接删除结点的孩子与删除结点父亲的链接关系
		if (del->m_left == nullptr) //实际删除结点的左子树为空
		{
			if (del == delP->m_left) //实际删除结点是其父结点的左孩子
			{
				delP->m_left = del->m_right;
				if (del->m_right != nullptr)
				{
					del->m_right->m_parent = delP;
				}
			}
			else //实际删除结点是其父结点的右孩子
			{
				delP->m_right = del->m_right;
				if (del->m_right != nullptr)
				{
					del->m_right->m_parent = delP;
				}
			}
		}
		else //实际删除结点的右子树为空
		{
			if (del == delP->m_left) //实际删除结点是其父结点的左孩子
			{
				delP->m_left = del->m_left;
				if (del->m_left != nullptr)
				{
					del->m_left->m_parent = delP;
				}
			}
			else //实际删除结点是其父结点的右孩子
			{
				delP->m_right = del->m_left;
				if (del->m_left != nullptr)
				{
					del->m_left->m_parent = delP;
				}
			}
		}

		//最后将结点删除
		delete del;
		return true;
	}

红黑树的查找

由于红黑树是特殊的二叉搜索树，所有红黑树的查找与普通的二叉搜索树的查找规则相同。
规则如下：

  1. 若树为空树，则查找失败，返回nullptr。
  2. 当二叉搜索树中不为空时：
    2.1 当插入的key值比我们当前所在的位置的值大时，我们往右走。
    2.2 当插入的key值比我们当前所在的位置的值小时，我们往左走。
    2.3 当插入的key值与当前的值相等时，就说明找到了该结点。
    2.4 如果在一条路径走到叶子结点也没有找到，返回nullptr。

在这里插入图片描述
代码如下：

public:
	Node* find(const K&kv) 
	{
		if (m_root == nullptr) //判断头结点是否为空
		{
			return nullptr;
		}
		Node* cur = m_root;
		while (cur != nullptr)
		{
			if (cur->m_kv.first > kv)  //想要找到Key值为kv比当前位置的Key值小，往左走
			{
				cur = cur->m_left;
			}
			else if (cur->m_kv.first < kv) //想要找到Key值为kv比当前位置的Key值大，往右走
			{
				cur = cur->m_right;
			}
			else
			{
				return cur; //找到了该结点，并返回该位置的指针
			}
		}
		return nullptr;  //未找到结点返回nullptr
	}

总结：

  • 插入：
    1、parent的颜色是黑色不需要进行调整，直接插入完成。
    2、parent的颜色是红色，违反性质3，需要处理，处理方式如上述三种情况处理。而插入时看uncle的颜色。
  • 删除：
    1、若删除的替换结点是红色，那么直接删除即可。
    2、若删除的替换结点是黑色，将要按照上述四种情况进行调整。删除时看brother的颜色。

红黑树与AVL树的区别：
红黑树和AVL树都是高效的平衡二叉搜索树，增删改查的时间复杂度都是O(logN),红黑树不追求绝对的平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优。

完整代码自提链接

可乐不解渴
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
红黑树实现源码
07-22
关于红黑树的功能实现
红黑树其实也简单
GJwalkhard的博客
06-02 584
文章目录红黑树的概念红黑树的性质红黑树节点的定义红黑树的插入操作 红黑树的概念 红黑树：是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 1. 根节点必须是黑色的。 2. 每个节点不是黑色就是红色。 3. 没有连续的红色节点。(如果一个节点是红色的，则它的两个孩子结点是黑色的) 4. 每条路径上的黑色节点的数目是相同的。 5. 所以的
数据结构（高阶）—— 红黑树
M的博客
11-26 2807
红黑树，是一种二叉搜索树，但在每个结点上增加了一个存储位表示结点的颜色，可以使Red或Black。通过对任何一条从根到叶子的路劲上各个结点着色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而近似平衡的。对于每个结点，从该结点到其所有后代叶子结点的简单路径上，均包含相同数目的黑色结点。如果一个结点是红色的，则它的两个孩子结点是黑色的。每条路径上的黑色结点数量相同。每个结点不是红色就是黑色。此处的叶子结点指定是空结点。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 16万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++ STL和平衡二叉树红黑树
无敌秋
03-31 1988
在实际使用过程中，到底选择这几种容器中的哪一个，应该根据遵循以下原则： １、如果需要高效的随机存取，不在乎插入和删除的效率，使用vector； 2、如果需要大量的插入和删除元素，不关心随机存取的效率，使用list； 3、如果需要随机存取，并且关心两端数据的插入和删除效率，使用deque； 4、如果打算存储数据字典，并且要求方便地根据key找到value，一对一的情况使用map，一对多的情况使用multimap； 5、如果打算查找一个元素是否存在于某集合中，唯一存在的情况使用set，不唯一存在的情况使用mul
Linux内核中红黑树算法的实现详解
09-15
红黑树是平衡二叉树的一种，它有很好的性质，树中的结点都是有序的，而且因为它本身就是平衡的，所以查找也不会出现非常恶劣的情况，基于...那么本文将详细的介绍Linux内核中红黑树算法的实现，有需要的可以参考借鉴。
java算法实现红黑树完整代码示例
08-28
主要介绍了java算法实现红黑树完整代码示例，具有一定参考价值，需要的朋友可以了解下。
C语言实现红黑树的实例代码
09-04
主要介绍了C语言实现红黑树的实例代码，有需要的朋友可以参考一下
java中treemap和treeset实现红黑树
08-28
主要为大家详细介绍了java中treemap和treeset实现红黑树，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
红黑树的算法实现和改进
06-30
我的毕业设计论文，详细的介绍了红黑树的概念和各种操作，并且对相关的删除旋转算法做了一定改进，提高了运算效率。另外还有大便时的ppt动态演示，非常适合初学者。
【C++数据结构】二叉树之三红黑树
我的博客
02-13 277
本次实现的红黑树为基于上篇实现的普通二叉树之上实现的，普通二叉树的实现已经在https://blog.csdn.net/qq811299838/article/details/104038745这篇文章中列出，此处就不再放出来了。 由于网上已经有很多红黑树的算法介绍，本文将不再介绍算法，只提供代码实现以及测试代码，如有问题，欢迎指出！ 关于结点删除：选用被删除结点中，左子树深度比右子树大，则选...
红黑树介绍
mz474920631的博客
05-28 4万+
红黑树一、红黑树的概念红黑树的性质红黑树节点的定义红黑树结构二、使用步骤1.引入库2.读入数据总结 一、红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数
红黑树（Red Black Tree，RBTree）
qq_39918677的博客
09-15 8295
一、概念 红黑树是一种自平衡二叉查找树（二叉排序树）。与平衡二叉树（avl树）不同的是，红黑树是弱平衡二叉树，即它的左右子树高度差有可能大于1。 二、5大性质 每个节点要么是黑色, 要么是红色。 根节点是黑色。 每个叶节点(Nil，空值)都是黑色。 每个红色节点的两个子节点一定都是黑色。 任意一个节点到每个叶子节点的路径都包含相同数量的黑节点。 三、推论（或规律） 左子树和右子树的黑节点的层数是相等的。因此我们称红黑树的这种平衡为黑色完美平衡。（由性质5推出） 如果一个节点存在黑子节点，那么该节点肯定
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
红黑树的实现（图文详解）
AllenSquirrel
05-24 3875
红黑树的实现 红黑树的定义 红黑树的结构
红黑树基本原理和简单实现
qq_59535638的博客
06-01 336
红黑树的基本性质，插入情况的详细分析与简单实现
五分钟搞懂什么是红黑树（全程图解）
weixin_41549033的博客
08-15 4693
前言：本文转载自点击这里阅读原文 另外：本文最好拿笔+草稿纸一边看一边按照规则进行演变，本文的过程可能和你演变的不一样，没关系，看懂思想，然后根据答案去反推，去思考，我相信你会有所收获的 什么是红黑树？ 红黑树就是一种平衡二叉树，说它平衡的意思是它不会出现左子树与右子树的高度之差不会大于1，左子树和右子树保持一种平衡的关系。 红黑树主要有以下5种特性： 节点要么是红色要么是黑色 根节点必须是黑色...
红黑树简介
weixin_54156274的博客
11-28 1418
一、什么是红黑树 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性
红黑树介绍，为什么引入红黑树
最新发布
09-09
红黑树是一种自平衡的二叉搜索树，它在插入和删除操作后能够保持相对平衡，从而提供了快速的查找、插入和删除...因此，红黑树常常被用作高效的数据结构，例如在各种编程语言的标准库中被广泛应用于实现平衡的查找表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值