【C++】红黑树的实现

最新推荐文章于 2025-11-22 23:45:52 发布
原创 最新推荐文章于 2025-11-22 23:45:52 发布 · 692 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #红黑树 #二叉搜索树 #数据结构

文章目录

前言

在上一篇文章中，我们详细介绍了AVL树（平衡二叉搜索树）的实现，内容很重要，请大家务必掌握！红黑树是一棵接近平衡的二叉搜索树（因为它没有平衡因子的概念，靠着四条规则来维持一种接近平衡的结构），那么本篇文章将带大家详细讲解红黑树的实现，接下来一起看看吧！

一. 红黑树的概念

红黑树是一棵二叉搜索树，它的每个节点增加一个存储位来表示节点的颜色，可以是红色或者黑色，通过对任何一条从根到叶子的路径上各个节点的颜色进行约束，确保红黑树没有一条路径比其他任何路径的2倍还长（最长路径不超过最短路径的2倍），因而是接近平衡的。

1.1 红黑树的规则

  1. 每个节点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子节点必须是黑色的，也就是说任何一条路径不会有连续的红色节点。
  4. 对于任意一个节点，从该节点到其所有叶子节点（NULL节点）的路径上，均包含相同数量的黑色节点。

说明：《算法导论》等书籍上补充了一条每个叶子结点(NIL)都是黑色的规则。这里所指的叶子结点不是传统的意义上的叶子结点，而是我们说的空结点，有些书籍上也把NIL叫做外部结点。NIL是为了方便准确的标识出所有路径，《算法导论》在后续讲解实现的细节中也忽略了NIL结点，所以我们知道一下这个概念即可。
在这里插入图片描述

1.2 如何确保最长路径不超过最短路径的2倍

  • 由规则4可知：从根到NULL节点的每条路径都有相同数量的黑色节点，所有在极端情况下，最短路径就是全是黑色节点的路径，假设最短路径的长度为bh（black height）。
  • 由规则2和规则3可知：任意一条路径不会有连续的红色节点，所以在极端情况下，最长路径就是一黑一红间隔组成，那么最长路径的长度为2*bh。
  • 综合红黑树的4点规则而言，理论上的全黑最短路径和一黑一红的最长路径并不是在每棵树都存在的。假设任意一条从根到NULL节点路径的长度为h，那么bh<=h<=2*bh。

1.3 红黑树的效率

假设N是红黑树树中结点的数量，h是最短路径的长度，那么 2 h 2^{h} 2h-1 <= N < 2 2 ∗ h 2^{2*h} 22∗h-1，由此推出h ≈ logN，也就是意味着红黑树增删查最坏也就是2*logN，那么时间复杂度还是O(logN)。

红黑树的表达相对AVL树要抽象一些，AVL树通过高度差直观的控制了平衡。红黑树通过4条规则的颜色约束，间接的实现了近似平衡，他们效率都是同一档次，但是相对而言，插入相同数量的结点，红黑树的旋转次数是更少的，因为他对平衡的控制没那么严格。

在这里插入图片描述

二. 红黑树的实现

2.1 红黑树的结构

红黑树的节点用三叉链结构表示，默认存储key/value结构的数据，同时存储一个枚举变量来表示节点的颜色。

// 枚举值表示颜色
enum  Color
{
	RED,
	BLACK
};

// 默认按key/value结构实现
template<class K, class V>
struct RBTreeNode
{
	// 这里更新控制平衡也要加入parent指针
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _col;

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv),
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_col(RED)
	{
	}
};
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
private:
	Node* _root = nullptr;
};

2.2 红黑树的插入

2.2.1 红黑树插入一个值的大概过程

  1. 插入一个值按二叉搜索树的规则进行插入，插入后只需观察是否符合红黑树的4条规则。
  2. 如果是空树插入，新增节点是黑色节点（因为根节点必须是黑色）。如果是非空树插入，新增节点必须是红色节点，如果新增节点是黑色就会使这个节点的所在路径比其他路径多出一个黑色节点，从而破坏了规则4，规则4是很难维护的。
  3. 非空树插入后，新增节点必须是红色节点，如果父亲节点是黑色的，则没有违反任何规则，插入过程结束。
  4. 非空树插入后，新增节点必须是红色节点，如果父亲节点是红色的，则违法规则3。进一步分析，c是红色，p是红色，g必须为黑色，这三个节点的颜色都固定了，关键的变化看u是什么情况，根据u可以分为以下几种情况分别处理。

