【C++】红黑树

CC.GG2025-12-21 15:39

目录

前言

书接上文【C++】AVL树，详情点击查看，今天继续来介绍【C++】红黑树，本文将在【C++】二叉搜索树、【C++】AVL树的基础上介绍

一、红黑树概念

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

红黑树的规则

  • 节点不是红色就是黑色
  • 根节点是黑色
  • 如果⼀个结点是红色的，则它的两个孩子结点必须是黑色的，也就是说任意⼀条路径不会有连续的红色结点
  • 对于任意⼀个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的黑色结点

二、红黑树实现

红黑树的节点结构和AVL树很相似，都有一个pair结构、_left、_right、_parent，除此之外还有一个颜色的数据，这里我们使用枚举值表示颜色

cpp 复制代码 
enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
	{ }

};
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:

private:
	Node* _root = nullptr;
};

插入

  1. 插入一个值按二叉搜索树规则进行插入，插入后我们只需要观察是否符合红黑树的4条规则
  2. 非空树插入后，新增结点必须红色结点，如果父亲结点是黑色的，则没有违反任何规则，插入结束
  3. 下面是二叉搜索树的插入逻辑，在这个逻辑下我们需要将颜色逻辑写入代码中，根节点是黑色，插入新节点是红色的
cpp 复制代码 
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 (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(kv);
	cur->_col = RED;
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	return true;
}
  1. 进⼀步分析，如果父亲结点是红色的，c是红色，p为红，g必为黑，这三个颜色都固定了，关键的变化看u的情况（新增结点标识为c(cur)，c的父亲标识为p(parent)，p的父亲标识为g(grandfather)，p的兄弟标识为u（uncle））
  2. 需要根据u分为以下几种情况分别处理：
  • c为红，p为红，g为黑，u存在且为红：将p和u变黑，g变红。在把g当做新的c，继续往上更新
  1. 将p和u变黑，为了保证黑色节点数量不变，g变红，但是g变红之后，如果爷爷的父亲是黑色，那么处理结束；如果爷爷父亲是红色的，那么将g变为c继续向上处理（因此c不一定是新增节点）
  2. g的父亲是红色，将p变为c，继续处理；u存在且为红色，继续上面的逻辑：将p和u变黑，g变红
  3. 经过上面的处理，每条路径的黑色节点数相同，但是并没有满足根节点是黑色，因此我们如果在处理时，根节点为g，将根节点变红了，需要将根节点再变黑，每条路径对比插入数据前多了一个黑色节点
  4. 结束条件（2个）：父节点为黑色；没有父节点（根节点）
  • 单旋+变色：p必须变黑：c为红，p为红，g为黑，u不存在则c一定为新增节点；u存在且为黑，那么c一定不是新增节点。
  • p是g的左，c是p的左，那么以g为旋转点进行右单旋 ，再把p变黑，g变红即可。p变成课这颗树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为p的父亲是黑色还是红色或者空都不违反规则
  • p是g的右，c是p的右，那么以g为旋转点进行左单旋 ，再把p变黑，g变红 即可。p变成课这颗树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为p的父亲是黑色还是红色或者空都不违反规则

  • 双旋+变色：c为红，p为红，g为黑，u不存在或者u存在且为黑，u不存在，则c⼀定是新增结点，u存在且为⿊，则c⼀定不是新增
  • p是g的左，c是p的右，那么先以p为旋转点进行左单旋，再以g为旋转点进行右单旋，再把c变黑，g变红即可。c变成课这颗树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则
  • p是g的右，c是p的左，那么先以p为旋转点进行右单旋，再以g为旋转点进行左单旋，再把c变黑，g变红即可。c变成课这颗树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则

  • 旋转逻辑和AVL树是一样的，只不过不用更新_bf平衡因子，在这里不做过多解释
cpp 复制代码 
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	parent->_left = subLR;
	subL->_right = parent;
	if(subLR)
	    subLR->_parent = parent;

	Node* parentParent = parent->_parent;
	parent->_parent = subL;
	if (parent == _root)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (parent == parentParent->_left)
		{
			parentParent->_left = subL;
		}
		else
		{
			parentParent->_right = subL;
		}
		subL->_parent = parentParent;
	}
}

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

	parent->_right = subRL;
	subR->_left = parent;
	if (subRL)
		subRL->_parent = parent;

	Node* parentParent = parent->_parent;
	parent->_parent = subR;

	if (parent == _root)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (parent == parentParent->_left)
		{
			parentParent->_left = subR;
		}
		else
		{
			parentParent->_right = subR;
		}
		subR->_parent = parentParent;
	}
}
  • 最终红黑树插入代码如下：
