【C++】红黑树及其实现

h665_2024-07-01 22:36

目录

一、红黑树的定义

1.为什么提出红黑树？

AVL树和红黑树的插入、删除和查找操作的时间复杂度都是 l o g ( n ) log(n) log(n)，既然如此，为什么会提出红黑树这一概念呢？

AVL树在插入和删除过程中，为了保持平衡性，会非常频繁地调整全树整体的拓扑结构，代价较大，为此在AVL树的平衡标准上进一步放宽条件，引入了红黑树的结构。

2.红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

3.红黑树的性质

一棵红黑树是满足如下红黑性质的二叉排序树：

  1. 每个结点或是红色，或是黑色的。
  2. 根结点是黑色的。
  3. 叶结点（这里指的是空结点）都是黑色的。
  4. 不存在两个相邻的红结点（即红结点的父结点和孩子结点均是黑色的）。
  5. 对每个结点，从该结点到任意一个叶结点的简单路径上，所含黑结点的数量相同。

对于这样的红黑树，有两个结论：

  1. 从根到叶结点的最长路径不大于最短路径的2倍。
  2. 有n个内部结点的红黑树的高度 h < = 2 l o g 2 ( n + 1 ) h<=2log_2(n+1) h<=2log2(n+1)。

二、红黑树的实现

1.红黑树的结构

红黑树的结构就是在二叉排序树的基础上加上了一个表示颜色的变量，我们可以使用枚举来实现。

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

template<class T>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	T _data;
	Colour _col;	// 颜色

	RBTreeNode(const T& data)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(RED)
	{}
};

2.红黑树的插入

红黑树的插入操作也需要先按照二叉排序树的插入方式插入结点，然后根据其是否破坏了红黑树的性质来进行调整。

当我们插入一个新结点时，其默认颜色是红色，不过当这个新结点为根时，则要把它改成黑色。

红黑树的插入调整共分为三种情况，想要知道该选用哪种方式，要看的是叔叔结点的位置和颜色，因此我们想要进行调整，必须准备好四个结点：cur(当前结点)、parent(父结点)、grandfather(爷结点)和uncle(叔叔结点)。

2.1 uncle为红色

当叔叔结点为红色时，不需要旋转操作即可完成调整，先将parent和uncle变为黑色，再将grandfather变为红色即可，如果grandfather是根结点，则调整后要将其改成黑色，如果其父结点是红色则需要继续向上调整。

2.2 uncle为黑色，且是grandfather的右孩子

这里的uncle可以为空，因为叶结点就是黑色的。

此时若cur在parent的左侧，则可以进行右旋，右旋后将parent和grandfather的颜色进行交换。

若cur载parent的右侧，需要进行两次旋转，先对parent进行左旋，此时即可看作是cur在parent的左侧了，再对grandfather进行右旋，再将cur改为黑色，parent和grandfather改为红色即可。

2.3 uncle为黑色，且是grandfather的左孩子

这种情况则和上一种情况相对称，cur在parent的右侧，则可以进行左旋，左旋后将parent和grandfather的颜色进行交换。

若cur载parent的左侧，需要进行两次旋转，先对parent进行右旋，此时即可看作是cur在parent的右侧了，再对grandfather进行左旋，再将cur改为黑色，parent和grandfather改为红色即可。

以下是插入的代码实现：

cpp 复制代码 
bool Insert(const T& data)
{
	// 先按照二叉排序树的方式进行排序
	if (_root == nullptr)
	{
		_root = new Node(data);
		_root->_col = BLACK;
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (data < cur->_data)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (data > cur->_data)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(data);
	if (data < parent->_data)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	cur->_parent = parent;
	// 开始调整
	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		// 当叔叔在爷结点的右侧
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			// 当叔叔为红色
			if (uncle && uncle->_col == RED)
			{
				uncle->_col = BLACK;
				parent->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			// 当叔叔为黑色
			else
			{
				if (cur == parent->_left)
				{
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					parent->_col = RED;
					grandfather->_col = RED;
				}
				break;
			}
		}
		// 当叔叔在爷结点的左侧
		else
		{
			Node* uncle = grandfather->_left;
			// 当叔叔为红色
			if (uncle && uncle->_col == RED)
			{
				uncle->_col = BLACK;
				parent->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else // 当叔叔为黑色
			{
				if (cur == parent->_right)
				{
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					parent->_col = RED;
					grandfather->_col = RED;
				}
				break;
			}
		}
	}
	_root->_col = BLACK;
	return true;
}

3.红黑树的验证

由于红黑树的删除过于复杂，这里就不再谈了。

关于红黑树的验证，我们需要从红黑树的性质入手，查看当前红黑树是否违背了性质。性质1、3不必检查，剩下的就是2、4和5了。

关于性质2，只需要简单一条if语句即可判定。

对于性质4，我们可以对红黑树进行遍历，如果父结点和当前结点同时为红色，则可以返回false。

性质5想要判断有一点麻烦了，我们可以使用一个mark来记录某一条路径上有多少黑色结点，然后递归每一条路径，来判断是否有路径上黑色结点总值与mark不同。

以下是具体实现：

cpp 复制代码 
bool Isbalance()
{
	if (_root && _root->_col == RED)
	{
		cout << "根结点为红色" << endl;
		return false;
	}
	int benchmark = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_col == BLACK)
		{
			++benchmark;
		}
		cur = cur->_left;
	}
	return _Check(_root, 0, benchmark);
}