说明：假设新增节点标识为c（cur），c的父亲标识为p（parent），p的父亲标识为g（grandfather），p的兄弟标识为u（uncle）。

// 旋转代码的实现跟AVL树是一样的，只是不需要更新平衡因子
bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr) {
		_root = new Node(kv);
		_root->_col = BLACK;
		return true;
	}
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (kv.first > cur->_kv.first) {
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first) {
			parent = cur;
			cur = cur->_left;
		}
		else {
			return false;
		}
	}
	cur = new Node(kv);
	// 新增节点，颜色红色
	cur->_col = RED;
	cur->_parent = parent;
	if (kv.first > parent->_kv.first) {
		parent->_right = cur;
	}
	else {
		parent->_left = cur;
	}
	//对不满足规则的情况进行调整
	
}

2.2.2 情况1：变色

过程：c为红，p为红，g为黑，u存在且为红，则将p和u变黑，g变红。再把g当做新的c，继续往上更新。

分析：因为p和u都是红色，g是黑色，把p和u变黑，左边子树路径各增加一个黑色节点，g再变红，相当于保持g所在子树的黑色节点的数量不变，同时解决了c和p连续红色节点的问题，需要继续往上更新是因为：g由黑变红，如果g的父亲还是红色，那么还需要继续处理；如果g的父亲是黑色，则处理结束了。如果g没有父亲节点，则g就是整棵树的根，再把g变回黑色即可。

注意：因为这种情况只变色，不旋转，所以无论c是p的左孩子还是右孩子，p是g的左孩子还是右孩子，都是上面的变色处理方式。

在这里插入图片描述
在这里插入图片描述
注意：如果最后g是整棵树的根节点，还要把g变回黑色，可以在代码的最后补充一句：_root->_col = BLACK，这样就不需要我们判断g是否为根节点了。

2.2.3 情况2：单旋+变色

过程：c为红，p为红，g为黑，u不存在或者u存在且为黑，如果u不存在，则c一定是新增节点（以g为根的右子树没有黑色节点，那么左子树一定也没有黑色节点）；如果u存在且为黑，则c一定不是新增节点（以g为根的右子树有黑色节点，那么左子树一定也有黑色节点），c之前是黑色的，是在c的子树中插入，符合情况1，c从黑色变成红色，此时c为红，p为红，g为黑，u为黑。

分析：p必须变黑，才能解决连续红色节点的问题，u不存在或者是黑色的，这里单纯的变色已经无法解决问题，需要旋转+变色。

在这里插入图片描述

  1. 如果p是g的左孩子，c是p的左孩子，那么以g为旋转点进行右单旋，再把p变黑，g变红即可(LL型)。p变成这棵树新的根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为p的父亲是黑色还是红色或者空都不违反规则。
  2. 如果p是g的右孩子，c是p的右孩子，那么以g为旋转点进行左单旋，再把p变黑，g变红即可(RR型)。p变成这棵树新的根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为p的父亲是黑色还是红色或者空都不违反规则。

这里拿LL型举例子，RR型做对称处理即可。

u不存在的情况：
在这里插入图片描述
u存在且为黑的情况：

说明：e和f是根为黑色或红色，黑色节点数量为hb-1的子树；a和b是根为红色，黑色节点数量为hb-1的子树；d是根为黑色，黑色节点数量为hb的子树。
在这里插入图片描述

2.2.4 情况3：双旋+变色

过程：c为红，p为红，g为黑，u不存在或者u存在且为黑，u不存在，则c一定是新增节点，u存在且为黑，则c一定不是新增节点，c之前是黑色的，是在c的子树中插入，符合情况1，c从黑色变成红色。

分析：p必须变黑，才能解决连续红色节点的问题，u不存在或者是黑色的，这里单纯的变色已经无法解决问题，需要旋转+变色。

