[数据结构]——浅谈红黑树原理与简易实现

最新推荐文章于 2024-01-27 18:48:53 发布
置顶 最新推荐文章于 2024-01-27 18:48:53 发布
阅读量1.4k 收藏 15
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 红黑树 重点难点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lucky52529/article/details/89419678
版权

红黑树

我之前的博客讲解了AVL树的性质，通过对AVL树的了解我们知道了他是一颗高度平衡的二叉搜索树，其实二叉搜索树最大的作用就是进行插入，删除，查找的操作，而AVL树查找的时间复杂度为log(n)。为了保持平衡的性质(左右子树的高度差绝对值不大于一)，AVL在进行插入数据时就要进行大量的旋转，当我们的数据量非常的大时，其实我们在进行插入调整这颗树的旋转操作也会有很大的开销，这里就出现了一颗叫红黑树的东西。

红黑树也是一颗二叉搜索树，他的节点不使用平衡因子来控制树的形状，而是采用了节点的两种颜色来控制使得树中最长路径中节点个数不会超过最短路径节点个数的两倍，这样就能保证树触发旋转的几率大大减小。但是有人会说红黑树的效率会不会变低，答案当然是会的，AVL树的查找时间复杂度为log(n)，红黑树的查找时间复杂度为nlog(n)，但是，对于计算机的运算速度是惊人每秒的运算量都是亿级的，所以在他的眼里log(n)和nlog(n)事实上没有什么区别。

正如我的老师所说，发明红黑树的人真是个奇才，他能从问题不同的角度切入，为这个世界创造了更多的可能性，值得我们每一个人学习。

红黑树的性质

首先一起来看看红黑树的性质：

  • 每个结点不是红色就是黑色（emmm…，彷佛在说废话）
  • 根节点是黑色的
  • 如果一个节点是红色的，则它的两个孩子结点是黑色的 （没有连续的红色节点）
  • 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 （到空节点的路径上黑色节点数量相同）
  • 每个叶子结点都是黑色的(此处的叶子结点指的是空结点）

只要我们可以保证上面的规则，就能保证我们前面所说的，树中最长路径中节点个数不会超过最短路径节点个数的两倍，但是这是为什么呢?

  • 最短路径：一定是纯黑色的
  • 最长路径：一定是红黑相间（这里要保证上面的第四条性质）
    在这里插入图片描述

红黑树的插入

说了这么多，其实我们这颗树就是使用红色和黑色这两种状态来控制树的形状的，但是具体的怎么控制形状，需要我们进行深入的思考。

首先根据我们的第一条性质，我们红黑树的根节点必为黑色，所以当我们这颗树是一颗空树时，直接返回颜色为黑的根节点，但是紧接着问题来了，我们之后插入节点是该插入红色的节点还是黑色的节点呢？其实我们前面提到过，如果对于新的节点插入颜色为黑的节点，此时我们就不能保证所有路径上黑节点数量相同，如果硬将其插入黑色节点，那么必须对所有路径进行调整，那么将会付出很大的代价。

所以我们在进行新插入节点时，都插入红色节点。插入后，如果父节点为黑就结束，如果父节点为红那么就要对树节点的颜色和形状进行调整。下面的讲解中不同的标识分别代表：

  • cur：新插入节点
  • parent：新插入节点的父亲
  • garndfather：新插入节点的父亲的父亲
  • uncle：新插入节点的父亲的兄弟

1.新插入节点的父亲为红，叔叔存在且颜色为红

下图中是我们遇到的第一种最简单的情况，新插入节点的父亲为红色，叔叔节点的颜色为红，我们就要进行如下操作：

  1. 将cur的parent节点和叔叔(uncle)节点调整为黑色
  2. 将grandfather节点调整为红色在这里插入图片描述

但是这里我们只讲了树结构中的一部分，如果grandfather的parent依旧是红色的节点我们就需要接着向上调整，如果grandfather的parent为空说明grandfather就是root，所以将他的颜色变为黑色并且结束。
在这里插入图片描述

2. 新插入节点父亲为红，叔叔节点不存在或存在且为黑（单旋）

下图中是我们遇到的第二种情况，新插入节点的父亲为红色，叔叔节点的颜色为黑或者不存在。

注意： 我们现在下图的遇到的这种情况一定是发生在上面我们讲的第一种情况调整之后，从图中我们可以看出，cur绝对不可能是新插入的节点，因为，如果cur是新插入节点这颗树就不满足各路径黑色节点相同的性质，所以cur之前肯定为黑色，是后来被调整为红色。
在这里插入图片描述
当我们遇到这种情况时就需要对树以grandfather为轴节点进行旋转：

  1. 让parent的右子树变为grandfather的左子树，grandfather变成parent的右子树
  2. 将parent颜色变为黑色，grandfather变为红色

在这里插入图片描述
当然了，结合情况一就会出现下面的情况：这也就清楚的解释了为什么情况二出现在情况一的基础上
在这里插入图片描述

3. 新插入节点父亲为红，叔叔节点不存在或存在且为黑（双旋）

其实第三种与第二种情况基本相同，只不过这时我们需要进行俩次旋转才能达到目的：
在这里插入图片描述

此时这种情况时就需要对树先以parent为轴节点进行左旋，然后以grandfather为轴节点进行右旋：需要注意的是，在进行第一次左旋后节点的颜色不改变，而在第二次的右旋之后需要进行将父亲和grandfather进行颜色调整。
在这里插入图片描述
所以更复杂的树就有了下面的场景：
在这里插入图片描述
以上就是我们在调整红黑树时会遇到的不同情况，旋转仅仅拿出右单旋和左右双旋来演示，左单旋和右左双旋也是相同的道理，有了上面的讲解我想大家可以独立完成另外两种旋转情况，但是光有图还不够，我们来进一步剖析插入的代码。

代码看起来虽然长，但是根据思路梳理并不难理解(每个人代码风格不同，仅供参考)

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;//记录cur节点的上一个节点
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > kv.first)//如果插入值小于当前节点值，向左树走
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)//如果插入值大于当前节点值，向右树走
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				//已经存在当前值
				return false;
			}
		}
		cur = new Node(kv);
		cur->_col = RED;//新节点插入红色节点
		if (parent->_kv.first > kv.first)//将cur插入树中
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)//如果当前插入节点的父亲节点为黑色则不需要调整
		{
			Node* grandfather = parent->_parent;//通过grandfather查看uncle节点在其的哪一侧
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)//如果叔叔为红色，对应情况1
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//如果叔叔为黑色，或者不存在
				{
					if (cur == parent->_right)//判断是否需要进行双旋，对应情况3
					{
						RotateL(parent);
						swap(cur, parent);//对照图发现，需要交换指针
					}
					RotateR(grandfather);//只单旋对应情况二
					parent->_col = BLACK;
					grandfather->_col = RED;
					break;
				}
			}
			else//相反的情况
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						RotateR(parent);
						swap(cur, parent);
					}
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
					break;
				}
			}
		}
		_root->_col = BLACK;//一定注意当情况一发生后，可能根节点是红色，每次插入后跟新成黑色
		return true;
	}

