C++：红黑树（RBT）

于 2024-07-28 00:39:38 发布
阅读量506 收藏 13
点赞数 26
文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80153885/article/details/140727745
版权

hello，各位小伙伴，本篇文章跟大家一起学习《C++：红黑树（RBT）》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！

文章目录

红黑树（RBT）的概念

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

红黑树（RBT）的性质：

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

总结就是三个规则：

  • 根节点是黑色的
  • 每条路径的黑色节点数目相同
  • 不能有连续的2个红色节点

满足以上性质，红黑树（RBT）就能保证其最长路径中节点个数不会超过最短路径节点个数的两倍。

假设最短路径寻找节点时间复杂度为O( l o g 2 n log_2 n log2​n)。
那么最长路径寻找节点时间复杂度为O( l o g 2 2 n log_2 2n log2​2n)。
实质上时间差不了多少。

红黑树节点的定义

enum Color // 节点颜色
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>(const T& data = T(),Color col = RED)
	:_data(data)
	, _parent(nullptr)
	, _left(nullptr)
	, _right(nullptr)
	, _col(col) // 新增节点默认为红色
{}
	
	T _data;
	RBTreeNode<T>* _parent;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	Color _col;
};

相比于AVL树也就是将平衡因子改为节点颜色。这样做的目的是为了减少结点的旋转。

为什么新增节点默认为红色呢？
因为在RBT规则里：**每条路径的黑色节点数目必须相同。**当出现2个红色节点时进行处理。

RBT结构

// KeyOfVal为伪函数，当传入的值为pair时，可以确定值是什么
template<class K, class T, class KeyOfVal>
class RBTree
{
	typedef RBTreeNode<T> Node;
	
public:
	typedef RBTreeIterator<T, T&, T*> Iterator;// 迭代器
	typedef RBTreeIterator<const T, const T&, const T*> Const_Iterator;

	RBTree() = default;// 强制生成默认构造

	RBTree(const RBTree& t)// 拷贝构造
	{
		_root = Copy(t._root);
	}
private:
	// 旋转操作和平衡二叉树一样
	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  RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
	
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
	
		Node* parentParent = parent->_parent;
	
		subL->_right = parent;
		parent->_parent = subL;
	
		if (parentParent == nullptr)// 更改根节点
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
	
			subL->_parent = parentParent;
		}
	}
	
	
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
	
		RotateR(parent->_right);
		RotateL(parent);
	}
	
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
	
		RotateL(parent->_left);
		RotateR(parent);
	
	}
	
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
	
		Node* newRoot = new Node(root->_key, root->_value);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);
	
		return newRoot;
	}
	
	Node* _root;

insert插入操作

当出现两个连续的红色节点时分两种情况：

  • 叔叔节点存在且为红色
  • 叔叔存在且为黑色或者叔叔不存在（叔叔为空）

在这里插入图片描述

  1. 当叔叔节点存在且为红色时，直接让父节点和叔叔节点变为黑色，祖先节点（gparent）变为红色，继续向上调整
  2. 当叔叔节点存在且为黑色或者叔叔节点不存在（空）时，旋转处理，旋转后调整颜色

对于旋转处理与AVL树一样，可看C++：平衡搜索二叉树（AVL）

// 返回pair<Iterator, bool>
pair<Iterator, bool> Insert(const T& data)
{
	KeyOfVal kt;
	if (_root == nullptr)// 创建根节点
	{
		_root = new Node(data);
		_root->_col = BLACK;
		return make_pair(Iterator(_root, _root), true);
	}

	Node* cur = _root;
	Node* parent = nullptr;

	while (cur)
	{
		if (kt(cur->_data) < kt(data))
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kt(cur->_data) > kt(data))
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		// 发现该值存在，插入失败
			return make_pair(Iterator(cur, cur), false);
	}

	cur = new Node(data);
	Node* newnode = cur;
	// cur->_col = RED; 默认新增节点为红色
	if (kt(data) > kt(parent->_data))
		parent->_right = cur;
	else
		parent->_left = cur;

	cur->_parent = parent;

	// 出现两个连续的红色节点，进行操作
	while (parent && parent->_col == RED)
	{
		Node* gparent = parent->_parent;

		if (parent == gparent->_left)
		{
			Node* uncle = gparent->_right;
			if (uncle && uncle->_col == RED)
			{
				// u存在且为红 ->变色再继续往上处理
				parent->_col = uncle->_col = BLACK;
				gparent->_col = RED;

				cur = gparent;
				parent = cur->_parent;
			}
			else
			{
				// u存在且为黑或不存在 ->旋转+变色
				if (cur == parent->_left)
				{
					RotateR(gparent);
					parent->_col = BLACK;
					gparent->_col = RED;
				}
				else
				{
					RotateLR(gparent);
					cur->_col = BLACK;
					gparent->_col = RED;
				}
				break;
			}
		}
		else
		{
			Node* uncle = gparent->_left;
			if (uncle && uncle->_col == RED)
			{
				// u存在且为红 ->变色再继续往上处理
				parent->_col = uncle->_col = BLACK;
				gparent->_col = RED;

				cur = gparent;
				parent = cur->_parent;
			}
			else
			{
				// u存在且为黑或不存在 ->旋转+变色
				if (cur == parent->_right)
				{
					RotateL(gparent);
					parent->_col = BLACK;
					gparent->_col = RED;
				}
				else
				{
					RotateRL(gparent);
					cur->_col = BLACK;
					gparent->_col = RED;
				}
				break;
			}
		}
	}
	// 由于并不知道根节点会不会被改为红色，所以直接将根节点改为黑色
	_root->_col = BLACK;
	return make_pair(Iterator(newnode, _root), true);
}