在这里插入图片描述

  1. 如果p是g的左孩子，c是p的右孩子，那么先以p为旋转点进行左单旋，再以g为旋转点进行右单旋，再把c变黑色，g变红色即可（LR型）。c变成这棵树新的根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则。
  2. 如果p是g的右孩子，c是p的左孩子，那么先以p为旋转点进行右单旋，再以g为旋转点进行左单旋，再把c变黑色，g变红色即可（RL型）。c变成这棵树新的根，这样子树黑色节点的数量不变，没有连续的红色节点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则。

这里拿LR型举例子，RL型做对称处理即可。

u不存在的情况：
在这里插入图片描述
u存在且为黑的情况：

说明：e和f是根为黑色或红色，黑色节点数量为hb-1的子树；a和b是根为红色，黑色节点数量为hb-1的子树；d是根为黑色，黑色节点数量为hb的子树。

在这里插入图片描述

2.2.5 插入函数代码实现

根据以上情况的解析，红黑树的插入函数代码实现如下：

// 旋转代码的实现跟AVL树是一样的，只是不需要更新平衡因子
bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr) {
		_root = new Node(kv);
		_root->_col = BLACK;
		return true;
	}
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (kv.first > cur->_kv.first) {
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first) {
			parent = cur;
			cur = cur->_left;
		}
		else {
			return false;
		}
	}
	cur = new Node(kv);
	// 新增节点，颜色红色
	cur->_col = RED;
	cur->_parent = parent;
	if (kv.first > parent->_kv.first) {
		parent->_right = cur;
	}
	else {
		parent->_left = cur;
	}
	//对不满足规则的情况进行调整
	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		//   g
		// p   u
		if (grandfather->_left == parent) {
			Node* uncle = grandfather->_right;
			if (uncle && uncle->_col == RED) {
				// 叔叔存在且为红，变色再继续往上处理
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else {
				// 叔叔不存在或存在且为黑，旋转+变色
				if (parent->_left == cur) {
					//    g
					//  p   u
					//c
					//单旋
					RotateR(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
				}
				else {
					//    g
					//  p   u
					//    c
					//双旋
					RotateL(parent);
					RotateR(grandfather);
					grandfather->_col = RED;
					cur->_col = BLACK;
				}
				break;
			}
		}
		else {
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED) {
				// 叔叔存在且为红，变色再继续往上处理
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else {
				// 叔叔不存在或存在且为黑，旋转+变色
				if (parent->_right == cur) {
					//   g
					// u   p
					//       c
					// 单旋
					RotateL(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
				}
				else {
					//   g
					// u   p
					//   c
					// 双旋
					RotateR(parent);
					RotateL(grandfather);
					grandfather->_col = RED;
					cur->_col = BLACK;
				}
				break;
			}
		}
	}
	_root->_col = BLACK;
	return true;
}
// 右单旋
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	subL->_right = parent;
	parent->_left = subLR;
	if (subLR)
		subLR->_parent = parent;
	Node* parentParent = parent->_parent;
	parent->_parent = subL;
	if (parentParent == nullptr) {
		// 如果parent为根节点则更新根节点
		_root = subL;
		subL->_parent = nullptr;
	}
	else {
		// subL和parentParent建立联系
		if (parentParent->_left == parent) {
			parentParent->_left = subL;
		}
		else {
			parentParent->_right = subL;
		}
		subL->_parent = parentParent;
	}
}

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

	subR->_left = parent;
	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;
	Node* parentParent = parent->_parent;
	parent->_parent = subR;
	if (parentParent == nullptr) {
		// 如果parent为根节点则更新根节点
		_root = subR;
		subR->_parent = nullptr;
	}
	else {
		// subR和parentParent建立联系
		if (parentParent->_left == parent) {
			parentParent->_left = subR;
		}
		else {
			parentParent->_right = subR;
		}
		subR->_parent = parentParent;
	}
}

2.3 红黑树的查找

按二叉搜索树的逻辑实现即可，搜索效率为O(log N)

// 查找
Node* Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (key > cur->_kv.first) {
			cur = cur->_right;
		}
		else if (key < cur->_kv.first) {
			cur = cur->_left;
		}
		else {
			return cur;
		}
	}
	return nullptr;
}

