C++之红黑树

想唱rap2025-12-03 11:05

一、红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或

Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

注意：红黑树确保没有一条路径会比其他路径长出俩倍，也就是说最常路径不超过最短路径的两倍

二、红黑树的性质

  1. 每个结点不是红色就是黑色

  2. 根节点是黑色的

  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的（说明任何路径没有连续的红色节点）

  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 （每条路径上的黑色节点数量相等）

  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

三、红黑树的插入操作

3.1红黑树的插入操作思路图

3.2红黑树的插入代码实现

cpp 复制代码 
#pragma once
#include<iostream>
#include<set>
#include<assert.h>
#include<stdbool.h>
#include<time.h>
#include<vector>
using namespace std;
enum color
{
	RED,
	BLACK
};
template<typename K,typename V>
class RBTreeNode
{
public:
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	color _color;
	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_color(RED)
	{ }
};
template<typename K,typename V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_color = 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->_color = RED;//把除根节点以外的节点首次设置成红色

		//把新结点链接到上一个结点的后面
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			assert(false);
		}
		cur->_parent = parent;

		//对颜色进行调节
		while (parent && parent->_color == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;

				if (uncle && uncle->_color == RED)//uncle存在且为红色
				{
					//变色处理
					uncle->_color = BLACK;
					parent->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//uncle不存在或者uncle为黑色
				{
					if (cur == parent->_left)//cur在parent左边，进行单旋
					{
						//对grandfather进行右旋
						RotateR(grandfather);
						//对parent和grandfather进行颜色的更改
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else//cur在parent的右边，进行双旋
					{
						//先对parent进行左旋
						RotateL(parent);
						//在对grandfather进行右旋
						RotateR(grandfather);
						grandfather->_color = RED;
						cur->_color = BLACK;
					}
					break;
				}
			}
			else//parent在grandfather的右边
			{
				Node* uncle = grandfather->_left;

				if (uncle && uncle->_color == RED)//uncle存在且uncle为红色
				{
					//变色处理
					parent->_color = BLACK;
					grandfather->_color = RED;
					uncle->_color = BLACK;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//uncle不存在或者uncle为黑色
				{
					if (cur == parent->_right)//cur在parent的右边（cur和pg在一条直线上）
					{
						//向左进行旋
						RotateL(grandfather);
						//颜色处理
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else//cur在parent的左边
					{
						//先进行右旋
						RotateR(parent);
						//在进行左旋
						RotateL(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}
					break;
				}
			}
		}
		_root->_color = BLACK;
		return true;
	}
	//左单旋
	void RotateL(Node* parent)
	{

		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;

		Node* ppnode = parent->_parent;

		parent->_parent = cur;


		if (parent == _root)
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;

			}

			cur->_parent = ppnode;
		}
	}
	//右单旋
	void RotateR(Node* parent)
	{

		Node* cur = parent->_left;
		Node* curright = cur->_right;

		parent->_left = curright;
		if (curright)
			curright->_parent = parent;

		Node* ppnode = parent->_parent;
		cur->_right = parent;
		parent->_parent = cur;

		if (ppnode == nullptr)
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;
			}

			cur->_parent = ppnode;
		}
	}
	//红黑树判断是否平衡
	bool CheckColor(Node* root, int blacknum, int benchmark)//此处不加引用算的是每条路径上的节点数量
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
			{
				return false;
			}
			return true;
		}

		if (root->_color == BLACK)
		{
			++blacknum;
		}

		if (root->_color == RED && root->_parent && root->_parent->_color == RED)
		{
			cout << "root->_kv.first" << "出现连续的红色结点" << endl;
			return false;
		}

		return CheckColor(root->_left, blacknum, benchmark) && CheckColor(root->_right, blacknum, benchmark);
	}
	bool _IsBalance()
	{
		return IsBalance(_root);
	}
	bool IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		//检查根节点是否为黑色
		if (root->_color != BLACK)
		{
			return false;
		}

		//求出最左路径作为基准值
		int benchmark = 0;
		Node* cur = root;
		while (cur)
		{
			if (cur->_color == BLACK)
			{
				++benchmark;
			}
			cur = cur->_left;
		}
		//检查是否右连续的红色结点
		return CheckColor(root, 0, benchmark);
	}
	//求高度
	int Height()
	{
		return Height(_root);
	}

	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}