cpp 复制代码 
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 (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(kv);
	cur->_col = RED;
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	while (parent && parent->_col == RED)
	{
		Node* grandparent = parent->_parent;
		if (parent == grandparent->_left)
		{
			Node* uncle = grandparent->_right;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandparent->_col = RED;
				//继续往上处理
				cur = grandparent;
				parent = cur->_parent;
			}
			else
			{
				//uncle不存在，或者存在且为黑色
				//  g
				//p   u
			   //c
				//单旋 
				if (cur == parent->_left)
				{
					RotateR(grandparent);
					//将parent->Col :BLACK
					//将grandparent->Col:RED
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else
				{
					//  g
				   //p    u
			       //  c
				   //双旋
					RotateL(parent);
					RotateR(grandparent);

					cur->_col = BLACK;
					grandparent->_col = RED;
				}
				break;
			}
		}
		else
		{

			Node* uncle = grandparent->_left;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandparent->_col = RED;
				//继续往上处理
				cur = grandparent;
				parent = cur->_parent;
			}
			else
			{
				//存在且为黑或者不存在
				 //  g
				//u    p
			   //         c
			    //单旋 
				if (cur == parent->_right)
				{
					RotateL(grandparent);
					//将parent->Col :BLACK
					//将grandparent->Col:RED
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else
				{
					//  g
				   //u    p
				   //  c
				   //双旋
					RotateR(parent);
					RotateL(grandparent);

					cur->_col = BLACK;
					grandparent->_col = RED;
				}
				break;
			}
		}
	}
	_root->_col = BLACK;
	return true;
}

查找

  • 查找和AVL、二叉树逻辑完全一样
cpp 复制代码 
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

三、测试

中序遍历代码和二叉树、AVL树一样，这里不做过多讲解

cpp 复制代码 
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
void _InOrder(Node* root)
{
	if (root == nullptr)
		return;
	_InOrder(root->_left);
	cout << root->_kv.first << " ";
	_InOrder(root->_right);
}
  • 测试是否为二叉树
cpp 复制代码 
int main()
{
	RBTree<int, int> t1;
	RBTree<int, int> t2;
	// 常规的测试
	int a1[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	// 特殊的带有双旋场景的测试
	int a2[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a1)
	{
		t1.Insert({ e, e });
	}
	t1.InOrder();

	for (auto e : a2)
	{
		t2.Insert({ e, e });
	}
	t2.InOrder();

	return 0;
}
  • 测试是否为红黑树
    分别检查红黑树的规则是否满足：
  1. 节点不是红色就是黑色（不需检查）
  2. 根节点是黑色（直接检查根即可）
  3. 如果⼀个结点是红色的，则它的两个孩子结点必须是黑色的，也就是说任意⼀条路径不会有连续的红色结点（前序遍历，遇到红色节点检查其父节点是否为红色）
  4. 对于任意⼀个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的黑色结点（前序遍历，遍历过程中用形参记录跟到当前结点的blackNum(黑色结点数量)，前序遍历遇到黑色结点就++blackNum，走到空就计算出了⼀条路径的黑色结点数量。再任意⼀条路径黑色结点数量作为参考值，依次比较即可）
cpp 复制代码 
bool Check(Node* root, int blackNum, const int refNum)
{
	if (root == nullptr)
	{
		if (refNum != blackNum)
		{
			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);
}
相关推荐
计算机毕设VX:Fegn08952 小时前
计算机毕业设计|基于springboot + vue旅游信息推荐系统(源码+数据库+文档)
java·数据库·vue.js·spring boot·课程设计·旅游
Qt程序员2 小时前
从 C++11 到 C++23：枚举的原理升级与实践
c++·c++23
吧啦蹦吧2 小时前
`org.springframework.util.ClassUtils#forName
开发语言·python
学IT的周星星2 小时前
java常见面试题
java·开发语言
闻缺陷则喜何志丹2 小时前
【计算几何 线性代数】仿射矩阵的秩及行列式
c++·线性代数·数学·矩阵·计算几何·行列式·仿射矩阵得秩
wjs20242 小时前
XPath 运算符
开发语言
shoubepatien2 小时前
JAVA -- 12
java·后端·intellij-idea
Mr.朱鹏2 小时前
大模型入门学习路径（Java开发者版）上
java·开发语言·spring boot·spring·大模型·llm·transformer
黎雁·泠崖2 小时前
C 语言指针进阶教程：const 修饰、野指针规避与传址调用
c语言·开发语言
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04BongoCat - 跨平台键盘猫动画工具05在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）06jdk21下载、安装（Windows、Linux、macOS）07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Open-AutoGLM Windows 安装部署教程09sqli-labs靶场通关笔记：第18-19关 HTTP头部注入10RedissonClient的配置解析