2.4 红黑树的验证

这里获取最长路径和最短路径，检查最长路径不超过最短路径的2倍是不可行的，因为就算满足这个条件，红黑树也可能会出现颜色不满足规则，当前暂时没出问题，后续继续插入还是会出问题的。所以我们还是去检查4点规则，满足这4点规则，一定能保证最长路径不超过最短路径的2倍。

  1. 规则1使用了枚举类型表示节点的颜色，保证了节点的颜色不是黑色就是红色。
  2. 规则2则直接检查根节点颜色即可。
  3. 规则3则使用前序遍历检查，遇到红色节点检查孩子不太方便，因为孩子有两个，且不一定存在，反过来检查父亲的颜色就方便多了。
  4. 规则4使用前序遍历，遍历过程中用形参记录根到当前节点的黑色节点数量（用blackNum），前序遍历遇到黑色节点就++blackNum，走到空就计算出了一条路径的黑色节点数量。先算出任意一条路径的黑色节点数量作为参考值，依次比较即可。
//检查
bool Check(Node* root, int blackNum, const int& refNum)
{
	if (root == nullptr) {
		if (blackNum != refNum) {
			cout << "存在黑色结点的数量不相等的路径" << endl;
			return false;
		}
		return true;
	}
	// 检查孩子不太方便，因为孩子有两个，且不一定存在，反过来检查父亲就方便多了
	if (root->_col == RED && root->_parent->_col == RED)
	{
		cout << root->_kv.first << "存在连续的红色节点" << endl;
		return false;
	}
	if (root->_col == BLACK)
	{
		blackNum++;
	}
	return Check(root->_left, blackNum, refNum) && Check(root->_right, blackNum, refNum);
}
// 验证是否平衡
bool IsBalance()
{
	if (_root == nullptr) {
		return true;
	}
	if (_root->_col == RED) {
		return false;
	}
	// 参考值
	int refNum = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_col == BLACK) {
			refNum++;
		}
		cur = cur->_left;
	}
	return Check(_root, 0, refNum);
}

测试（与AVL树对比）：

插入随机值，查找随机值：

// 插入一堆随机值，测试平衡，顺便测试一下高度和性能等
void TestRBTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		//v.push_back(i);
		v.push_back(rand() + i);
	}
	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "RBTree:Insert:" << end2 - begin2 << endl;
	cout << t.IsBalance() << endl;
	cout << "RBTree:Height:" << t.Height() << endl;
	cout << "RBTree:Size:" << t.Size() << endl;
	size_t begin1 = clock();
	// 确定在的值
	/*for (auto e : v)
	{
		t.Find(e);
	}*/
	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
		//t.Find(i);
	}
	size_t end1 = clock();
	cout << "RBTree:Find:" << end1 - begin1 << endl;

	cout << endl;
}
void TestAVLTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		//v.push_back(i);
		v.push_back(rand() + i);
	}
	size_t begin2 = clock();
	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "AVLTree:Insert:" << end2 - begin2 << endl;
	cout << t.IsBalanceTree() << endl;
	cout << "AVLTree:Height:" << t.Height() << endl;
	cout << "AVLTree:Size:" << t.Size() << endl;
	size_t begin1 = clock();
	// 确定在的值
	/*for (auto e : v)
	{
		t.Find(e);
	}*/
	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
		//t.Find(i);
	}
	size_t end1 = clock();
	cout << "AVLTree:Find:" << end1 - begin1 << endl;
}

在这里插入图片描述

插入相同数量的相同值，查找相同值：

