STL学习---＞用一棵红黑树同时封装set和map

最新推荐文章于 2023-06-03 15:47:36 发布
最新推荐文章于 2023-06-03 15:47:36 发布
阅读量811 收藏 3
点赞数 10
文章标签： c++ 学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56628506/article/details/127144250
版权

文章目录

改造先前的红黑树

前面我们模拟实现了红黑树。而前面我们知道红黑树的就是STL容器里面的set和map容器的底层数据结构。 但是有一个很致命的问题：set容器是K的结构，map是K,V的结构
但是我们先前写好的红黑树的节点数据是一个pair类型！这样一来，map是可以直接使用了。但是set不能使用了，难道我们要实现两颗红黑树吗？
我们不妨来看一看源代码里面是怎么处理的。

参考SGI版本的STL源码

首先我们来看STL里面的红黑树的定义：

//红黑树定义在stl_tree.h
//树的节点的定义，这里用了一个泛型参数
template <class Value>
struct __rb_tree_node 
{
  typedef __rb_tree_node<Value>* link_type;
  Value value_field;
};
//再来看看红黑树的定义(简化了)
template <class Key, class Value, class KeyOfValue>
class rb_tree {
protected:;
  typedef __rb_tree_node<Value> rb_tree_node;

可以看到，库里的红黑树并不是把数据类型写死成pair，而是把把数据声明成了一个泛型！也就意味着，下层红黑树并不决定真正存储节点的类型，而是由上层决定。

模拟实现set容器

接下来，我们就来模拟实现set容器，首先我们知道set容器是key模型，但是它是怎么做到和map共用一棵红黑树的呢?同样我们来看看源代码。

参考set的源码

经过简化后，我们能够看到set实现key模型代码的关键所在

template <class Key>
class set {
public:
  // typedefs:

  typedef Key key_type;
  typedef Key value_type;
private:
  typedef rb_tree<Key, Key, identity<value_type>> rep_type;
 rep_type t;  // red-black tree representing set

从模板的定义我们不难可以看到，set就是把key同时作为参数传递给下一层的红黑树。那么这里的第三个参数又是什么意思呢?
首先，回想一下。我们这里的数据是泛型，那么意味着我们传递的数据可能是任意类型:string,int,double甚至可能是Teacher等等的不明确的类型！而底层的红黑树需要根据数据进行有序插入。
而转换数据就是一个重要的事情：identity<value_type>完成的就是这个任务

模拟实现set

接下来我们就来根据库里的代码迅速搭一个框架出来：

namespace chy{

