【C++进阶】红黑树封装实现map和set

于 2023-03-20 21:48:04 发布
阅读量453 收藏 1
点赞数 1
分类专栏： C++初阶和高阶 文章标签： c++ 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67077469/article/details/129673946
版权

文章目录

改造红黑树

要用红黑树实现map和set的时候，我们面临一个问题。
看一下代码：
在这里插入图片描述
红黑树的节点结构我们是这么实现的，而节点里面存的数据类型是pari<K,V>对象。
根据之前学习和使用过map和set的时候我们知道，set节点里面存的数据是一个K类型，而map节点里面存的一个数据是一个pari<K,V>对象。那么我们如何让一颗树满足两个容器呢？

可以进行以下改造：

1.红黑树节点的改造

在这里插入图片描述
既然我们不知道会传的是什么类型的数据，我们就直接把模板参数的改成T，我们在外面封装实现set和map的时候显示传就可以。

2.红黑树模板参数的改造

原模板参数：
在这里插入图片描述
改造后的模板参数：
在这里插入图片描述
模板里的KeyOfT下面再讲解，这里先跳过
set：
在这里插入图片描述
map：
在这里插入图片描述

3.红黑树插入的改造

原插入的参数：
在这里插入图片描述
改造后插入的参数：
在这里插入图片描述
改造后的插入函数的返回值我们下面再讲解，这里先跳过。

改造后我们又遇到难题了，我们知道红黑树也是二叉搜索树，遵循二叉搜索树的规则，新插入节点时，要进行节点之间的比较，新节点的值比节点的值大往右走，比节点的值小往左走。但是我们传了个T过来，我们也不知道它是pair<K,V>，还是K。我们要如何比较？
这我们运用到了仿函数，底层红黑树是不知道，但是外层封装的map和set知道啊，所以我们在set和map中分别写出它们各自的仿函数，然后显示的传给红黑树.
set:
在这里插入图片描述
在这里插入图片描述
map:
在这里插入图片描述

在这里插入图片描述

改造前的插入代码：
在这里插入图片描述

改造后的插入新节点：
在这里插入图片描述
从图片的代码中我们可以看出，每当我们要进行两个节点的比较之前，我们要定义一个KeyOfT的kot对象，然后用它们的返回值进行比较。

到这里我们改造的就差不多了，其它的几乎不用怎么变，解下来最重要的就是实现红黑树的迭代器。

红黑树迭代器的实现

迭代器是C++ STL库中所有数据结构容器必须实现的一个。
它是对节点指针的封装，让所有数据结构容器可以像指针一样去实现用迭代器的++或者–来实现遍历。

迭代器的结构

在这里插入图片描述
在这里插入图片描述

迭代器的构造函数

在这里插入图片描述

operator*和operator->的实现

在这里插入图片描述

operator!=的实现

在这里插入图片描述

operator++(前置)的实现

红黑树迭代器的精华就是，它的++和–的实现。我们知道对数组我们可以使用原生指针的++、--和解引用来对数组进行遍历，但是对于红黑树我们就不能使用原生指针的++、--来对树形结构进行遍历。因为数组底层存储数据的空间是连续的，而红黑树底层存储数据的空间是不连续的。
那么我们如何让红黑树像数组一样去用指针的++、–来遍历红黑树呢？

我们知道，红黑树的中序遍历是有序的，所以我们用迭代器遍历时，就遵循中序遍历的思想。
中序遍历思想：
先访问左子树
再访问根
最后访问右子树

所以当对一个红黑树的节点指针++,如果该节点的右子树存在，那么下一个访问的就是右子树最左的节点的值。如果右子树不存在，那么说明我存在的子树已经访问完了，那么继续沿着到根节点的路径找孩子是父亲左的那个节点，下一个访问的就是这个节点的值。
在这里插入图片描述
在这里插入图片描述
整颗树都访问完了的情况：
在这里插入图片描述

首先我们传的是15这个节点的指针，我们会发现15的右子树为空。