红黑树的删除

红黑树的删除有一定的难度，这里我们就不详细介绍了，其实它跟搜索树的删除很类似就是寻找一个替换节点然后删掉它的替换节点
在这里插入图片描述
删除分三个情况：

  • del的左为空.

  • del的右为空.

  • del的左右都不为空

因为这里红黑树的删除还没有搞定，这里就先不贴代码了。

红黑树的验证

红黑树的验证是个棘手的问题，但是根据我们前面的红黑树规则，可以对目标树是否是红黑树进行判断：

  1. 查看数的根节点是否为黑色
  2. 若当前节点是红色节点查看是否存在连续的红色节点
  3. 统计一条路径上的黑色节点并且作为基准，递归查看其他路径上的黑色节点是否等于基准值

这是我们用于判断构建的树是否为红黑树的代码：

bool ISRBtree()
	{
		if (_root->_col == RED)
		{
			return false;
		}
		size_t n = 0;//基准值
		size_t m = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				n++;//统计一条路径上的黑色节点个数
			}
			cur = cur->_left;
		}
		return _ISRBtree(_root, m, n);
	}

	bool _ISRBtree(Node* root, size_t m, size_t n)//递归对每一条路径上的值进行查看是否都相同
	{
		if (root == NULL)
		{
			if (m == n)
				return true;
			else
				return false;
		}

		if (root->_col == BLACK)
		{
			m++;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)//判断是否存在连续的红色节点
		{
			return false;
		}
		return _ISRBtree(root->_left, m, n) && _ISRBtree(root->_right, m, n);
	}

测试用例：

16, 3, 7, 11, 9, 26, 18, 14, 15

验证结果：
在这里插入图片描述

