【数据结构】红黑树（C++实现）

于 2024-03-11 09:45:00 发布
阅读量2k 收藏 98
点赞数 105
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77112634/article/details/136523992
版权

👀樊梓慕：个人主页

 🎥个人专栏：《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》《算法》

🌝每一个不曾起舞的日子，都是对生命的辜负

目录

前言

1.概念

2.性质

3.节点的定义 

4.插入

4.1情况1：叔叔u存在且为红

4.2情况2：叔叔u不存在或者叔叔u存在且为黑

4.3代码实现

5.验证

6.红黑树完整源码

7.AVL树与红黑树的性能比较

前言

如果没有现在的红黑树的话，那么可能set与map底层的数据结构就是AVL树了，那么红黑树的设计为什么能够取代AVL树的地位呢，红黑树的设计又有哪些奥秘，今天让我们一同来探索一下吧！

欢迎大家📂收藏📂以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。 

=========================================================================

GITEE相关代码：🌟樊飞 (fanfei_c) - Gitee.com🌟

=========================================================================

1.概念

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

红黑树不像AVL树那样绝对的平衡，而是接近平衡，

但是这个影响是常数级别的，接着往下看。

2.性质

了解了红黑树的性质，你就明白了为什么红黑树是如何控制平衡的。

  • 每个结点不是红色就是黑色
  • 根节点是黑色的
  • 如果一个节点是红色的，则它的两个孩子结点必须是黑色的（没有连续的红色节点）。
  • 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。
  • 每个叶子结点都是黑色的(此处的叶子结点指的是空结点-NIL节点，因为路径指的是从根节点走到空，而不是从根节点走到叶子节点，所以设计者专门将空节点定义为NIL节点默认为黑色，就是为了防止人们数错路径)。

接下来我们构建极端场景来分析下为什么最长路径中节点的个数不会超过最短路径节点个数的两倍？

  • 最短路径情况：节点为全黑。
  • 最长路径情况：一黑一红排列。
  • 大前提：每条路径都包含相同数量的黑色节点。

举例：

而且红黑树不是每次搜索都是2*logN。 

 AVL树与红黑树搜索效率基本平齐，但是AVL树实现更小的高度的方法是频繁地旋转，而旋转的开销还是比较大的，所以AVL树有点『 得不偿失』。

红黑树虽然也需要旋转来控制高度，但是引入了颜色控制，可以减少旋转的次数。

3.节点的定义 

enum Colour
{
	RED,
	BLACK
};

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

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

思考：节点的默认颜色为什么是红色？ 

因为如果插入黑色节点就一定会破坏规则（每条路径上的黑色节点数相同），并且会影响其他路径。

所以我们需要设置节点的默认颜色为红色。

4.插入

因为新节点的默认颜色是红色，因此

  • 如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；
  • 但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：

所以以下都是当新插入节点的父节点为红色时的情况： 

4.1情况1：叔叔u存在且为红

 g的颜色是确定为黑的，因为如果g不为黑，那么就证明上一层就已经不满足红黑树的规则了。

此时c一定是新插入的节点，并且已经破坏了没有连续的红色节点的规则，所以我们需要进行调整。

调整的办法：p/u变黑，g变红。

 g变红的目的是为了保持当前分支黑色节点的数目不变。

但这里注意：

  • 如果g为根节点，那么需要再将g变黑（规则：根节点必须是黑色），即将所有路径的黑色节点数都+1，仍然符合规则。
  • 如果g不为根节点，那么g为红色，此时将g视为cur，继续向上调整。

4.2情况2：叔叔u不存在或者叔叔u存在且为黑

 同样的g的颜色是确定为黑的，因为如果g不为黑，那么就证明上一层就已经不满足红黑树的规则了。

  • 如果叔叔u不存在，那么c一定是新插入的节点，因为叔叔u不存在说明在parent的下面不可能再挂黑色结点了。
  • 如果叔叔u存在且为黑，那么c一定不是新插入的节点，因为之前已经不满足规则了，所以c一定是刚刚变红的，也就是说有可能是情况1调整过后，将c变红的。 