说明15的右子树已经访问完毕，沿着根路径走找到了13，我们发现15是13的右节点。

说明13的右子树已经访问完毕，我们继续沿着根路走找到了11，我们发现13是11的右节点。

说明11的右子树已经访问完毕我们继续沿着根路走找到了8，而11又是8的右节点，我们继续沿着根路走到了空。

说明整颗树已经访问完毕。

operator++(后置)的实现

后置++的实现和前置++的实现是一样的，只不过是返回值的区别。
这里如果不理解前置++和后置++的区别，大家可以自己去理解一下。
在这里插入图片描述
后置++的返回是传值返回，因为后置++要返回的是++前的迭代器，而迭代++后指向的位置就变了，所以我们对这个迭代器提前用来一个临时迭代器来保存，我们最后返回的是这个临时迭代器，但是出了作用域这个迭代器就不存在了，所以我们不能传引用返回，只能传值返回。

operator–(前置)的实现

–的思路和++的思路是一样的。
当对一个红黑树的节点指针--,如果该节点的左子树存在，那么下一个访问的就是左子树最右的节点的值。如果左子树不存在，那么说明我存在的子树已经访问完了，那么继续沿着到根节点的路径找孩子是父亲右的那个节点，下一个访问的就是这个节点的值。
在这里插入图片描述

operator–(后置)的实现

后置–的实现和前置–的实现是一样的，只不过是返回值的区别。
这里如果不理解前置++和后置++的区别，大家可以自己去理解一下。
在这里插入图片描述
后置–的传值返回和后置++传值返回的原因一样这里就不过多赘述。

下面我们将继续讲解前面预留的一个问题，插入的返回值为什么是一个pari<iterator,bool>?
因为STL的map支持operator[],而这个运算符的作用大家应该也知道，不理解的伙伴可以看我之前写的博客。这里就不过多讲述。

在这里插入图片描述

在这里插入图片描述

这里就是为了支持[ ]可以修改kv.second，所以支持了pair对象返回.

红黑树封装实现map和set的整体代码

RBtree.h

#pragma once
namespace lzf
{
	enum Colour
	{
		RED,
		BLACK
	};
	
	
	template<class T>
	struct RBTreeNode
	{
		RBTreeNode<T>* _left;
		RBTreeNode<T>* _right;
		RBTreeNode<T>* _parent;
		T _data;

		int _col;

		RBTreeNode(const T& data)
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _data(data)
			, _col(RED)
		{}
	};
	template<class T,class Ref,class Ptr>
	struct RBTreeiIterator
	{
	private:
		typedef RBTreeNode<T> Node;
		typedef RBTreeiIterator<T, Ref, Ptr> Self;
	public:
		RBTreeiIterator(Node* it)
			:_it(it)
		{}

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

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

		bool operator!=(const Self& it)
		{
			return _it != it._it;
		}

		Self& operator++()
		{
			//....
			
			
			if (_it->_right)
			{
				Node* min = _it->_right;
				while (min && min->_left)
				{
					min = min->_left;
				}

				_it = min;
			}
			else
			{
				Node* cur = _it;
				Node* parent = cur->_parent;
				while (parent && cur == parent->_right)
				{
					cur = parent;
					parent = parent->_parent;
				}

				_it = parent;
			}
			return *this;
		}

		Self operator++(int)
		{
			//....

			Self temp(_it);
			if (_it->_right)
			{
				Node* min = _it->_right;
				while (min && min->_left)
				{
					min = min->_left;
				}

				_it = min;
			}
			else
			{
				Node* cur = _it;
				Node* parent = cur->_parent;
				while (parent && cur == parent->_right)
				{
					cur = parent;
					parent = parent->_parent;
				}

				_it = parent;
			}
			return temp;
		}

		Self& operator--()
		{
			//....
			if (_it->_left)
			{
				Node* min = _it->_left;
				while (min && min->_right)
				{
					min = min->_right;
				}

				_it = min;
			}
			else
			{
				Node* cur = _it;
				Node* parent = cur->_parent;
				while (parent && cur == parent->_left)
				{
					cur = parent;
					parent = parent->_parent;
				}

				_it = parent;
			}
			return *this;
		}