protected:
	Node* _root = nullptr;
};

四、红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)

  2. 检测其是否满足红黑树的性质

cpp 复制代码 
//红黑树判断是否平衡
bool CheckColor(Node* root, int blacknum, int benchmark)//此处不加引用算的是每条路径上的节点数量
{
	if (root == nullptr)
	{
		if (blacknum != benchmark)
		{
			return false;
		}
		return true;
	}

	if (root->_color == BLACK)
	{
		++blacknum;
	}

	if (root->_color == RED && root->_parent && root->_parent->_color == RED)
	{
		cout << "root->_kv.first" << "出现连续的红色结点" << endl;
		return false;
	}

	return CheckColor(root->_left, blacknum, benchmark) && CheckColor(root->_right, blacknum, benchmark);
}
bool _IsBalance()
{
	return IsBalance(_root);
}
bool IsBalance(Node* root)
{
	if (root == nullptr)
	{
		return true;
	}
	//检查根节点是否为黑色
	if (root->_color != BLACK)
	{
		return false;
	}

	//求出最左路径作为基准值
	int benchmark = 0;
	Node* cur = root;
	while (cur)
	{
		if (cur->_color == BLACK)
		{
			++benchmark;
		}
		cur = cur->_left;
	}
	//检查是否右连续的红色结点
	return CheckColor(root, 0, benchmark);
}
//求高度
int Height()
{
	return Height(_root);
}

int Height(Node* root)
{
	if (root == nullptr)
		return 0;

	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

五、红黑树的测试

cpp 复制代码 
int main()
{
	int a[] = { 1,2,4,12,45,67 };
	RBTree<int, int> RBT1;
	for (auto element : a)
	{
 		RBT1.Insert(make_pair(element, element));
		cout << "Insert" << element << ":" << RBT1._IsBalance() << endl;
		cout << "高度为:" << RBT1.Height() << endl;
	}

	const int N = 100;
	srand((size_t)time(0));

	RBTree<int, int> RBT2;
	vector<int> v;
	for (size_t i = 0; i <= N; i++)
	{
		v.push_back(rand());
	}
	for (auto e : v)
	{
		RBT2.Insert(make_pair(e, e));
		cout << "Insert" << e << ":" << RBT2._IsBalance() << endl;
		cout << "高度为:" << RBT2.Height() << endl;
	}


	return 0;
}

六、红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(log_2 N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数， 所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红 黑树更多。

相关推荐
Hello.Reader1 小时前
FF4J 用特性开关玩转 Java 应用灰度与发布
java·开发语言
某林2121 小时前
在slam建图中为何坐标base_link，laser，imu_link是始终在一起的，但是odom 会与这位三个坐标在运行中产生偏差
人工智能·算法
想看一次满天星1 小时前
阿里140-n值纯算
爬虫·python·算法·网络爬虫·阿里140
Keep__Fighting1 小时前
【机器学习：逻辑回归】
人工智能·python·算法·机器学习·逻辑回归·scikit-learn·matplotlib
无限进步_1 小时前
C++运算符重载完全指南：从基础到实战应用
开发语言·数据库·c++·windows·git·github·visual studio
sin_hielo1 小时前
leetcode 3623
算法·leetcode·哈希算法
Dxxyyyy1 小时前
零基础学JAVA--Day40(坦克大战)
java·开发语言
郑州光合科技余经理1 小时前
PHP技术栈：上门系统海外版开发与源码解析
java·开发语言·javascript·git·uni-app·php·uniapp
( •̀∀•́ )9201 小时前
高性能拖拽排序
java·开发语言·算法
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04BongoCat - 跨平台键盘猫动画工具05本地部署阿里最新开源的Z-Image06Linux下V2Ray安装配置指南07Meta第三代“分割一切”模型——SAM 3本地部署教程：首支持文本提示分割，400万概念、30毫秒响应，检测分割追踪一网打尽08【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连09【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）10Labelme从安装到标注：零基础完整指南