此时单纯地变色已经无法处理了，所以此时我们需要进行旋转。

很明显根据之前学习的AVL树，面对如上图情况时我们需要对g进行右旋。 

即当p为g的左，cur为p的左时对g进行右旋：

注意：之前分析由于cur是因为之前的调整才变红的，所以cur向下的路径中一定有一个黑色节点与叔叔抵消，此时达到平衡。

如果叔叔不存在也是一样的对g进行右旋即可：

那么假如cur在p的右子树上呢？此时则需要先左旋再右旋。

即当p为g左，cur为p的右时进行左右双旋，然后变色。

  同样的如果叔叔不存在也是一样的进行左右双旋，然后变色。

总结下来就以上这些种情况，相信你掌握了左面的这些种情况，右面也非常简单。

4.3代码实现

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); // 红色的
	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;
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			// 情况一：叔叔存在且为红
			if (uncle && uncle->_col == RED)
			{
				// 变色
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 继续往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				// 情况二：叔叔不存在或者存在且为黑
				// 旋转+变色
				if (cur == parent->_left)
				{
					//       g
					//    p    u
					// c
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//       g
					//    p     u
					//      c
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else
		{
			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 RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

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

	subR->_left = parent;
	Node* ppnode = parent->_parent;
	parent->_parent = subR;

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

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

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

	subL->_right = parent;

	Node* ppnode = parent->_parent;
	parent->_parent = subL;

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

5.验证

红黑树的验证分为两步：

首先要对树是否满足搜索特性进行检测，这一部分我们只需要对树进行中序遍历，观察得到的序列是否为有序序列即可。

其次就是如何判断该树满足红黑树的特性呢？

其实就是看是否满足红黑树的规则即可。

即：

  • 根节点是黑色的；
  • 没有连续的红色节点；
  • 每条路径均包含相同数目的黑色结点。

首先根节点是否为黑很好检测。

其次是否有连续的红色节点，由于我们采用的是三叉链式结构，我们维护了父亲节点，所以只需要判断当前节点和父亲节点是否同时为红即可。

最后就是如何判断每条路径的黑色节点数目是否相同，其实最简单的做法就是先统计一下最左路径的黑色节点数目，然后将该值作为参考，检验其他路径是否与该值相同即可。

bool Check(Node* cur, int blackNum, int refBlackNum)
{
	if (cur == nullptr)
	{
		if (refBlackNum != blackNum)
		{
			cout << "黑色节点的数量不相等" << endl;
			return false;
		}
		return true;
	}

	if (cur->_col == RED && cur->_parent->_col == RED)
	{
		cout << cur->_kv.first << "存在连续的红色节点" << endl;
		return false;
	}

	if (cur->_col == BLACK)
		++blackNum;

	return Check(cur->_left, blackNum, refBlackNum)
		&& Check(cur->_right, blackNum, refBlackNum);
}

bool IsBalance()
{
	if (_root && _root->_col == RED)
		return false;

	int refBlackNum = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_col == BLACK)
			refBlackNum++;

		cur = cur->_left;
	}
	return Check(_root, 0, refBlackNum);
}

6.红黑树完整源码

enum Colour
{
	RED,
	BLACK
};

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

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

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); // 红色的
		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;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					if (cur == parent->_left)
					{
						//       g
						//    p    u
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//       g
						//    p     u
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else
			{
				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 RotateL(Node* parent)
	{
		++rotateSize;

		Node* subR = parent->_right;
		Node* subRL = subR->_left;

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

		subR->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subR;

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

	void RotateR(Node* parent)
	{
		++rotateSize;

		Node* subL = parent->_left;
		Node* subLR = subL->_right;

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

		subL->_right = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = subL;

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

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

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

	void InOrder()
	{
		_InOrder(_root);
	}

	bool Check(Node* cur, int blackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			if (refBlackNum != blackNum)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}

			//cout << blackNum << endl;
			return true;
		}

		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		if (cur->_col == BLACK)
			++blackNum;

		return Check(cur->_left, blackNum, refBlackNum)
			&& Check(cur->_right, blackNum, refBlackNum);
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				refBlackNum++;

			cur = cur->_left;
		}

		return Check(_root, 0, refBlackNum);
	}

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

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

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

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

	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 Height()
	{
		return _Height(_root);
	}

	int GetRotateSize()
	{
		return rotateSize;
	}

private:
	Node* _root = nullptr;
	int rotateSize = 0;
};