		Self operator--(int)
		{
			//....
			Self temp(_it);
			if (_it->_left)
			{
				Node* min = _it->_left;
				while (min && min->_right)
				{
					min = min->_right;
				}

				_it = min;
			}
			else
			{
				Node* cur = _it;
				Node* parent = cur->_parent;
				while (parent && cur == parent->_left)
				{
					cur = parent;
					parent = parent->_parent;
				}

				_it = parent;
			}
			return temp;
		}
	private:
		Node* _it;
	};


	//set RBTree<K,K,SetKeyOfT>
	//map RBTree<K,pair<K,V,MapKeyOfT>>
	template<class K,class T,class KeyOfT>
	class RBTree
	{
		typedef RBTreeNode<T> Node;
		
	public:
		typedef RBTreeiIterator<T, T&, T*> iterator;
		iterator begin()
		{
			Node* min = _root;
			while (min && min->_left)
			{
				min = min->_left;
			}

			return iterator(min);
		}
		iterator end()
		{
			return iterator(nullptr);
		}

		RBTree()
			:_root(nullptr)
		{}

		RBTree(const RBTree<K, T, KeyOfT>& t)
		{
			_root = Copy(t._root);
		}
		~RBTree()
		{
			Destory(_root);
			_root = nullptr;
		}
		iterator Find(const K& key)
		{
			Node* cur = _root;
			KeyOfT kot;
			while (cur)
			{
				if (kot(cur->_data) < key)
				{
					cur = cur->_right;
				}
				else if (kot(cur->_data) > key)
				{
					cur = cur->_left;
				}
				else
				{
					return iterator(cur);
				}
			}

			return end();
		}
		RBTree<K, T, KeyOfT>&  operator=(RBTree<K, T, KeyOfT> t)
		{
			swap(_root, t._root);
			return *this;
		}
		pair<iterator,bool> Insert(const T& data)
		{
			Node* parent = nullptr;
			Node* cur = _root;

			//如果根为空
			if (_root == nullptr)
			{
				_root = new Node(data);
				_root->_col = BLACK;
				return make_pair(iterator(_root),true);
			}

			KeyOfT kot;
			//寻找插入位置
			while (cur)
			{
				//如果要插入的值比cur的值小
				if (kot(cur->_data) > kot(data))
				{
					//往左找
					parent = cur;
					cur = cur->_left;
				}
				//如果要插入的值比cur的值大
				else if (kot(cur->_data) < kot(data))
				{
					//往右找
					parent = cur;
					cur = cur->_right;
				}
				//如果相等就不再插入
				else
				{
					return make_pair(iterator(cur), true);
				}
			}

			//插入
			cur = new Node(data);
			Node* node = cur;
			if (kot(parent->_data) > kot(data))
			{
				parent->_left = cur;
				cur->_parent = parent;
			}
			else
			{
				parent->_right = cur;
				cur->_parent = parent;
			}

			//更新颜色
			while (parent && parent->_col == RED)
			{
				Node* grandpa = parent->_parent;
				Node* uncle = nullptr;
				if (grandpa->_left == parent)
				{
					uncle = grandpa->_right;
					if (uncle && uncle->_col == RED)
					{
						parent->_col = BLACK;
						uncle->_col = BLACK;
						grandpa->_col = RED;

						cur = grandpa;
						parent = cur->_parent;
					}
					else
					{
						//单旋
						if (parent->_left == cur)
						{
							RotateR(grandpa);
							parent->_col = BLACK;
							grandpa->_col = RED;
						}
						//双旋
						else
						{
							RotateLR(grandpa);
							grandpa->_col = RED;
							cur->_col = BLACK;
						}
						break;
					}
				}
				else
				{
					uncle = grandpa->_left;
					if (uncle && uncle->_col == RED)
					{
						parent->_col = BLACK;
						uncle->_col = BLACK;
						grandpa->_col = RED;

						cur = grandpa;
						parent = cur->_parent;
					}
					else
					{
						//单旋
						if (parent->_right == cur)
						{
							RotateL(grandpa);
							parent->_col = BLACK;
							grandpa->_col = RED;
						}
						//双旋
						else
						{
							RotateRL(grandpa);
							cur->_col = BLACK;
							grandpa->_col = RED;
						}
						break;
					}
					
				}

			}
			_root->_col = BLACK;
			return make_pair(iterator(node), true);
		}
		
		
	private:
		void RotateR(Node* parent)
		{
			//要调整的节点
			Node* sub = parent;
			//要调整的节点的左孩子
			Node* subL = parent->_left;
			//要调整的节点的左孩子的右孩子
			Node* subLR = subL->_right;

			//要调整的节点的父母
			Node* subparent = sub->_parent;

			//重新链接关系
			if (subLR)
				subLR->_parent = sub;
			sub->_left = subLR;

			sub->_parent = subL;
			subL->_right = sub;
			subL->_parent = subparent;

			if (_root == sub)
			{
				_root = subL;
			}
			else
			{
				if (subparent->_left == sub)
				{
					subparent->_left = subL;
				}
				else
				{
					subparent->_right = subL;
				}
			}

		}
		void RotateL(Node* parent)
		{
			//要调整的节点
			Node* sub = parent;
			//要调整的节点的右孩子
			Node* subR = parent->_right;
			//要调整的节点的有孩子的左孩子
			Node* subRL = subR->_left;

			//要调整的节点的父母
			Node* subparent = sub->_parent;

			//重新链接关系
			if (subRL)
				subRL->_parent = sub;
			sub->_right = subRL;

			sub->_parent = subR;
			subR->_left = sub;

			subR->_parent = subparent;

			if (_root == sub)
			{
				_root = subR;
			}
			else
			{
				if (subparent->_left == sub)
				{
					subparent->_left = subR;
				}
				else
				{
					subparent->_right = subR;
				}
			}
		}
		void RotateRL(Node* parent)
		{
			RotateR(parent->_right);
			RotateL(parent);
		}
		void RotateLR(Node* parent)
		{
			RotateL(parent->_left);
			RotateR(parent);
			
		}
		
