模拟实现STL中的map和set

已于 2024-08-26 13:23:32 修改
阅读量698 收藏 32
点赞数 23
分类专栏： C++ 文章标签： c++ 算法
于 2024-08-26 13:22:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D5486789_/article/details/141558650
版权

1.map设计图

2.set设计图

map和set其实都是将 红黑树 和 迭代器 进行了封装，所以，想要实现map和set只需要实现红黑树和迭代器，让后将其组合封装，对外提供统一的接口即可。

3.迭代器的设计

map和set的迭代器是封装了红黑树的迭代器，所以我们只需实现红黑树的迭代器即可；map和set的迭代器底层封装的是结点的指针。所以我们在RBTreeIterator中，主要封装一些操作结点的指针的接口。

判断迭代器相等or不相等：

迭代器封装的是红黑树的结点的指针，判断想不相等，只需要判断结点的指针是否相等。

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

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

迭代器的++操作：

红黑树中的遍历是按照二叉树的中序遍历来走的，迭代器的++操作也是一样的，那么迭代器++之后应该到达哪一个位置呢？

按照中序遍历的规则，左子树->根->右子树，访问完根之后，++应该去右子树中，那应该是右子树的哪个结点呢？按照二叉搜索树的规则，应该是与根结点的差值最小的那一个，不就是右子树的最左结点吗？

上面讨论的是右子树存在的情况，如果右子树不存在呢？右子树不存在，也就是右子树为空的情况，意味着这个节点的子树中序访问完了，下一个节点找祖先里面，孩子是父亲左的那个祖先。

代码如下：

    Self& operator++()
	{
		if (_node->_right)
		{
			// 右子树的中序第一个(最左节点)
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}

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

			_node = parent;
		}

		return *this;
	}

重载operator->:

迭代器的->操作主要是用来操作结点中的数据的，操作结点中的数据，需要数据的指针，所以，返回数据的地址即可。

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

重载operator*：

迭代器的 * 操作主要是用来获取数据的，所以我们只需要返回结点中的数据即可。

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

迭代器完整代码如下：

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

	Node* _node;

	RBTreeIterator(Node* node)
		:_node(node)
	{}

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

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

	Self& operator++()
	{
		if (_node->_right)
		{
			// 右子树的中序第一个(最左节点)
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}

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

			_node = parent;
		}

		return *this;
	}

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

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

3.红黑树的设计

在使用STL中的map时，我们希望它存储的是一个个的键值对数据，所以我们通常指定两个类型，比如：map<int,int>；而在使用set时，我们希望它里面存储的是一个个的元素，所以我们通常指定一个类型，比如：set<int>；但是map和set的底层数据结构都是红黑树，那是不是意味着要实现两份红黑树，一份Key结构的，一份Key-Value结构的？如果这样实现的话，就会造成STL库中代码重复和冗余，前辈大佬们绝不允许这种事情发生。

大佬们想出了下面这种做法：

将底层的红黑树实现成Key-Value结构的，使用set的时候传入Key类型，用Key类型定义出key_type和value_type；使用map的时候传入Key类型和T类型，用Key类型定义出key_type，用Key类型和T类型定义出value_type。二者都将key_type传给红黑树的Key类型，将value_type传给红黑树的Value类型，到了红黑树定义结点的时候，只关注自己的Value类型；这时，如果使用的是set，结点中的数据就是一个个k类型的数据，如果使用的是map，结点中的数据就是<k,v>类型的键值对。通过这种方式，就实现了set和map复用同一个类模板的红黑树。

红黑树的设计推荐阅读如何实现一棵红黑树，这篇文章中的红黑树是纯粹的红黑树，和用于实现map和set的红黑树有点不同：1.用于实现map和set的红黑树中还需要提供操作迭代器的接口。2.获取map和set中的Key值。

迭代器操作

迭代器的begin操作：begin() 用于返回红黑树走中序遍历的第一个结点的迭代器。也就是红黑树中最左节点的迭代器，代码如下所示：

    iterator begin()
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}

		return iterator(subLeft);
	}

迭代器的end()操作：end() 用来返回红黑树走中序遍历的最后一个节点的下一个位置，其实就是空。代码如下所示：

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

获取map和set中的Key值

在红黑树的操作中，我们经常要比较两个值的大小，map中存储的是键值对，我们希望比较的时候按照Key值来比较，set中存储的是单个元素，我们也希望按照Key值来比较，但是存储键值对的map和存储单个元素的set都是封装了同一棵红黑树，所以我们获取map和set中Key的方式不同，所以我们可以提供第三个模板参数，用来获取map和set中的Key；这个模板参数以仿函数的形式实现，以缺省参数的形式提供给类模板红黑树使用。

获取map中的Key代码如下：

struct MapKeyOfT
{
	const K& operator()(const pair<K, V>& kv)
	{
		return kv.first;
	}
};

获取set中的Key代码如下：

struct SetKeyOfT
{
	const K& operator()(const K& key)
	{
		return key;
	}
};

4.附录 —— 各部分完整代码

迭代器和红黑树代码：

#include<vector>

enum Colour
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Colour _col;
	T _data;

	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

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

	Node* _node;

	RBTreeIterator(Node* node)
		:_node(node)
	{}

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

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

	Self& operator++()
	{
		if (_node->_right)
		{
			// 右子树的中序第一个(最左节点)
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}

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

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		// 跟++逻辑相反
		return *this;
	}

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

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