完整代码

这里只将构建红黑树的代码贴出来（emmm，主要是太长了），其他代码读者可以自己尝试实现。

#include<iostream>
#include<windows.h>
using namespace std;

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:
	RBTree()
		:_root(nullptr)
	{}

	~RBTree()
	{}

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;//记录cur节点的上一个节点
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > kv.first)//如果插入值小于当前节点值，向左树走
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)//如果插入值大于当前节点值，向右树走
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				//已经存在当前值
				return false;
			}
		}
		cur = new Node(kv);
		cur->_col = RED;//新节点插入红色节点
		if (parent->_kv.first > kv.first)//将cur插入树中
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)//如果当前插入节点的父亲节点为黑色则不需要调整
		{
			Node* grandfather = parent->_parent;//通过grandfather查看uncle节点在其的哪一侧
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)//如果叔叔为红色，对应情况1
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//如果叔叔为黑色，或者不存在
				{
					if (cur == parent->_right)//判断是否需要进行双旋，对应情况3
					{
						RotateL(parent);
						swap(cur, parent);//对照图发现，需要交换指针
					}
					RotateR(grandfather);//只单旋对应情况二
					parent->_col = BLACK;
					grandfather->_col = RED;
					break;
				}
			}
			else//相反的情况
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						RotateR(parent);
						swap(cur, parent);
					}
					RotateL(grandfather);
					parent->_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;
		}
		SubL->_right = parent;
		Node* pNode = parent->_parent;
		parent->_parent = SubL;
		if (parent == _root)
		{
			_root = SubL;
		}
		else
		{
			if (pNode->_left == parent)
			{
				pNode->_left = SubL;
			}
			else
			{
				pNode->_right = SubL;
			}
		}
		SubL->_parent = pNode;
	}

	void RotateL(Node* parent)//左单旋
	{
		Node* SubR = parent->_right;
		Node* SubRL = SubR->_left;
		parent->_right = SubRL;
		if (SubRL)
		{
			SubRL->_parent = parent;
		}
		SubR->_left = parent;
		Node* pNode = parent->_parent;//记录当前parent的父亲节点，以便让SubR指向当前parent的父亲节点
		parent->_parent = SubR;
		if (_root == parent)
		{
			_root = SubR;
		}
		else
		{
			if (pNode->_left == parent)
			{
				pNode->_left = SubR;
			}
			else
			{
				pNode->_right = SubR;
			}
		}
		SubR->_parent = pNode;
	}	

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}

	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_kv.first << " ";
		_Inorder(root->_right);
	}

	bool ISRBtree()
	{
		if (_root->_col == RED)
		{
			return false;
		}
		size_t n = 0;
		size_t m = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				n++;
			}
			cur = cur->_left;
		}
		return _ISRBtree(_root, m, n);
	}

	bool _ISRBtree(Node* root, size_t m, size_t n)
	{
		if (root == NULL)
		{
			if (m == n)
				return true;
			else
				return false;
		}


		if (root->_col == BLACK)
		{
			m++;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			return false;
		}
		return _ISRBtree(root->_left, m, n) && _ISRBtree(root->_right, m, n);
	}


private:
	Node* _root;
};

总结

红黑树真的是一个非常重要的数据结构，并且他的实现极其的复杂，我们是因为看到了经过很多大师的总结所以才感觉理解起来不是那么困难，红黑树重在理解他的插入节点时不同情况怎么来对树的形状和节点颜色进行调整，只要理解了总的框架，也就变得更容易的实现，这里就是我对红黑树的浅见，如果有什么问题，还请大家多多指出。