		void Destory(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			Destory(root->_left);
			Destory(root->_right);

			delete root;
		}
		Node* Copy(Node* root)
		{
			if (root == nullptr)
			{
				return nullptr;
			}

			Node* newnode = new Node(root->_data);
			newnode->_col = root->_col;

			newnode->_left = Copy(root->_left);
			newnode->_right = Copy(root->_right);

			if (newnode->_left)
				newnode->_left->_parent = newnode;
			if (newnode->_right)
				newnode->_right->_parent = newnode;

			return newnode;
		}
	private:
		Node* _root;
	};

	
}

Myset.h

#pragma once
#include"RBTree.h"
namespace lzf
{
	template<class K>
	class MySet
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
	public:
		typedef typename lzf::RBTree<K, K, SetKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		pair<iterator,bool> Insert(const K& data)
		{
			return _t.Insert(data);
		}
		iterator find(const K& k)
		{
			return _t.Find(k);
		}
	private:
		//set
		lzf::RBTree<K, K, SetKeyOfT> _t;
	};

	void Test_Set()
	{
		MySet<int> s;
		s.Insert(1);
		s.Insert(2);
		s.Insert(3);
		s.Insert(4);
		s.Insert(5);
		s.Insert(6);

		MySet<int>::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		MySet<int> s1(s);
		MySet<int>::iterator it1 = s1.begin();
		while (it1 != s1.end())
		{
			cout << *it1 << " ";
			++it1;
		}
		cout << endl;

		MySet<int>::iterator it2 = s1.find(5);
		cout << *it2;
	}
}

Mymap.h

#pragma once
#include"RBTree.h"
namespace lzf
{
	template<class K, class V>
	class MyMap
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
		