注：rotateSize成员是用来记录旋转次数的，若不记录可以删除。 

7.AVL树与红黑树的性能比较

 如上图，这是在一千万数据下得到的测试结果。

结论：红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是logN，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，红黑树降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多（比如STL库中的set和map容器，linux内核等等）。而AVL树虽然在高度和搜索上优于红黑树，但基本可以忽略。

=========================================================================

如果你对该系列文章有兴趣的话，欢迎持续关注博主动态，博主会持续输出优质内容

🍎博主很需要大家的支持，你的支持是我创作的不竭动力🍎

🌟~ 点赞收藏＋关注 ~🌟

=========================================================================

樊梓慕
关注
  • 105
    点赞
  • 踩
  • 98
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 73
    评论
专栏目录
红黑树 C++源代码实现
老衣的专栏
04-15 1511
<br /> 今天看了csdn博主july写的红黑树系列，觉得他写的非常好，研究了很长时间的红黑树 ，终于觉得明白些了。july写的C++源代码实现，已经非常好了，我只是在他的基础上  稍微做了一下修改，能够知道每个节点是个红  还是黑色的。<br />july的博客地址：http://blog.csdn.net/v_JULY_v/archive/2011/03/29/6285620.aspx，可以去他那看看他的系列！<br />直接上代码：<br />RB_tree.h<br />//file RBTre
红黑树C++实现大学生课程设计
12-11
数据结构课程设计，实现红黑树。我这有详细的设计实验报告，外加PPT，需要的话留言发给你，仅供参考嘿嘿
红黑树的C++实现
01-24
程序为红黑树的C++代码实现，主要包括插入删除查找等操作，红黑树具体可以参考算法导论第3版第13章
C++实现红黑树
痴心不改的博客
08-30 541
#pragma once #include&lt;iostream&gt; using namespace std; enum COLOR{BLACK,RED}; template&lt;class K,class V&gt; struct RBTreeNode { RBTreeNode&lt;K, V&gt;* _left; RBTreeNode&lt;K, V&gt;* _...
红黑树c++实现
小小程序员
03-06 1248
一、红黑树的基本概念 性质： 1、根结点的颜色是黑色 2、红结点的两个孩子都为黑色 3、根结点的父结点，所有叶子结点都为黑色（在程序中用NIL替换） 4、每个结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点   黑高：从某个结点出发（不含该结点）到达一个叶结点的任意一条简单路径上的黑色结点个数称为该结点的黑高   二、c++源代码 #include using
红黑树C++实现
Brant_zero的博客
11-24 1338
红黑树c++实现，平衡二叉搜索树。插入、查找、平衡调整、平衡判定、高度检测、升序遍历(中序遍历)
红黑树（C++实现）
热门推荐
2021dragon的博客
12-06 1万+
红黑树（C++实现）
红黑树 | C++实现
何如是
03-09 120
1.红黑树的定义与性质 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过 对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩 倍，因而是接近平衡的。 性质： 每个结点不是红色就是黑色。 根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的。 对于每个结点，从该结点到其所有后代叶结点的简单...
模板--红黑树（C++实现）
qq_42418728的博客
01-18 429
一、结点类与红黑树类： （一）结点类基本数据成员： 1.左右子结点指针域 2.父结点指针域，方便回访父结点 3.有序 前驱 /后继指针域，迭代访问元素，提供一种顺序存储的假象 4.结点颜色，利用红黑规则，保持树的平衡。 （二）结点类的基本成员函数： 两个重载的构造函数，构造红色的新结点 （三）红黑树类基本数据成员： 1.头结点：保存一个据点，用来维系根节点与公用空结点 2....
【C++】红黑树的实现
m0_65679465的博客
05-16 607
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。map 、set 两个关联式容器的底层就是红黑树。
红黑树实现源码
07-22
关于红黑树的功能实现
C++简单实现红黑树
最新发布
weixin_50601177的博客
09-28 272
C++实现红黑树
红黑树的详细实现(C++)
code_peak
10-08 6004
红黑树概念(concept) 树型结构主要用于搜索，一直是科学领域的重要演算法，当中探讨了树可能遇到的问题：树的成长可能偏向于一边，也就是不平衡现象。 二叉树是常见且广泛使用的一种树，面临其可能退化成链表的潜藏缺点，在使用上难免让人担心其效率。此外，在一些应用上，可能不希望这样的不平衡的可能性发生。所以具有自动平衡左右数量分布效果的演算算法早在 1962 年被提出，称为 AVL 树。这种平衡成长的二叉搜索树被称为自平衡二叉搜索树。 接下来，介绍同为自平衡二叉搜索树的红黑树对平衡性的要求比 AVL 树还要宽松
详解红黑树【C++实现】
Tau_Ceti的博客
08-31 648
详解红黑树
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2248
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
红黑树(RBTree)c++实现
m0_73904148的博客
06-14 543
在上一期的AVL树中，这种树虽然能保持树的高度是平衡的，但还有一个缺陷那就是会导致频繁旋转，一定程度上降低了树的效率，而我们这期的红黑树解决的就是AVL树中频繁旋转的问题红黑树底层是一颗二叉搜索树，但在结点类中还加入了一个状态用来表示结点红色还是黑色else//查找插入的位置，parent记录上一次查看的结点else//理论上不可能走到这else//调整颜色的接口//如果parent是黑色，那么插入一个红节点就不会违反性质了。
C++---红黑树介绍及简单实现
blue_jun_的博客
11-05 483
C++---红黑树性质介绍，即插入节点情况详细分析以及实现，红黑树的验证。
C++map的数据结构红黑树
07-09
在C++中，std::map 是使用红黑树（RedBlack Tree）作为底层数据结构实现的。红黑树是一种自平衡二叉查找树，它具有以下特点： 1. 每个节点要么红色，要么是黑色。 2. 根节点是黑色的。 3. 所有叶子节点（NIL节点）都是黑色的。 4. 如果一个节点是红色的，则它的两个子节点都是黑色的。 5. 对于每个节点，从该节点到其后代叶子节点的简单路径上，均包含相同数目的黑色节点。 这些特性保证了红黑树的平衡性，使得在最坏情况下，插入、删除和查找操作的时间复杂度都是O(log n)。 std::map 是C++标准库中提供的关联容器之一，它提供了一种键值对的存储方式，并根据键的顺序自动进行排序。通过使用红黑树作为底层数据结构，std::map 可以在插入、删除和查找操作上具有较好的性能表现。 以下是一个使用 std::map 的简单示例： ```cpp #include <iostream> #include <map> int main() { std::map<int, std::string> myMap; // 插入键值对 myMap.insert(std::make_pair(1, "Apple")); myMap.insert(std::make_pair(2, "Banana")); myMap.insert(std::make_pair(3, "Orange")); // 遍历输出 for (const auto& pair : myMap) { std::cout << pair.first << ": " << pair.second << std::endl; } // 查找键对应的值 auto it = myMap.find(2); if (it != myMap.end()) { std::cout << "Value of key 2: " << it->second << std::endl; } return 0; } ``` 上述示例中，我们使用 std::map 存储了一些水果的名称，并按照键的顺序输出。通过调用 find() 函数，我们可以查找指定键对应的值。 希望以上回答能够解决你的问题！如有更多疑问，请继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 73
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

樊梓慕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值