// KeyOfT仿函数 取出T对象中的key
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T, T*, T&> iterator;
	typedef RBTreeIterator<T, const T*, const T&> const_iterator;

	const_iterator begin() const
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}

		return const_iterator(subLeft);
	}

	iterator begin()
	{
		Node* subLeft = _root;
		while (subLeft && subLeft->_left)
		{
			subLeft = subLeft->_left;
		}

		return iterator(subLeft);
	}

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

	const_iterator end() const
	{
		return const_iterator(nullptr);
	}

	iterator Find(const K& key)
	{
		KeyOfT kot;
		Node* cur = _root;
		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();
	}

	pair<iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);
		}

		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(iterator(cur), false);
			}
		}

		cur = new Node(data); // 红色的
		Node* newnode = cur;

		if (kot(parent->_data) < kot(data))
		{
			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)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						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
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					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);
	}

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

private:
	Node* _root = nullptr;
};

my_set代码：

#include"RBTree.h"

namespace wall
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, const K, SetKeyOfT>::iterator iterator;
		typedef typename RBTree<K, const K, SetKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}

		iterator find(const K& key)
		{
			return _t.Find(key);
		}

	private:
		RBTree<K, const K, SetKeyOfT> _t;
	};
}

my_map代码：

#include"RBTree.h"

namespace wall
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RBTree<K, const K, MapKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		const_iterator begin() const
		{
			return _t.begin();
		}

		const_iterator end() const
		{
			return _t.end();
		}

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}

		iterator find(const K& key)
		{
			return _t.Find(key);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}

	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};	
}
手捧向日葵的花语
关注
专栏目录
C++之STLmap和set的模拟实现
小赵小赵福星高照的博客
03-21 1062
模拟实现map和set 文章目录模拟实现map和set源码中红黑树的结构模板参数中的仿函数红黑树的迭代器的模拟实现迭代器的基本结构红黑树的迭代器的整体代码map的模拟实现set的模拟实现 我们首先来看一下源码当中的set和map的结构： template <class Key,class Compare = less<Key>, class Alloc = alloc> class set { public: typedef Key key_type; typedef
C++STL之map、set的使用和模拟实现
溟洵的博客
01-29 1501
本章主要讲了map、set是如何使用的，以及map、set如何底层实现相较于前面的章节本章更加考验你的逻辑能力来进行封装，还能帮助对大体框架的有更加好的了解。
【C++】STL —— map和set的模拟实现
M的博客
11-29 859
【C++】STL —— map和set的模拟实现。
STL容器 —— map和set的模拟实现
lyzzs222的博客
10-18 433
用红黑树 实现 map和set 是不是有点小 cool。对红黑树进一步完善，关键是迭代器的实现，以及拷贝构造，赋值重载，析构的实现。
STL——map和set模拟实现
smx_dd的博客
01-26 382
map和set的底层是使用红黑树来实现的，接下来我利用红黑树来模拟实现一下map和set。 map详解博客链接：https://blog.csdn.net/smx_dd/article/details/86531881 set详解博客链接：https://blog.csdn.net/smx_dd/article/details/86555973 红黑树详解与实现博客链接：https://blog....
C++进阶--红黑树模拟实现STL中的map和set
sushang的博客
01-15 1278
因此，上层容器map需要向底层红黑树提供一个仿函数，用于获取T当中的键值Key，这样一来，当底层红黑树当中需要比较两个结点的键值时，就可以通过这个仿函数来获取T当中的键值了。但是对于底层红黑树来说，它并不知道上层容器是map还是set，因此需要进行两个结点键值的比较时，底层红黑树都会通过传入的仿函数来获取键值Key，进而进行两个结点键值的比较。这样一来，当底层红黑树需要进行两个结点之间的键值的比较时，都会通过传入的仿函数来获取相应结点的键值，然后再进行比较。
模拟实现STL中的unordered_map和unordered_set
知其然 知其所以然
08-26 1024
模拟实现小型的unordered_set和unordered_map！
【C++】STL之map和set的模拟实现
xiaomage1213888的博客
06-10 375
红黑树改造 map set模拟实现
C++: 使用红黑树模拟实现STL中的map和set
酷酷学!!!的博客
09-20 1239
模拟实现map和set细节和代码
map和set的模拟实现
06-06
这将帮助我们更好地理解和实现红黑树，从而有效地模拟出Map和Set。 总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在...
红黑树模拟实现STL中的map与set（附详细代码）
zhao_leilei的博客
01-26 722
文章目录1.红黑树的迭代器2.改造红黑树3.map的模拟实现4.set的模拟实现 1.红黑树的迭代器 迭代器的好处是可以方便遍历，使数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以下问题： begin()与end() STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？能
【手撕STL】map和set
AI_ELF的博客
07-09 806
这里写目录标题setset的使用举例map三级目录 set set文档介绍 set是按照一定次序存储元素的容器 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。 set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭
【C++ STL】模拟实现 map 和 set（对一颗红黑树进行封装）
codewinter的博客
06-25 728
阅读STL源码就可以发现，其实 set 和 map 自己没有实现啥东西，整体就是对红黑树进行了一个封装，set 和 map 的 insert / erase 接口底层就是调用红黑树的 insert / erase 接口，并且 set 和 map 的迭代器也都是取的红黑树里面的迭代器那 set 和 map 的核心区别在哪里呢？set 底层封装了一颗红黑树，是 KV 结构，值得注意的是 key_type 和 value_type 都是 key，说明传了两个 key 给红黑树。 map 底层封装了一颗红黑树，是
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1709
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
数组综合应用（下标计数）C++
最新发布
hjxxlsx的博客
10-08 747
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
【C++】List
m0_46676283的博客
10-08 140
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
windows C++-创建数据流代理(三)
苏洛的博客
10-08 249
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
C++：图的最短路径问题
han2205277149的博客
10-04 1083
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
C++ STL详解：从vector到map
这篇文档详细总结了C++ STL中的常用容器，包括vector、stack、queue、priority_queue、deque、list、bitset、set、multiset、map和multimap，以及string的基本操作。 1. vector向量容器：vector是最常见的动态数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值