	public:
		typedef typename lzf::RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		pair<iterator, bool> Insert(const pair<K,V>& data)
		{
			return _t.Insert(data);
		}
		V& operator[](const K& k)
		{
			auto ret = _t.Insert(make_pair(k, V()));

			return ret.first->second;
		}
		iterator find(const K& k)
		{
			
			return _t.Find(k);
		}
	private:
		//map
		lzf::RBTree<K, pair<K,V>, MapKeyOfT> _t;
	};

	void Test_Map()
	{
		MyMap<int, int> m;
		m.Insert(make_pair(1, 1));
		m.Insert(make_pair(2, 2));
		m.Insert(make_pair(3, 3));
		m.Insert(make_pair(4, 4));

		
		MyMap<int,int>::iterator it = m.begin();
		while (it != m.end())
		{
			cout << it->first<<":"<<it->second << endl;
			++it;
		}
		cout << endl;


		MyMap<string, string> m1;
		m1["sort"];
		m1["sort"] = "排序";
		m1["left"] = "左边";
		m1["map"] = "地图";
		m1["son"] = "儿子";
		m1["map"] = "地图、映像";

		MyMap<string, string>::iterator it1 = m1.begin();
		while (it1 != m1.end())
		{
			cout << it1->first << ":" << it1->second << endl;
			++it1;
		}
		cout << endl;
		
	}
}
(unstoppable)
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用红黑树实现map和set
Radium_1209
03-18 549
用红黑树实现map和set 上一篇文章讲解了如何实现红黑树： https://blog.csdn.net/Radium_1209/article/details/104873813 这里我们用已经实现的红黑树来写一个简单的map和set。 因为map有两个参数，所以我们要先对原来的代码进行微调，将传入的参数调整为Key和Value。 还有一些地方需要微调，详见https://github.com/...
map和set的模拟实现
最新发布
06-06
这将帮助我们更好地理解和实现红黑树，从而有效地模拟出Map和Set。 总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在...
红黑树实现——STL中的map
zhongjie的专栏
11-04 7778
红黑树实现——STL中的map [ 2009-07-24 13:55:31 | 作者: dklkt ] 字号: 大 | 中 | 小 [转载]STL中map实现技术 来源：http://blog.csdn.net/Fandywang_jlu/archive/2008/03/23/2208363.aspx 红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，
数据结构中的各种树浅谈
dengdiaoji0891的博客
11-22 388
　　数据结构中为了存储和查找的方便，用各种树结构来存储文件，本章就浅谈一下各种树的表示方法、特点及各自的用途，本章设计的树结构包括：二叉查找树（二叉排序树）、平衡二叉树（AVL树）、红黑树、B-树、B+树、字典树（trie树）、后缀树、广义后缀树。 1、二叉查找树（二叉排序树） 　　（图a） 二叉查找树是一种动态查找表（图a），具有这些性质：...
map的实现--红黑树
weixin_30919235的博客
06-23 156
一、什么是红黑树？？？ 红黑树首先是一棵搜索二叉树，树中的每一个结点的颜色不是黑色就是红色。它的特性如下： 1、根节点是黑色 2、每一个结点不是黑色就是红色 3、不能有连续的两个红色结点 4、从任意一个结点出发，到后代中空指针的路径上，均包含相同数量的黑色结点。 例如： 二、为什么要有红黑树？？？ 最开始我们学习了搜索二叉树，但是最后...
用红黑树实现Map
Eriksen的博客
08-26 234
红黑树实现Map
c++容器list、vector、map、set区别与用法详解
08-19
c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 list容器 list容器是一个双向链表，链表的每个...
C++数据结构代码实现.zip
10-03
C++标准库中的`std::unordered_map`和`std::unordered_set`实现了散列表。 9. **堆**：堆是一种特殊的树形数据结构，满足最大堆或最小堆性质。在C++中，`std::priority_queue`提供了堆操作，而`<algorithm>`库中...
STL.rar_hash stl_stl 封装_搜索树
09-24
在STL中，搜索树主要通过`<set>`和`<map>`容器实现，它们基于红黑树这一自平衡二叉查找树。`<set>`用于存储唯一整数，而`<map>`则用于存储键值对，两者都支持快速的查找、插入和删除操作，其时间复杂度通常为O(log ...
红黑树实现简单map
qq_42716357的博客
07-08 322
红黑树，map，模板编程
通用红黑树（Tree-Map）容器纯C实现
08-05
纯C实现的通用红黑树容器不好找，于是自己琢磨着实现了一个。 算法部分直接剪裁自Linux内核中的rbtree 作者主要是在此基础上封装了一个通用的容器 里面含有 test例子 以及 benchmark基准测试 另外这个是Windows和Linux都可以用的 由于Linux内核的rbtree用了很多C99语法，笔者还得写了一些宏改造内核代码 Linux下的make是完整的 Windows下提供了VS08版的sln文件（只有test木有benchmark） 附带了一个C++里面的STL Map的benchmark
使用红黑树实现的map
本想找到回家的路，可谁曾想，我从未离开过
11-03 4990
<br />公司算法库中不希望包含STL,BOOST之类的库，很多基础算法都需要自己写。下边的代码是用红黑树实现的MAP模板类，测试无误，贴出来供参考。实现了插入·查找·删除等主要功能。因为没有加额外的容器，迭代器，所以速度比STL的快很多, 用20000000数据进行查找·删除·插入测试结果如下：<br /> <br />STL MAP:<br />Begin!<br /><br />Insert Data ...<br />Insert End! time:47<br />Del Test ...<br
红黑树来实现map&set
贵在坚持,我相信只要我努力,未来肯定是美好的!
05-25 124
红黑树实现map&set目录: 目录:
用红黑树模拟实现map和set
qq_57283958的博客
05-22 358
今天我们用红黑树来模拟实现map和set，我们可以参考STL源码，不用自己造轮子。 一下是STL源码中的片段，它定义节点的颜色是用const的全局变量，同样需要三个指针left,right,parent.还用了一个继承，我也不知道大佬当时是怎么想的，其实不用继承也是一样可以搞，那么我们模拟实现就不搞继承了。大佬当时可能是出于某种原因吧。 typedef bool __rb_tree_color_type; const __rb_tree_color_type __rb_tree_red = fa.
红黑树实现map、set基本功能
qq_52145272的博客
06-27 277
了解使用红黑树封装形成map、set的基本过程
红黑树模拟实现STL中的map与set
An_Mo的博客
11-25 238
红黑树的迭代器 增加迭代器分为三步： 定义一个类，封装一个指针 1、构造 2、就有指针的类似行为：operator*（）、operator->() 3、能够移动：前置++、后置++、前置–、后置– 4、能够比较 ：！=、== 在容器类中给迭代器类型取别名 在容器中增加begin()、end() #include<iostream> using namespace ...
红黑树的实现、map、set的封装
ych9527的博客
06-02 428
1.红黑树概念、性质 1.1什么是红黑树 红黑树，是一种二叉搜索树，但是在每个节点上增加了一个存储位，标识节点的颜色，可以是RED或者BLACK。通过对任何一条从根到叶子的路径上各个节点着色方式的限制，红黑树确保没有一条路径会比其它的路径长出两倍(最长路径<=2倍最短路径)，因此是接近平衡的 1.2红黑树的性质 1.每个节点不是红色就是黑色的 2.根节点是黑色的 3.没有连续的两个红色节点 4.对于每个节点，从该节点到其后代叶节点的路径上，均包含相同的黑色节点(每条路径上的黑色节点的总数是相同的) 5
C++精通之路：红黑树的应用（模拟实现map/set）
yin_ming_hui的博客
08-16 965
因为红黑树的增删查改都是O（logN）,所以用红黑树实现的map/set的增删查改也是O（logN），是个非常优秀的容器。
c++stl中红黑树的实现
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值