红黑树实现

小杰帅气2025-11-28 16:03

1红黑树的概念

红黑树是一颗二叉搜索树，他的每个节点增加一个储存位来表示节点颜色，可以是红色或者黑色。

通过对任何一条从跟到叶子的路径上各个节点的颜色进行约束，红黑树保证没有任何一条路径会比其他路径长出2倍，因而接近是平衡的。

红黑树的规则

1每个节点不是黑色就是红色。

2跟节点是黑色的

3如果一个节点是红色的，则它的两个孩子必须是黑色的，也就是说任何一条路径不会有连续的两个红色节点。

4对于任何一个节点，从该节点到其所有NULL节点的简单路径上，均含有相同数量的黑色节点。

红黑树如何保证最长路径不超过最短路径的2倍的？

由规则4可知，从跟节点到NULL节点的每条路径都有相同的数量的黑色节点，所以在极端场景下 ，最短路径就是全是黑色节点的路径，假设最短路径为bh。

由规则2和规则3可知，任意一条路径都不会有连续的红点节点，所以极端场景下，最长的路径就是一黑一红间隔组成，那么最长路径理论长度就是2*bh。

综合红黑树的四点规则，理论是上的全黑最短路径和一黑一红的最长路径不是在每颗红黑树都存在的。假设任意一条从根到NULL节点路径的长度为X，那么 bh<x<2*bh。

红黑树的效率

假设N是红黑树树中节点数量，h表示最短路径，那么2^ h− 1 <= N< 2 ^2∗h− 1,由此推出h~logN,也就是说红黑树增删查改最坏也就是最长路径2*logN，那么时间复杂度是O(logN)。

红黑树控制平衡更加抽象，AVL树通过高度差直观的控制了平衡。

红黑树通过四条规则颜色约束，间接抽象的实现了近似平衡，他们的效率都是同一档次，但是相对而言，插入相同数量的节点，红黑树旋转次数是更少的，因为它对平衡控制没有那么严格。

2红黑树的实现

红黑树的结构

cpp 复制代码 
// 枚举值表⽰颜⾊
enum Colour
{
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;
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插入一个值按二叉搜索树的规则进行插入，插入后我们只需要观察是否符合红黑树的四条规则。

2如果是空树插入，新增节点是黑色节点。如果是非空树的插入，新增节点必须是红色，因为非空树插入，新增黑色节点就破坏了规则四，规则是很难维护的。

3非空树插入后，新增节点必须是红色节点，如果父亲是黑色的，则没有违反任何规则，插入结束。

4非空树插入后，新增节点必须是红色节点，如果父亲是红色的，则违反规则3。进一步分析，c是红色，p是红色，g是必定为黑，这三个颜色固定，关键看u的情况，需要根据u分为以下几种情况分别处理。

情况1变色 （u存在且为红）

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

分析

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

无论c是p的左还是右，p是g的左还是右，都是上面的处理方式。

情况2：单选＋变色

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

分析：p必须变黑，才可以解决连续红点节点问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要使用旋转＋变色来解决。

g

p u

c

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

g

u p

c

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

情况3 双选+变色

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

分析：p必须变黑，才可以解决连续红点节点问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要使用旋转＋变色来解决。

g

p u

c

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

g

u p

c

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

红黑树的查找

红黑树的验证

这里获取最长路径和最短路径，检查最长路径不超过最短路径的二倍是不可行的，因为就算满足这个条件，红黑树的颜色也可能不满足规则，当前没问题，后续插入也可能出现问题。

所以还是要去检查四条规则，满足规则，一定可以保证最长路径不超过最短路径的二倍。

1规则1枚举颜色类型，天然确保颜色不是黑色就是红色。

2规则2直接检查根就可以了

3规则3前序遍历检查，遇到红色节点查孩子不太方便，因为孩子有两个，且不一定存在，反过来检查父亲颜色就方便多了。

4规则4前序遍历，遍历过程中用形参记录跟到当前节点的blackNUM（黑色节点数量），前序遍历遇到黑色节点就++blackNUM，走到空就计算出一条路径的黑色节点数量。再任意一条路径黑色节点数量作为参考值，依次比较。

红黑树代码实现

cpp 复制代码 
#include<iostream>
using namespace std;

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:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		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* grandfather = parent->_parent;
			//    g
			//  p   u
			//c
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)
				{
					//uncle存在且为红
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					//     g
					//  p    u
					//c
					if (cur == parent->_left)
					{
						RotateR(grandfather);

						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					//     g
					//  p    u
					//    c
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						grandfather->_col =RED;
						cur->_col = BLACK;
					}
					break;
				}
			}
			else
			{
				//    g
				//  u   p
				//        c

				Node* uncle = grandfather->_left;
				// 叔叔存在且为红，-》变?即可
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 叔叔不存在，或者存在且为?
				{
					// 情况?：叔叔不存在或者存在且为?
					// 旋转+变?
					// g
					// u p
					// c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						// g
						// u p
						// c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}



	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

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

		Node* pParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

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

			subL->_parent = pParent;
		}
	}

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

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

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	int Height()
	{
		return _Height(_root);
	}

	int Size()
	{
		return _Size(_root);
	}


	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;
	}
	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);
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

	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;
	}

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

		return _Size(root->_left) + _Size(root->_right) + 1;
	}

	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			// 前序遍历?到空时，意味着?条路径?完了
			//cout << blackNum << endl;
			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);
	}
	
private:
	Node* _root = nullptr;
};
相关推荐
AI科技星3 小时前
为什么变化的电磁场才产生引力场？—— 统一场论揭示的时空动力学本质
数据结构·人工智能·经验分享·算法·计算机视觉
一起养小猫5 小时前
《Java数据结构与算法》第三篇（下）队列全解析：从基础概念到高级应用
java·开发语言·数据结构
别动哪条鱼7 小时前
AVAudioFifo
数据结构·ffmpeg·音视频
Croa-vo8 小时前
TikTok 数据工程师三轮 VO 超详细面经：技术深挖 + 建模推导 + 压力测试全记录
javascript·数据结构·经验分享·算法·面试
蘑菇小白8 小时前
时间复杂度
数据结构·算法
Cx330❀8 小时前
C++ STL set 完全指南：从基础用法到实战技巧
开发语言·数据结构·c++·算法·leetcode·面试
阿昭L10 小时前
堆结构与堆排序
数据结构·算法
.YM.Z19 小时前
【数据结构】：排序（一）
数据结构·算法·排序算法
sin_hielo1 天前
leetcode 2435
数据结构·算法·leetcode
热门推荐
01GitHub 镜像站点02【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连03BongoCat - 跨平台键盘猫动画工具04UV安装并设置国内源05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Linux下V2Ray安装配置指南07Labelme从安装到标注：零基础完整指南08Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南09全球最强模型Grok4，国内已可免费使用！（附教程）10Gemini 3.0 Pro Preview 实测报告