lucky52529
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【图文详解】彻底了解红黑树底层实现原理
GodTheTang的博客
10-31 4113
红黑树定义 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n是树中元素的数目。(来源百度百科) 结构特点 ...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 16万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
红黑树介绍
mz474920631的博客
05-28 4万+
红黑树一、红黑树的概念红黑树的性质红黑树节点的定义红黑树结构二、使用步骤1.引入库2.读入数据总结 一、红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数
红黑树-原理详解
架构师之路。。
01-27 1145
红黑树之原理详解 R-B Tree简介 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。 红黑树的特性: （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！] （4）如果一个节点是红色的，则它的子节点必须是黑色的。 （5）从一个节点到该节点的子孙节点的所有路径上包含相同
红黑树（Red Black Tree，RBTree）
qq_39918677的博客
09-15 8242
一、概念 红黑树是一种自平衡二叉查找树（二叉排序树）。与平衡二叉树（avl树）不同的是，红黑树是弱平衡二叉树，即它的左右子树高度差有可能大于1。 二、5大性质 每个节点要么是黑色, 要么是红色。 根节点是黑色。 每个叶节点(Nil，空值)都是黑色。 每个红色节点的两个子节点一定都是黑色。 任意一个节点到每个叶子节点的路径都包含相同数量的黑节点。 三、推论（或规律） 左子树和右子树的黑节点的层数是相等的。因此我们称红黑树的这种平衡为黑色完美平衡。（由性质5推出） 如果一个节点存在黑子节点，那么该节点肯定
红黑树原理简单解析
黄沙客栈
08-19 9745
一、红黑树为什么会出现呢？ 是因为二叉搜索树有可能会出现极端的情况，就是只有一侧有数据，那这样的话就会降级为链表。后来出现了平衡二叉树，但是由于强制平衡所导致付出的代价比较高昂，所以黑红树出现了。 二、简介 红黑树（Red Black Tree） 的实现是基于二叉查找树的，对于含有n个节点的二叉查找树的最坏的情况是这n个节点形成一条单链，此时二叉查找树的高度为n，时间复杂度为O(n)。为了维持O(lg n)的运行时间，就需要采取一些措施在不影响二叉查找树的性质下改变二叉查找树的结构，使之平衡。红黑树就是这样
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
红黑树-基于Java实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于Java实现的红黑树数据结构
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C语言实现的红黑树数据结构
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C++实现的红黑树数据结构
数据结构 红黑树的详解
01-20
数据结构 红黑树的详解 红黑树是具有下列着色性质的二叉查找树： 1.每一个节点或者着红色，或者着黑色。 2.根是黑色的。 3.如果一个节点是红色的，那么它的子节点必须是黑色。 4.从一个节点到一个NULL指针的每一条...
数据结构-红黑树.zip
最新发布
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
红黑树基本原理和简单实现
qq_59535638的博客
06-01 323
红黑树的基本性质，插入情况的详细分析与简单实现
红黑树的原理及实现
菊头蝙蝠的博客
03-26 3272
红黑树一、 一、
数据结构（高阶）—— 红黑树
M的博客
11-26 2793
红黑树，是一种二叉搜索树，但在每个结点上增加了一个存储位表示结点的颜色，可以使Red或Black。通过对任何一条从根到叶子的路劲上各个结点着色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而近似平衡的。对于每个结点，从该结点到其所有后代叶子结点的简单路径上，均包含相同数目的黑色结点。如果一个结点是红色的，则它的两个孩子结点是黑色的。每条路径上的黑色结点数量相同。每个结点不是红色就是黑色。此处的叶子结点指定是空结点。
五分钟搞懂什么是红黑树（全程图解）
weixin_41549033的博客
08-15 4677
前言：本文转载自点击这里阅读原文 另外：本文最好拿笔+草稿纸一边看一边按照规则进行演变，本文的过程可能和你演变的不一样，没关系，看懂思想，然后根据答案去反推，去思考，我相信你会有所收获的 什么是红黑树？ 红黑树就是一种平衡二叉树，说它平衡的意思是它不会出现左子树与右子树的高度之差不会大于1，左子树和右子树保持一种平衡的关系。 红黑树主要有以下5种特性： 节点要么是红色要么是黑色 根节点必须是黑色...
红黑树简介
weixin_54156274的博客
11-28 1382
一、什么是红黑树 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性
快速理解红黑树原理
jjc120074203的博客
01-31 2万+
红黑树 红黑树 其实就是一个二叉树。 常用的二叉树类型 简单说二叉树概念： 二叉树 又称度为至多二的树。 平衡二叉树 平衡二叉树又称 AVL 树 特点：一个根节点的左右个子树的高度差不超过1 平衡二叉树 非平衡二叉树 高度差已经大于1 了。 平衡树解决的问题就是 能够最大限度的增加访问的每个节点的的平均性 。保证每个节点被访问的次数平衡。 完全二叉树
红黑树的特点，哪些数据结构使用了红黑树
10-25
红黑树的特点使得它具有良好的平衡性和搜索性能，因此被广泛应用于数据结构中。在C++ STL中，很多部分（目前包括set、multiset、map、multimap）应用了红黑树的变体，SGI STL中的红黑树有一些变化，这些修改提供了更...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值