// 插入一堆随机值，测试平衡，顺便测试一下高度和性能等
void TestRBTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(i);
		//v.push_back(rand() + i);
	}
	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "RBTree:Insert:" << end2 - begin2 << endl;
	cout << t.IsBalance() << endl;
	cout << "RBTree:Height:" << t.Height() << endl;
	cout << "RBTree:Size:" << t.Size() << endl;
	size_t begin1 = clock();
	// 确定在的值
	/*for (auto e : v)
	{
		t.Find(e);
	}*/
	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		//t.Find((rand() + i));
		t.Find(i);
	}
	size_t end1 = clock();
	cout << "RBTree:Find:" << end1 - begin1 << endl;

	cout << endl;
}
void TestAVLTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(i);
		//v.push_back(rand() + i);
	}
	size_t begin2 = clock();
	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "AVLTree:Insert:" << end2 - begin2 << endl;
	cout << t.IsBalanceTree() << endl;
	cout << "AVLTree:Height:" << t.Height() << endl;
	cout << "AVLTree:Size:" << t.Size() << endl;
	size_t begin1 = clock();
	// 确定在的值
	/*for (auto e : v)
	{
		t.Find(e);
	}*/
	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		//t.Find((rand() + i));
		t.Find(i);
	}
	size_t end1 = clock();
	cout << "AVLTree:Find:" << end1 - begin1 << endl;
}

在这里插入图片描述

根据以上测试，可得知红黑树在插入和查找的性能上和AVL树是差不多的。

2.5 红黑树的删除

红黑树的删除很复杂，我认为甚至比AVL的删除还难，因为它的情况实在是太多了，大家想了解可以看一下，不想了解的可以略过。我就做个简单的讲解。

  1. 首先按照二叉搜索树的删除规则，如果被删除的节点既有左孩子又有右孩子，则找到它的右子树的最小节点进行替换，此时就转换成被删除节点只有0/1个孩子。
  2. 只有左孩子/右孩子：将孩子代替自己的位置，再使其变成黑色节点即可。
  3. 没有孩子：如果被删除节点是红色节点，则直接删除，无须任何调整；如果被删除节点是黑色节点，则要看它的兄弟节点的情况。

兄弟节点是黑色：兄弟至少有一个红孩子：变色+（LL,RR,LR,RL）旋转，（LL，RR） → \rightarrow → r变s,s变p,p为黑，（LR，RL） → \rightarrow → r变p,p变黑，双黑节点变单黑节点；兄弟的孩子都是黑色：兄弟节点变红色节点，双黑节点上移（遇红色节点或根节点变单黑节点）。
兄弟节点是红色：兄弟节点变黑，父亲节点变红（兄父变色），以父节点为旋转点朝双黑节点旋转，保持双黑节点继续调整。

想要详细了解红黑树删除的可以看一下这个视频：红黑树 - 删除

这个博主讲解的非常清楚，动图也非常清晰，感兴趣的可以去看看！

代码实现：