  template<typename K>
	struct KeyofSet
	{
		const K operator()(const K key)
		{
			return key;
		}
	};
	//set的容器的结构
	template<typename K>
	class set
	{
	public:
	//插入算法->调用_tree的insert
      bool insert(const K& key)
	  {  
	     return _tree.insert(key);
      }
	private:
		RBTree<K,K,KeyofSet<K>> _tree;
	};
}

这就是set容器的整个大框架。而set的迭代器我们将会在实现了红黑树的迭代器以后再封装出来。map也是如此。

模拟实现map容器

前面我们实现了set容器，下面我们就来实现一下map容器，和set一样，我们先来看看库里面的map的定义。

参考map的源代码

经过简化以后，map的整个大框架如下

template <class Key, class Val>
class map {
public:

// typedefs:
  typedef Key key_type;
  typedef Val data_type;
  typedef Val mapped_type;
  typedef pair<const Key, Val> value_type;
private:
//map的红黑树结构
  typedef rb_tree<Key,pair<const Key, Val> , select1st<value_type>> rep_type;
  rep_type t;  // red-black tree representing map

不难可以看出，map的第二个参数就是一个pair,因此就实现了set和map复用一棵红黑树。不得不佩服前辈们的智慧。

模拟实现map

接下来我们也来封装一下map容器

namespace chy{
//实现转换的仿函数
template<typename K,typename V>
	struct KeyofMap
	{
		const K operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
 template<typename K,typename V>
 class map
 {	 
 public:
    bool insert(const K& key)
    {
        return _tree.insert(key);
   }
 private:
	 RBTree<K, pair<K, V>, KeyofMap<K,V>> _tree;
 };

}

到这里，set和map容器的简单雏形就出来了。但是我们还有迭代器和map的operator[]还没有实现，而这些都基于底层结构红黑树。下面我们就来给红黑树添加迭代器。

为红黑树封装迭代器

和实现list的迭代器类似，红黑树的迭代器也是一个自定义类型，大致的结构如下:

template<typename T, typename Ref, typename Ptr>
struct RBTreeIterator
{
  typedef RBTreeNode<T> Node;
  //给迭代器重命名，否则太长了
  typedef RBTreeNode<T,Ref,Ptr> Self;
  //封装节点的指针
  Node* _node;
  explicit RBTreeNode(Node* node)
  		:_node(node)
  		{}
 //重载*
 Ref operator*() 
 {
   return _node->_val;
 }
 //重载->()
 Ptr operator->()
 {
    return &_node->_val;
 }
 bool operator==(const Self& s) const
{
			return _node == s._node;
}
		bool operator!=(const Self& s) const
{
			return _node != s._node;
}
//实现++和--才是这里的重头戏！
Self& operator++()
{	//如何实现++
	return *this;
}
Self& operator++(int)
{
	Self tmp(*this);
	++(*this);
	return tmp;
}
Self& operator--()
{
//--如何实现
return *this;
}
Self& operator--(int)
{
			Self tmp(*this);
			--(*this);
			return tmp;
}
 		
};

由于底层的结构是树型结构，所以相对而言++和–是比较繁琐的一个步骤，接下来我们通过图片来分析++应该如何实现。
在这里插入图片描述
所以基于上面的分析，我们就可以写出如下的代码

Self& operator++()
		{ 
		  //右子树非空，++寻找右子树的最左节点
			if (_node->_right)
			{
				Node* minRight = _node->_right;
				while (minRight && minRight->_left)
				{
					minRight = minRight->_left;
				}
				_node = minRight;
			}
			//右子树为空，向上回溯到it的祖先节点是it祖先左孩子的祖先节点
			else
			{
				Node* cur = _node;
				Node* parent = cur->_parent;
				while (parent && cur == parent->_right)
				{
					cur = parent;
					parent = parent->_parent;
				}
				_node = parent;
			}
			return *this;
		}

而对于–的操作就是和++对称的，这里直接给出代码

Self& operator--()
		{
//如果左孩子非空，找左孩子的最右节点
			if (_node->_left)
			{
				Node* maxLeft = _node->_left;
				while (maxLeft && maxLeft->_right)
				{
					maxLeft = maxLeft->_right;
				}
				_node = maxLeft;
			}
//左子树为空，那么需要向上回溯到it祖先节点是it祖先节点的右孩子的那个祖先节点			
			else
			{
				Node* cur = _node;
				Node* parent = cur->_parent;
				while (parent && parent->_left == cur)
				{
					cur = parent;
					parent = parent->_parent;
				}
				_node = parent;
			}
			return *this;
		}

顺带提供后置的版本

//这里的int是给编译器传的，以便于识别调用对应的版本
Self& operator++(int)
{
			Self tmp(*this);
			++(*this);
			return tmp;
}
Self& operator--(int)
{
			Self tmp(*this);
			--(*this);
			return tmp;
}

接下来我们在来给红黑树添加start()和finish() （为了不和后面set和map的begin()和end()起冲突，所以这里用这两个命名）

class RBTree
	{
		typedef RBTreeNode<T> Node;
	public:
	//套迭代器
		typedef RBTreeIterator<T, T&, T*> iterator;
		typedef RBTreeIterator<T, const T&, const T*> const_iterator;
		RBTree()
			:_root(nullptr)
		{}
		//start是整棵树里面最小的节点
		iterator start()
		{
			Node* minLeft = _root;
			while (minLeft && minLeft->_left)
			{
				minLeft = minLeft->_left;
			}
			return iterator(minLeft);
		}
		iterator finish()
		{
			return iterator(nullptr);
		}
		const_iterator start() const
		{
			Node* minLeft = _root;
			while (minLeft && minLeft->_left)
			{
				minLeft = minLeft->_left;
			}
			return const_iterator(minLeft);
		}
		const_iterator finish() const
		{
			return const_iterator(nullptr);
		}

到这里，红黑树的迭代器基本已经封装完成了。接下来我们封装set和map的迭代器

//封装set
namespace chy {
	template<typename K>
	struct KeyofSet
	{
		const K operator()(const K key)
		{
			return key;
		}
	};
	template<typename K>
	class set
	{
	public:
/*这里使用typename修饰，是因为编译器按需实例化的时候，可能内嵌的类型没有实例化，找出来也可能是虚拟类型，使用typename修饰告诉编译器等待内嵌类型实例化以后再进去寻找
*/	
		typedef typename RBTree<K, K,  KeyofSet<K>>::const_iterator iterator;
		typedef typename RBTree<K, K,  KeyofSet<K>>::const_iterator const_iterator;
		iterator begin() const
		{
			return _tree.start();
		}
		iterator end() const
		{
			return _tree.finish();
		}
private:
	RBTree<K, K, KeyofSet<K>> _tree;

map的封装如下:

namespace chy
{ 
	template<typename K,typename V>
	struct KeyofMap
	{
		const K operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
 template<typename K,typename V>
 class map
 {

	 
 public:
	 typedef typename RBTree<K, pair<K, V>, KeyofMap<K,V>>::iterator iterator;
	 typedef typename RBTree<K, pair<K, V>, KeyofMap<K,V>>::const_iterator const_iterator;
	 iterator begin()
	 {
		 return _tree.start();
	 }
	 iterator end()
	 {
		 return _tree.finish();
	 }
	 const_iterator begin() const 
	 {
		 return _tree.start();
	 }
	 const_iterator end() const 
	 {
		 return _tree.finish();
	 }
private:
	  RBTree<K, pair<K, V>, KeyofMap<K,V>> _tree;

但是我们目前的map仍然有不足的地方，我们还没有实现对应的opreator[]，而由于operator[]底层调用的是insert,所以我们还需要修改insert。

实现map的operator[]

为了实现operator[]，我们需要对应修改insert的代码：

pair<iterator,bool> insert(const T& val)
		{
			if (!_root)
			{
				_root = new Node(val);
				_root->_col = BLACK;
				return make_pair(iterator(_root),true);
			}
			Node* parent = nullptr;
			Node* cur = _root;
			//使用仿函数转换数据对象
			KeyOfT kot;
			while (cur)
			{   //左子树
				if (kot(cur->_val) > kot(val))
				{
					parent = cur;
					cur = cur->_left;
				}
				//右子树
				else if (kot(cur->_val) < kot(val))
				{
					parent = cur;
					cur = cur->_right;
				}
				//停止重复插入
				else
				{
					return make_pair(iterator(cur),false);
				}
			}
			//插入节点默认是红色
			cur = new Node(val);
			//因为旋转会变化，所以提前记录
			Node* newnode = cur;
			if (kot(parent->_val) > kot(val))
				parent->_left = cur;
			else
				parent->_right = cur;
			cur->_col = RED;
			cur->_parent = parent;
			//如果父亲存在且为红色，违反规则三，需要处理
			while (parent && parent->_col == RED)
			{
				Node* grandfather = parent->_parent;
				if (parent == grandfather->_left)
				{
					Node* uncle = grandfather->_right;
					//情况1：叔叔存在且为红色
					//处理方式：叔叔和父亲变黑，祖父变红，继续向上调整
					if (uncle && uncle->_col == RED)
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						cur = grandfather;
						parent = cur->_parent;
					}
					//叔叔不存在||叔叔存在且是黑色
					else
					{
						//如果父亲是祖父的左且cur也是父亲的左要右单旋
						if (cur == parent->_left)
						{
							RotateR(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
						}
						//如果cur是父亲的右，就要双旋
						/*   g
						*   p
						*    c
						*/
						else
						{
							RotateL(parent);
							RotateR(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
						}
						break;
					}
				}
				//父亲是祖父的右
				else
				{
					Node* uncle = grandfather->_left;
					//情况1：叔叔存在且为红色
					//处理方式：叔叔和父亲变黑，祖父变红，继续向上调整
					if (uncle && uncle->_col == RED)
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						cur = grandfather;
						parent = cur->_parent;
					}
					//叔叔不存在||叔叔存在且是黑色
					else
					{

						//如果父亲是祖父的右且cur也是祖父的右要左单旋转
						if (cur == parent->_right)
						{
							RotateL(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
						}
						else
						{
							RotateR(parent);
							RotateL(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
						}
						break;
					}
				}
			}
			//根节点要保持黑色
			_root->_col = BLACK;
			return make_pair(iterator(newnode),true);
		}

改造set和map的insert

air<iterator,bool> insert(const K& key)
		{
			pair<typename RBTree<K, K, KeyofSet<K>>::iterator, bool> ret = _tree.insert(key);
			return pair<iterator,bool>(iterator(ret.first._node), ret.second);
		}
pair<iterator,bool> insert(const pair<K,V>& kv)
	 {
		 return _tree.insert(kv);
	 }

最后就是封装operator[]

//不存在就插入，存在就返回对应的V的引用
	 V& operator[](const K& key)
	 {
		 pair<iterator, bool> ret = _tree.insert(make_pair(key, V()));
		 return ret.first->second;
	 }

以上就是整篇文章的内容。模拟实现这两个容器是为了更好体会容器的底层结构。而不是造更好的轮子，对底层结构有更深的理解，才能更好使用容器。 如有不足之处还望指出。希望大家共同进步。

__cplusplus
关注
  • 10
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
底层实现红黑树_C++ map，set底层的红黑树实现
weixin_32569511的博客
02-05 1133
1. 为什么用红黑树实现？map, set底层都提供了排序功能，红黑树形式存储的键值是有序的。同时红黑树可以在O(log n)时间内做插入，查找和删除。2. 红黑树的性质红黑树是每个节点都带有颜色属性的二叉搜索树，颜色要么是红色，要么是黑色。性质1：红黑树的每个节点要么是红色，要么是黑色。性质2：红黑树的根节点一定是黑色的。性质3：红黑树的所有外部节点都是黑色的。(外部节点是扩充二叉树中对所有空指...
STL详解（十一）—— 用一棵红黑树同时封装出map和set
2021dragon的博客
12-11 3983
文章目录 用一棵红黑树同时封装出map和set
用一棵红黑树同时封装出set和map
weixin_45599288的博客
01-21 1318
一棵红黑树同时封装set和map红黑树代码红黑树的模板参数红黑树结点的数据存储仿函数的增加正向迭代器的实现operator++operator--封装后的set和mapset的代码map的代码测试set和map的迭代器 ????快速导航和本篇相关的文章???? set和map的基本使用 点击直达文章 红黑树 点击直达文章 红黑树代码 我们要对KV模型的红黑树进行封装，模拟实现set和map,用到的代码如下 #include<iostream> using namespace
C++_用红黑树实现关联容器map和set
hello呀！
08-21 317
template <class K,class V> class Map { private: struct MapKeyOfValue { const K& operator()(const pair<K, V>& data) { return data.first; } }; public: typedef typename ...
红黑树封装实现树形结构的关联式容器（map，set）
qq_50408340的博客
06-13 184
目录红黑树的改造节点问题插入问题迭代器红黑树的迭代器改造红黑树map简单模拟set简单模拟 红黑树的改造 节点问题 map和set不同，map存放的是pair<K,V>键值对，而set中只有Key，我们要对红黑树节点进行改造，是她既能存放键值对，又能存放K值。 改造的节点结构体如下 template<class T> struct tree { tree<T> *left; tree<T> *right; tree<T> *parent;
Effective_STL.rar_Effective-STL_effective STL
09-24
set和map是基于红黑树的关联容器，用于存储唯一元素，并提供按特定顺序访问的能力。 3. **迭代器**：迭代器是STL的关键概念，它像指针一样遍历容器中的元素，但具有更丰富的操作和更强的类型安全。迭代器有不同种类...
boost-STL.rar_Boost_STL_boost学习资料
09-24
- `set`和`map`：基于红黑树实现的关联容器，用于存储唯一元素，按键值排序。 2. 迭代器（Iterators）：类似于指针，用于遍历容器中的元素，支持不同的迭代方式。 3. 配适器（Adaptors）：如stack和queue，分别...
STL.rar_hash stl_stl 封装_搜索树
09-24
在STL中，搜索树主要通过`<set>`和`<map>`容器实现，它们基于红黑树这一自平衡二叉查找树。`<set>`用于存储唯一整数，而`<map>`则用于存储键值对，两者都支持快速的查找、插入和删除操作，其时间复杂度通常为O(log ...
sgi-stl-docs：来自SGI的标准模板库（STL）文档。 （镜子）
02-05
通过阅读和学习SGI-STL-Docs，C++程序员能够更好地理解和利用STL的强大功能，编写出更高效、更易维护的代码。同时，文档中的示例代码和解释有助于解决实际编程中遇到的问题，提升问题解决能力。无论是初学者还是经验...
STL--源码剖析完整版.zip
04-09
而`set`和`map`是基于红黑树的数据结构，用于保持元素的排序并支持快速查找。 2. 迭代器： 迭代器是STL的核心概念之一，它类似于指针，但提供了更多功能。迭代器可以遍历容器中的元素，有输入迭代器、输出迭代器、...
使用红黑树封装map和set
qq_47406941的博客
06-07 772
红黑树和AVL树都是二叉搜索树，但是从效率以及实现方式等方面综合来看，红黑树比AVL树更优。也就是说，红黑树是一种更好的，适合搜索的数据结构。同时，红黑树的使用方面非常广泛，Java库、linux内核、c++ST ...
13 set和map以及用红黑树模拟实现set和map
精致的灰的博客
01-13 653
文章目录序列容器和关联式容器树形结构与哈希结构setset的成员函数构造方法set当中常用的成员函数multisetmapmap的成员函数构造方法map的插入insertmap的查找findmap的删除erasemap的[ ]运算符重载map的其他成员函数统计出现次数的三种方式对统计的次数进行排序multimap用红黑树模拟实现map和set参数的控制使用仿函数比较参数大小迭代器的实现 序列容器和关联式容器 C++STL中的部分容器，比如：vector、list、deque、forward_list(C+
红黑树实现map、set基本功能
qq_52145272的博客
06-27 269
了解使用红黑树封装形成map、set的基本过程
C++红黑树模拟实现map和set
轻松学C语言
08-20 167
点击蓝字关注我们一、红黑树及其节点的设计对于底层都是红黑树的map和set来说，他们之间存在的最大的区别就是：对于set是K模型的容器，而map是KV模型的容器。为了更好的灵活兼容实现map和set，就需要在红黑树以及树节点上进行特别的设计1、树节点的设计对于红黑树的节点我们需要节点对于set来说储存key，对于map来说储存key-value键值对，所以这里我们就直接让节点类型的阈值类型为T，用...
底层以红黑树实现的map和set
TheBao0107的博客
06-03 441
set是Key模型，1.set中（为了和map对应），也存的是pair键值对，只不过key和value的值相等，并且每个value必须是唯一的。sre中的元素不能在容器中修改（每个元素都是const），但是可以删除或者插入元素。2.在内部，set中的元素总是按照其内部比较对象（仿函数）所指示的特点比较准则进行排序的。3.set容器通过key访问单个元素的速度常常比unordered_set容器慢（哈希），但支持迭代器访问。4.set在底层是使用红黑树实现的。注意。
STL—— 用一棵红黑树同时封装出map和set
裙下的霸气的博客
01-27 545
STL——红黑树封装....
c++ 红黑树实现 map和set的底层原理
Hedenghui777的博客
10-24 1286
文章目录前言一、红黑树是什么？二、红黑树的特性1.根节点是黑色的2.叶子节点(null)是黑色的3.每个结点不是黑色就是红色4.一个结点是红色的，他的两个子节点一定是黑色的5.对于每个结点，从该节点到所有后代叶节点的简单路径上，均包含相同数目的黑节点三、红黑树的实现四、map底层的实现代码测试五、set底层的实现代码测试总结 前言 上一个博客总结了AVL树，链接: AVL树实现. 但是当需要大量增删的时候，AVL树旋转次数太多，效率并不高。所以我们引入了红黑树，红黑树不是绝对的平衡二叉树，但实现起来简单.
红黑树同时封装实现 map 和 set——红黑树の华丽二重奏
qq_61500888的博客
09-08 2165
带你一命通关 map ，set 底层原理 咋舌细品红黑树魅力，二十分钟手撕数据结构
【C++】红黑树封装实现map和set
The porters of knowledge
04-01 1002
用一棵红黑树封装map和set，set表层迭代器底层均为红黑树的const迭代器，实现map的[ ]重载……
c++stl中红黑树的实现
最新发布
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码略有不同。STL中的红黑树使用节点颜色（红色或黑色）和节点指针（parent、left、right）来表示树的结构，而你提供的代码使用了模板和节点对象来实现。 在STL中，红黑树的插入和删除操作已经被封装在`std::map`和`std::set`中，使用起来非常简单。你只需要包含相应的头文件`<map>`或`<set>`，并使用`std::map`或`std::set`类来定义变量，就可以直接使用红黑树的功能了。 以下是使用STL中红黑树的简单示例： ```cpp #include <map> int main() { std::map<int, std::string> myMap; // 插入元素 myMap.insert(std::make_pair(1, "one")); myMap = "two"; // 查找元素 auto it = myMap.find(1); if (it != myMap.end()) { std::cout << it->second << std::endl; // 输出 "one" } // 删除元素 myMap.erase(2); return 0; } ``` 在上面的示例中，我们使用`std::map`来创建一个键-值对的红黑树。我们使用`insert`函数插入元素，使用`find`函数查找元素，使用`erase`函数删除元素。 总结一下，C++ STL中的红黑树实现被封装在`std::map`和`std::set`中，使用起来非常方便。你可以直接包含相应的头文件，并使用这些类来实现红黑树的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值