迭代器的实现

template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;

	Node* _node;
	Node* _root;

	RBTreeIterator(Node* node, Node* root)
		:_node(node)
		, _root(root)
	{}

	Self& operator++()
	{
		if (_node->_right)
		{
			// 右不为空，右子树最左节点就是中序第一个
			Node* leftMost = _node->_right;
			while (leftMost->_left)
			{
				leftMost = leftMost->_left;
			}

			_node = leftMost;
		}
		else
		{
			// 孩子是父亲左的那个祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = cur->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node == nullptr) // end()
		{
			// --end()，特殊处理，走到中序最后一个节点，整棵树的最右节点
			Node* rightMost = _root;
			while (rightMost && rightMost->_right)
			{
				rightMost = rightMost->_right;
			}

			_node = rightMost;
		}
		else if (_node->_left)
		{
			// 左子树不为空，中序左子树最后一个
			Node* rightMost = _node->_left;
			while (rightMost->_right)
			{
				rightMost = rightMost->_right;
			}

			_node = rightMost;
		}
		else
		{
			// 孩子是父亲右的那个祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = cur->_parent;
			}

			_node = parent;

		}

		return *this;
	}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator!= (const Self& s)
	{
		return _node != s._node;
	}

	bool operator== (const Self& s)
	{
		return _node == s._node;
	}
};

迭代器++操作和迭代器–操作

在这里插入图片描述
根据搜索二叉树的性质，迭代器++操作找下一个节点实质上就是走左、根、右的顺序，迭代器- -则是反过来操作右、根、左的顺序。当在end()进行- -操作时要进行特殊处理

代码实现：

Self& operator++()
	{
		if (_node->_right)
		{
			// 右不为空，右子树最左节点就是中序第一个
			Node* leftMost = _node->_right;
			while (leftMost->_left)
			{
				leftMost = leftMost->_left;
			}

			_node = leftMost;
		}
		else
		{
			// 孩子是父亲左的那个祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = cur->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node == nullptr) // end()
		{
			// --end()，特殊处理，走到中序最后一个节点，整棵树的最右节点
			Node* rightMost = _root;
			while (rightMost && rightMost->_right)
			{
				rightMost = rightMost->_right;
			}

			_node = rightMost;
		}
		else if (_node->_left)
		{
			// 左子树不为空，中序左子树最后一个
			Node* rightMost = _node->_left;
			while (rightMost->_right)
			{
				rightMost = rightMost->_right;
			}

			_node = rightMost;
		}
		else
		{
			// 孩子是父亲右的那个祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = cur->_parent;
			}

			_node = parent;

		}

		return *this;
	}

在RBTree类中的代码：

typedef RBTreeIterator<T, T&, T*> Iterator;
typedef RBTreeIterator<const T, const T&, const T*> Const_Iterator;
Node* Leftmost()
{
	Node* cur = _root;
	while (cur && cur->_left != nullptr)
	{
		cur = cur->_left;
	}
	return cur;
}

Iterator Begin()
{
	Node* cur = Leftmost();
	return Iterator(cur,_root);
}

Iterator End()
{
	return Iterator(nullptr,_root);
}

Const_Iterator Begin() const
{
	Node* cur = Leftmost();
	return Iterator(cur, _root);
}

Const_Iterator End() const
{
	return Const_Iterator(nullptr,_root);
}

红黑树是否满足规则验证

直接看代码：

void testrbtree1()
{
	class A
	{
	public:
		int operator()(const T& val)
		{
			return val;
		}
	};
	RBTree<int, int, A> t;
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a)
	{
		/*if (e == 9)
		{
			int i = 0;
		}*/

		t.Insert(e);

		//cout << e << "->" << t.isbalancetree() << endl;
	}

	t.inorder();
	cout << t.isbalance() << endl;
}

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

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

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