// 删除
bool Erase(const K& key)
{
	// 树为空则无须删除
	if (_root == nullptr) return false;
	Node* cur = Find(key);
	if (cur == nullptr) {
		// 找不到指定节点则返回false
		return false;
	}
	Node* parent = cur->_parent;
	if (cur->_left && cur->_right)
	{
		// 如果被删除的节点既有左孩子又有右孩子，则去找右子树的最小节点替代被删除的节点
		Node* minRight = cur->_right;
		Node* minRightParent = cur;
		while (minRight->_left)
		{
			minRightParent = minRight;
			minRight = minRight->_left;
		}
		//替换
		cur->_kv = minRight->_kv;
		cur = minRight;
		parent = minRightParent;
	}
	// 被删除节点只有0/1个孩子
	Node* child = nullptr;
	if (cur->_left) child = cur->_left;
	else child = cur->_right;

	if (child) child->_parent = parent;
	if (parent == nullptr) {
		// 被删除节点是根节点，则孩子节点变为根节点
		_root = child;
		if (_root) _root->_col = BLACK; // 细节，如果孩子节点也为空则红黑树为空，无须设置颜色
		delete cur;
		return true;
	}
	if (child) {
		// 如果删除节点只有一个孩子，则parent和child建立联系，并且将child设置为黑色节点
		if (parent->_left == cur) {
			parent->_left = child;
		}
		else {
			parent->_right = child;
		}
		child->_col = BLACK;
	}
	else {
		// 删除节点没有孩子的情况
		Node* pNode = cur;
		if (pNode->_col == RED) {
			// 删除节点是红色节点，则直接删除无须任何调整
			if (parent->_left == cur) {
				parent->_left = nullptr;
			}
			else {
				parent->_right = nullptr;
			}
			delete cur;
			return true;
		}
		// pNode表示双黑节点
		while (pNode)
		{
			if (pNode->_col == RED || pNode == _root)
			{
				// 如果遇到红节点或者根节点则双黑节点变为单黑节点
				pNode->_col = BLACK;
				break;
			}
			Node* bro = nullptr;
			if (parent->_left == pNode)
			{
				// 兄弟节点是父节点的右孩子
				bro = parent->_right;
				if (bro->_col == BLACK)
				{
					// 兄弟节点是黑节点
					Node* broR = bro->_right;
					Node* broL = bro->_left;
					if (broR && broR->_col == RED)
					{
						// RR型，颜色变化：broR变bro，bro变parent
						// 对parent进行左单旋，双黑节点变为单黑节点
						broR->_col = bro->_col;
						bro->_col = parent->_col;
						parent->_col = BLACK;
						RotateL(parent);
						break;
					}
					else if (broL && broL->_col == RED)
					{
						// RL型，颜色变化：broL变为parent，parent变黑
						// 对bro进行右单旋，对parent进行左单旋，双黑节点变为单黑节点
						broL->_col = parent->_col;
						parent->_col = BLACK;
						RotateR(bro);
						RotateL(parent);
						break;
					}
					else
					{
						// 兄弟都是黑色节点
						// 兄弟变为红色节点，双黑节点上移，遇红或根变单黑
						bro->_col = RED;
						pNode = parent;
						parent = parent->_parent;
					}
				}
				else
				{
					// 兄弟节点是红色
					// 兄弟节点变黑色，父亲节点变为红色
					// 以parent为旋转点朝双黑节点旋转（左单旋）
					// 保持双黑节点继续调整
					bro->_col = BLACK;
					parent->_col = RED;
					RotateL(parent);
				}
			}
			else
			{
				// 兄弟节点是父节点的左孩子
				bro = parent->_left;
				if (bro->_col == BLACK)
				{
					// 兄弟节点是黑节点
					Node* broR = bro->_right;
					Node* broL = bro->_left;
					if (broL && broL->_col == RED)
					{
						// LL型，颜色变化：broL变bro，bro变parent
						// 对parent进行右单旋，双黑节点变为单黑节点
						broL->_col = bro->_col;
						bro->_col = parent->_col;
						parent->_col = BLACK;
						RotateR(parent);
						break;
					}
					else if (broR && broR->_col == RED)
					{
						// LR型，颜色变化：broR变为parent，parent变黑
						// 对bro进行左单旋，对parent进行右单旋，双黑节点变为单黑节点
						broR->_col = parent->_col;
						parent->_col = BLACK;
						RotateL(bro);
						RotateR(parent);
						break;
					}
					else
					{
						// 兄弟都是黑色节点
						// 兄弟变为红色节点，双黑节点上移，遇红或根变单黑
						bro->_col = RED;
						pNode = parent;
						parent = parent->_parent;
					}
				}
				else
				{
					// 兄弟节点是红色
					// 兄弟节点变黑色，父亲节点变为红色
					// 以parent为旋转点朝双黑节点旋转（右单旋）
					// 保持双黑节点继续调整
					bro->_col = BLACK;
					parent->_col = RED;
					RotateR(parent);
				}
			}
		}
		// 断开删除节点cur和它的父节点的联系
		parent = cur->_parent;
		if (parent->_left == cur) {
			parent->_left = nullptr;
		}
		else {
			parent->_right = nullptr;
		}
		// 删除节点
		delete cur;
	}
	// 将根节点设置为黑色节点
	_root->_col = BLACK;
	return true;
}

测试（与AVL树对比）：

删除效率对比：