bool _Check(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
			{
				cout << "某条路径黑色节点数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++blacknum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "存在连续红色节点" << endl;
			return false;
		}
		return _Check(root->_left, blacknum, benchmark)
			&& _Check(root->_right, blacknum, benchmark);
	}

4.红黑树的查找效率分析

我们先引入一个概念，
黑高 ：从某结点出发（不含该结点）到达一个叶结点的任意一个简单路径上的黑结点总数称为该结点的黑高（记为bh），黑高的概念是由性质5确定的。根结点的黑高称为红黑树的黑高。

比如下图中13的bh=2，15的bh=1。

由红黑树的性质可知，从根到任意一个叶结点的简单路径最短时，就是这条路径上全是黑结点。某条路径最长时，这条路径必然是由黑结点和红结点相间构成的。这样也就引出了结论1：从根到叶结点的最长路径不大于最短路径的两倍。这样就能够知道根的黑高至少为h/2，于是就有 n > = 2 h / 2 − 1 n>=2^{h/2}-1 n>=2h/2−1可以证得结论2。

可见红黑树的"适度平衡"，由AVL树的"高度平衡"，降低到"人体一个结点左右子树的高度，相差不会超过2倍"，也降低了动态操作时调整的频率。对于一颗动态查找树，若插入和删除操作比较少，查找操作比较多，则采用AVL树比较合适，否则采用红黑树比较合适。

但由于维护这种高度平衡所付出的代价比获得的收益大得多，红黑树的实际应用更广泛，比如C++中的map和set、Java中的TreeMap和TreeSet就是用红黑树实现的。

5.整体代码

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

template<class T>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	T _data;
	Colour _col;	// 颜色

	RBTreeNode(const T& data)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(RED)
	{}
};

template<class T>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	~RBTree()
	{
		_Destroy(_root);
	}
	Node* Find(const T& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_data < key)
			{
				cur = cur->_right;
			}
			else if (cur->_data > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
	bool Insert(const T& data)
	{
		// 先按照二叉排序树的方式进行排序
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (data < cur->_data)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (data > cur->_data)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(data);
		if (data < parent->_data)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			// 当叔叔在爷结点的右侧
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				// 当叔叔为红色
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				// 当叔叔为黑色
				else
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						parent->_col = RED;
						grandfather->_col = RED;
					}
					break;
				}
			}
			// 当叔叔在爷结点的左侧
			else
			{
				Node* uncle = grandfather->_left;
				// 当叔叔为红色
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 当叔叔为黑色
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						parent->_col = RED;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	bool Isbalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根结点为红色" << endl;
			return false;
		}
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++benchmark;
			}
			cur = cur->_left;
		}
		return _Check(_root, 0, benchmark);
	}
	int Height()
	{
		return _Height(_root);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
protected:
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}
	bool _Check(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
			{
				cout << "某条路径黑色节点数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++blacknum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "存在连续红色节点" << endl;
			return false;
		}
		return _Check(root->_left, blacknum, benchmark)
			&& _Check(root->_right, blacknum, benchmark);
	}
	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);
		return leftH > rightH ? leftH + 1 : rightH + 1;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_data << " ";
		_InOrder(root->_right);
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		subR->_left = parent;
		parent->_right = subRL;
		Node* ppnode = parent->_parent;		// 记录parent的父结点

		parent->_parent = subR;

		if (subRL)
		{
			subRL->_parent = parent;
		}
		if (ppnode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}
	void RotateR(Node* parent)
	{
		// subL：parent的左孩子
		// subLR：parent的左孩子的右孩子，注意：该点可能不存在
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		subL->_right = parent;
		parent->_left = subLR;
		Node* ppnode = parent->_parent;		// 记录parent的父结点，用于连接新的子树

		parent->_parent = subL;

		if (subLR)
		{
			subLR->_parent = parent;
		}
		if (ppnode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}
private:
	Node* _root = nullptr;
};

void RBTreeTest1()
{
	// int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTree<int> t1;
	for (auto e : a)
	{
		t1.Insert(e);
	}
	t1.InOrder();
	cout << t1.Isbalance() << endl;
}

void RBTreeTest2()
{
	srand(time(0));
	const size_t N = 5000000;
	RBTree<int> t;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand() + i;
		t.Insert(x);
	}
	cout << t.Isbalance() << endl;
	cout << t.Height() << endl;
}
相关推荐
Matlab精灵几秒前
Matlab科研绘图：自定义内置多款配色函数
算法·matlab
诚丞成10 分钟前
滑动窗口篇——如行云流水般的高效解法与智能之道（1）
算法
手握风云-19 分钟前
数据结构(Java版)第二期：包装类和泛型
java·开发语言·数据结构
怀澈1221 小时前
高性能服务器模型之Reactor（单线程版本）
linux·服务器·网络·c++
chnming19872 小时前
STL关联式容器之set
开发语言·c++
带多刺的玫瑰2 小时前
Leecode刷题C语言之统计不是特殊数字的数字数量
java·c语言·算法
爱敲代码的憨仔2 小时前
《线性代数的本质》
线性代数·算法·决策树
威桑2 小时前
MinGW 与 MSVC 的区别与联系及相关特性分析
c++·mingw·msvc
熬夜学编程的小王2 小时前
【C++篇】深度解析 C++ List 容器：底层设计与实现揭秘
开发语言·数据结构·c++·stl·list
yigan_Eins2 小时前
【数论】莫比乌斯函数及其反演
c++·经验分享·算法
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