int Size()
{
	return _Size(_root);
}
private:
	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->_data << "存在连续的红色节点" << endl;
			return false;
		}
	
		if (root->_col == BLACK)
		{
			blackNum++;
		}
	
		return Check(root->_left, blackNum, refNum)
			&& Check(root->_right, blackNum, refNum);
	}
	
	int _Size(Node* root)
	{
		return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
	}
	
	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;
	
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
	
		_InOrder(root->_left);
		cout << root->_data << " ";
		_InOrder(root->_right);
	}

private:
	int _rotateNum;
}

注意：要在左旋和右旋的实现代码中增加：

_rotateNum++;

在主函数中调用：

class A
{
public:
	int operator()(const int& val)
	{
		return val;
	}
};
int main()
{
	RBTree<int, int,A> t;
	t.testrbtree1();
	return 0;
}

你学会了吗？
好啦，本章对于《C++：红黑树（RBT）》的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！！！

如你喜欢，点点赞就是对我的支持，感谢感谢！！！

请添加图片描述

Sherry_iyao
关注
  • 26
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
红黑树_ C++模板实现
11-08
详细的红黑树C++模板实现，调试后运行正确。 template class RBTree { private: static node<T> *nil;//哨兵，静态成员，被整个RBTree类所共有 node<T> *root; RBTree(const RBTree&);//禁止复制构造 RBTree ...
根据随机生成的数构造红黑树的代码（C++)
04-19
根据提供的文件信息，本文将详细解释如何使用C++实现基于随机生成数字构建红黑树的过程。主要内容包括：红黑树的基本概念、构建红黑树的关键函数解析、以及具体实现细节。 ### 红黑树基本概念 红黑树是一种自平衡...
学习-＞C++篇十五：红黑树和map,set
u014801954的博客
10-18 763
目录 一 . 红黑树的定义（规则）： 二 . 红黑树是如何保持平衡的？ 插入操作： 情况一：叔叔节点存在且为红色 情况二：叔叔节点不存在或存在且为黑色 三.map和set如何封装？
树（七）：红黑树(RBT) C++实现
Worthy_Wang的博客
02-23 452
文章目录
C++ 红黑树
weixin_53946312的博客
01-28 1476
红黑树
红黑树 RBT
qq_56711779的博客
06-21 133
平衡二叉树 任意一个节点，他的左子树最大深度与右子树最大深度不能超过1。 二叉排序树 任何一个节点的左子节点都小于该节点，右子节点大于该节点。 AVL 平衡二叉排序树，结合二者特点。 （上图中 0 、-1、 1为每个节点的平衡因子） 二叉排序树在添加节点的时候会改变左右子树的深度（平衡因子），就会打破平衡，同理删除也会，故引入了左旋和右旋的方法来维持二叉树的平衡。 LL型 使用右旋平衡左右子树的绝对因子。 ①将A的左孩......
红黑树RBT的（C++）实现
liuchenjane的博客
11-19 774
//RBT--红黑树 //红黑树是“平衡”搜索树的一种 //红黑树满足下面的性质： //1.每个节点或是红色或是黑色 //2.根节点是黑色的 //3.每个叶节点(NIL) 是黑色的 //4.如果一个节点是红色的，则它的两个子节点都是黑色的 //5.对每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点 #include using namespace std; class
红黑树（C++实现）
2202_75331338的博客
07-22 946
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
二叉搜索树：红黑树的原理和实现
Pursue quality, not quantity.
03-30 1108
程序员的“浪漫”——手撕红黑树
C++ 基于红黑树的map和set
qq_54178958的博客
10-18 587
/ 节点的颜色// 红黑树节点的定义{{}// 节点的左孩子// 节点的右孩子// 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)// 节点的值域// 节点的颜色};
C++红黑树封装set和map（很详细）
kkbca的博客
12-06 1003
set和map的底层就是红黑树，现在我们要用这一棵树来封装STL里面的容器：set和map。
RBT.rar_red black tree_红黑树
09-24
在C++中实现红黑树，通常涉及到节点定义、颜色枚举、旋转操作以及插入、删除和查找等基本操作。 首先，我们需要定义红黑树的节点结构。每个节点包含一个键值、颜色属性（红色或黑色）、指向左右子节点的指针，以及...
rbt.rar_rbt_red black tree_动态演示_红黑树
09-14
红黑树的应用广泛，例如在操作系统、数据库系统以及各种编程语言的标准库中都有使用，如C++的STL中的map和set容器就基于红黑树实现。 在“www.pudn.com.txt”文件中，可能包含了关于红黑树的更多详细信息，例如代码...
rbt.rar_C builder tree
09-22
标题“rbt.rar_C++ builder tree”表明这是一个关于使用C++编程语言构建红黑树的项目或代码库。可能包含了实现红黑树的各种功能，如插入、删除、查找等操作的源代码文件。 描述中提到的“用C++来实现数据结构中的...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1190
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 658
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 271
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1133
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值