void TestRBTreeErase()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
	}
	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "RBTree:Insert:" << end2 - begin2 << endl;
	cout << t.IsBalance() << endl;
	cout << "RBTRee:Height:" << t.Height() << endl;
	cout << "RBTree:Size:" << t.Size() << endl;

	size_t begin1 = clock();
	// 随机删除500个数据
	/*for (int i = 0; i < 500; i++) {
		t.Erase(v[rand() + i]);
		if (!t.IsBalance()) {
			cout << "红黑树不平衡，删除节点有误" << endl;
			break;
		}
	}*/

	// 删除所有节点需要的时间
	for (int i = 0; i < v.size(); i++)
	{
		t.Erase(v[i]);
		/*if (!t.IsBalance()) {
			cout << "红黑树不平衡，删除节点有误" << endl;
			break;
		}*/
	}
	size_t end1 = clock();
	cout << t.IsBalance() << endl;
	cout << "RBTRee:Erase:" << end1 - begin1 << endl;
	cout << endl;
}
void TestAVLTreeErase()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
	}
	size_t begin2 = clock();
	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "AVLTree:Insert:" << end2 - begin2 << endl;
	cout << t.IsBalanceTree() << endl;
	cout << "AVLTree:Height:" << t.Height() << endl;
	cout << "AVLTree:Size:" << t.Size() << endl;

	size_t begin1 = clock();
	//// 随机删除500个数据
	//for (int i = 0; i < 500; i++) {
	//	t.Erase(v[rand() + i]);
	//	if (!t.IsBalanceTree()) {
	//		cout << "AVL树不平衡，删除节点有误" << endl;
	//		break;
	//	}
	//}

	// 删除所有节点需要的时间
	for (int i = 0; i < v.size(); i++)
	{
		t.Erase(v[i]);
	}
	size_t end1 = clock();
	cout << t.IsBalanceTree() << endl;
	cout << "AVLTree:Erase:" << end1 - begin1 << endl;
}

在这里插入图片描述
由运行结果可知红黑树的删除效率和AVL树是差不多的。

红黑树实现的源代码链接：https://gitee.com/xie-zhus-shovel/c-learning/tree/master/C++Learning/%E7%BA%A2%E9%BB%91%E6%A0%91

最后

本篇关于C++红黑树的实现到这里就结束了，难度还是挺大的，其中还有很多细节值得我们去探究，需要我们不断地学习。如果本篇内容对你有帮助的话就给一波三连吧，对以上内容有异议或者需要补充的，欢迎大家来讨论！

C++红黑树
zhao19971014的博客
11-09 766
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的
C++ 红黑树实现详解：理论+代码+图解
铭哥不写bug的博客
08-08 1538
本文详细介绍了C++中红黑树的实现原理与代码实现。首先阐述了红黑树的基本概念和规则，包括节点颜色、路径黑节点数等特性，并对比分析了红黑树与AVL树的效率差异。重点讲解了红黑树的插入操作，详细分析了三种调整情况：根节点处理、叔叔节点为红色时的变色调整，以及叔叔节点为黑色时的4种旋转情况（LL、RR、LR、RL）。文章配合大量图示直观展示了各种调整过程，并提供了完整的C++代码实现，包括节点结构、旋转操作和插入逻辑。通过理论解析与代码实践相结合的方式，帮助读者深入理解红黑树这一重要数据结构。
后端发送邮件
ye_you
07-22 448
@param toQQEmail 收件人QQ邮箱（如123456@qq.com）host: smtp.163.com # 136邮箱实际使用139的SMTP服务器。username: xxxxxx@163.com # 完整邮箱地址。password: xxxxxx # 您的授权码（非登录密码）* @param subject 邮件主题。* @param text 邮件正文。debug: true # 开启调试。* 发送简单文本邮件到QQ邮箱。163 发邮件给qq。
007-网络安全协议
wyl703的博客
10-01 788
摘要 网络安全协议学习指南，ardo120分钟课程涵盖以下核心内容： 协议分层体系：从应用层(HTTPS/SSH)到物理层(光纤加密)的完整安全协议栈，采用分层防御策略。 **TLS协议深度ever分析ITS深入解析TLS握手流程，包括： 四层协议架构（握手/记录宵禁/警报/变更规范） 类图设计展现密钥协商流程 Python实现握手过程分析器 安全设计原则：提出最小权限、深度防御等5大准则，fors网络oma安全协议设计，具有实际配置指导意义。 实践导向：课程包含代码示例（TLSHandshake Anal
C++红黑树实现
muzi_liii的博客
03-23 1323
红黑树的概念：红黑树是一棵二叉搜索树，他的每个结点增加一个存储位来表示结点的颜色，但颜色只能是红色或者黑色。它是通过约束任何一条从根到叶子结点上的颜色来控制平衡的，这样就会确保没有一条路径会比其他路径长出两倍，因而红黑树接近平衡结点颜色只能是红色或者黑色根结点必须是黑色若一个结点是红色，那么它左右孩子的结点只能是黑色，换句话说就是，不能有连续的红色结点（注：若红色结点的孩子结点为空，那么该“空叶子结点”也是黑色的对于任意一个结点，从该结点到其他所有空结点的简单路径上，均包含相同数量的黑色结点。
C++实现——红黑树
sqm_C的博客
08-20 1071
我们将红色与黑色设置成枚举类型，使代码看起来更加规范，我们定义节点采用类模板的方式，内部成员分别是左节点指针，右节点指针，父亲节点指针，pair结构体类型的变量，然后就是代表我们颜色的变量。我们再对它们进行初始化列表就可以了，我们的每个节点初始颜色都得设置成红色，不然就无法满足我们上面给的5条红黑树的性质。
【C++】红黑树实现
uyeonashi的博客
12-06 1306
红⿊树是⼀棵⼆叉搜索树，他的每个结点增加⼀个存储位来表⽰结点的颜色，可以是红色或者黑色。通过对任何⼀条从根到叶⼦的路径上各个结点的颜色进行约束，红⿊树确保没有⼀条路径会⽐其他路径⻓出2倍，因而是接近平衡的。
C++简单实现红黑树
weixin_50601177的博客
09-28 685
C++实现红黑树
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 4030
红黑树详解、模拟实现
C++实现红黑树
hdsHDS6的博客
06-28 1880
C++实现红黑树，插入和删除思路
C++红黑树实现过程
09-15
在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. ...
C++红黑树实现源代码解析
本资源提供了一份使用C++语言编写的红黑树的实现源代码，包括两个文件：task9.1.cpp和rbtree.h。task9.1.cpp文件可能包含红黑树的实现逻辑，包括节点结构定义、插入、删除、查找等操作的具体实现代码。而rbtree.h...
【C++】智能指针
2401_89058999的博客
11-21 653
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存，一般是忘记释放或者发生异常释放程序未能执行导致的。内存泄漏并不是指内存在物理上的消失，而是应用程序分 配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏的危害：普通程序运行一会就结束了出现内存泄漏问题也不大，进程正常结束，页表的映射 关系解除，物理内存也可以释放。
开源鸿蒙 Cordova 设备信息插件开发详解
夏天的博客
11-22 1033
Apache Cordova 是一个开源的移动应用开发框架，允许开发者使用 HTML、CSS 和 JavaScript 构建跨平台移动应用。Cordova 通过插件机制提供了访问设备原生功能的能力，使 Web 应用能够调用系统 API。
【免费】中国电子学会C语言（C++）scratch python 机器人技术 三维创意 所有历年真题卷全部免费2025年09月己更新
最新发布
星卯教育-信奥教练tony
11-22 173
电子学会scratch等级考试1-4级 链接：https://pan.quark.cn/s/ab0f0a0ffd6c电子学会python等级考试料1-6级链接：https://pan.quark.cn/s/88f82804f7a2电子学会机器人考级1-6级链接：https://pan.quark.cn/s/4479f423f2ed电子学会C++语言考级1-8级链接：https://pan.quark.cn/s/61d890a7d94e电子学会三维创意设计链接：https://pan.quark.cn/s/6
DAY13 Understanding C Pointers, Strings, and Stack Memory: A Practical Guide
weixin_46607526的博客
11-19 878
本文介绍了C语言中指针、字符串和栈内存的核心概念及应用。重点讲解了指针作为函数参数时的值传递与引用传递区别，以及指针与数组的关系。通过实现字符串长度计算、复制、连接和比较等自定义函数，展示了指针操作字符串的方法。文章还包含栈内存的图示说明，帮助理解函数调用时的内存分配。最后总结了指针在内存操作、数组处理和字符串处理中的基础作用，为进阶C编程打下基础。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值