[ C++ ] STL---map与set的模拟实现

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量871 收藏 19
点赞数 33
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58963318/article/details/137923687
版权
本文详细讨论了红黑树模板的设计，包括节点定义、迭代器的实现、如何适应set和map容器的需求，以及插入、查找逻辑和红黑树性质的维护。特别关注了红黑树模板中第一个模板参数K的重要性，以及如何通过仿函数处理不同数据类型的比较。
摘要由CSDN通过智能技术生成

目录

前言：

 红黑树结点的定义

 红黑树的改造

红黑树的迭代器

operator++()

operator--()

map的模拟实现

operator [ ]

set的模拟实现

红黑树底层结构

前言：

set容器中存储的数据为键值key，map容器中存储的数据为键值对<key,value>，当红黑树的底层采用kv模型结构时，利用模版控制红黑树模型结构的第二个模版参数从而传递不同的数据类型使得set容器存储<key，key>，map容器存储<key，pair<key,value>>，最终达到使用同一颗红黑树同时封装set容器与map容器的目的；

思考：红黑树第一个模板参数K是否可以省略？

  • 若省略红黑树的第一个模版参数，对于set容器，由于第二个模版参数与第一个模版参数相同，没有任何的影响；
  • 若省略红黑树的第一个模版参数，对于map容器，可以通过数据类型pair<K, V> 取到键值key，但是并不能取出key的类型，而红黑树的Find()函数需要key的数据类型，因此红黑树的第一个模版参数K不可以省略；

 红黑树结点的定义

enum Color
{
	RED,
	BLACK
};
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;//指向左孩子
	RBTreeNode<T>* _right;//指向右孩子
	RBTreeNode<T>* _parent;//指向父节点
	Color _col;//结点颜色
	T _data;//存储有效数据
	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
		, _data(data)
	{}
};

 红黑树的改造

红黑树的插入、查找等逻辑需要按照搜索二叉树的规则查找合适的插入位置，需要使用键值key进行比较，set容器可以直接使用key(data)进行比较，但是map容器中的数据pair<key,value>(data)首先是按first比较，若first相等则按second比较，不满足只按照first比较的需求，因此在红黑树中设计第三个模版参数用于接收map与set容器中所提供的不同的比较方式；

set容器

template<class K>
class set
{
	//仿函数
	struct SetKeyOfT//获取set容器中数据的键值key
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	//...
private:
	RBTree<K, K, SetKeyOfT> _t;
};

map容器

template<class K,class V>
class map
{
	//仿函数
	struct MapKeyOfT//获取map容器中数据的键值key
	{
		const K& operator()(const pair<K,V>& kv)
		{
			return kv.fisrt;
		}
	};
public:
	//......
private:
	RBTree<K, pair<K, V>, MapKeyOfT> _t;
};

RBTree

template <class K, class T,class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
    //...
private:
    Node* _root=nullptr;
};

红黑树内部具体某个模块涉及到到数据比较时，便可通过定义仿函数对象的方式达到对于不同类型的数据，按照自定义的方式比较；

示例

iterator* Find(const T& data)
{
	KeyOfT kot;//定义仿函数对象
	Node* cur = _root;
	while (cur)
	{
		if (kot(cur->_data) < kot(data))
		{
			cur = cur->_right;
		}
		else if (kot(cur->_data)  > kot(data))
		{
			cur = cur->_left;
		}
		else
		{
			return cur;
		}
	}
	return nullptr;
}

红黑树的迭代器

思考一：

若it为结点指针，++it，能否从红黑树的当前位置指向中序遍历后的当前位置的下一位置?  (×)

思考二：

若it为结点指针，* it，能否得到红黑树结点中的数据_data?（×）

只能将结点指针封装为自定义类型，从而使用运算符重载满足需求；

迭代器的成员变量 : Node* _node；（_node为指向当前结点的指针）
迭代器的成员函数 : 运算符重载函数；

无论是普通迭代器还是const迭代器，均需要迭代器遍历容器中的内容，因此迭代器本身可以被修改，区别仅在于迭代器指向的内容是否可以被修改，由于const迭代器本质为保护迭代器指向的内容不允许被修改，若实现const迭代器类，只需要普通迭代器的operator*()与operator->()两个接口的返回值采用const修饰，便保护容器中的内容不会被修改，其余接口均保持不变；采用迭代器类增加两个模版参数，使用时便可实例化出普通迭代器与const迭代器；

operator++()

operator--()

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)
	{}

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

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

	//++it
	Self& operator++()
	{
		//it指向当前结点,若右子树不为空,下一个访问的是右子树的最左结点
		if (_node->_right != nullptr)
		{
			Node* SubLeft = _node->_right;
			while (SubLeft->_left!= nullptr)
			{
				SubLeft = SubLeft->_left;
			}
			_node = SubLeft;
		}
		//it指向当前结点,若右子树为空,寻找祖先结点中某个结点是其父亲的左子树的结点
		else
		{
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent&&parent->_right == cur)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}

		return *this;
	}
	//it++
	Self operator++(int)
	{
		//记录++之前的it位置
		Self tmp = Self(_node);
		//it指向当前结点,若右子树不为空,下一个访问的是右子树的最左结点
		if (_node->_right != nullptr)
		{
			Node* SubLeft = _node->_right;
			while (SubLeft->_left != nullptr)
			{
				SubLeft = SubLeft->_left;
			}
			_node = SubLeft;
		}
		//it指向当前结点,若右子树为空,寻找祖先结点中某个结点是其父亲的左子树的结点
		else
		{
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent&&parent->_right == cur)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return tmp;
	}

	Self& operator--()
	{
		if (_node == nullptr)
		{
			//特殊处理(未找到解决方案,具体参见带有哨兵位的红黑树结构)
		}
		//it指向当前结点,若左子树不为空,下一个访问的是左子树的最右结点
		if (_node->_left != nullptr)
		{
			Node* SubRight = _node->_left;
			while (SubRight->_left != nullptr)
			{
				SubRight = SubRight->_right;
			}
			_node = SubRight;
		}
		//it指向当前结点,若左子树为空,寻找祖先结点中某个结点是其父亲的右子树的结点
		else
		{
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent&&parent->_left == cur)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

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

map的模拟实现

operator [ ]

operator[]通过键值k来访问map容器中对应的值value；

如果键值k不存在，则会自动插入一个新的键值对，其中键值为k，value值为默认构造的值；

如果键值k已经存在，则会返回与该键相关联的value值；

//operator[]等价形式如下:
(*((this->insert(make_pair(k,mapped_type()))).first)).second

首先this指针调用insert()函数即this->insert(make_pair(k,mapped_type()))，插入的键值对中的键值key为k，value值为mapped_type类型的默认构造函数，而insert()函数的返回值为结构体pair<iterator, bool>，结构体pair中的第一个元素为迭代器（迭代器本质为指针或者封装过的指针），当取到迭代器位置first对其解引用便可获得map容器中的与k相对应的value值；

由于map中的operator[ ]返回的类型为键值对pair<iterator bool>, 而红黑树底层的insert()函数返回bool值，因此需要对红黑树底层的insert()修改；

  • 键值对<iterator，bool>: iterator代表新插入结点的迭代器，bool值表示插入是否成功；
  • 若新结点键值key原先存在，则返回原本存在结点的迭代器，并且插入失败，返回false；
  • 若新结点键值key原先不存在，则插入结点，返回新插入结点在红黑树中的迭代器，返回true；
template<class K,class V>
class map
{
	//仿函数
	struct MapKeyOfT//获取map容器中数据的键值key
	{
		const K& operator()(const pair<K,V>& kv)
		{
			return kv.first;
		}
	};
public:
	typedef typename 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>& kv)
	{
		return _t.insert(kv);
	}
	V& operator[](const K& key)
	{
		pair<iterator, bool> ret = insert(make_pair(key, V()));
		return ret.first->second;
	}
	iterator Find(const K& key)
	{
		return _t.Find();
	}
private:
	RBTree<K, pair<K, V>, MapKeyOfT> _t;
};

set的模拟实现

template<class K>
class set
{
	//仿函数
	struct SetKeyOfT//获取set容器中数据的键值key
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;

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

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

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

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

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

红黑树底层结构

// 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;
	//左子树的最左结点(中序遍历的第一个)
	iterator begin()
	{
		Node* SubLeft = _root;
		while (SubLeft && SubLeft->_left)
		{
			SubLeft = SubLeft->_left;
		}
		return iterator(SubLeft);
	}

	//空结点
	iterator end()
	{
		return iterator(nullptr);
	}
	pair<iterator,bool> insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);
		}
		Node* parent = nullptr;
		Node* cur = _root;
		KeyOfT kot;
		while (cur != nullptr)
		{
			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->_left = cur;
		}
		else
		{
			parent->_right = 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;
				}
			}
			//parent==grandfather->_right
			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;
		}
	}
	//红黑树的检测
	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)
	{
		if (cur == nullptr)
			return true;

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

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

	iterator* Find(const T& data)
	{
		KeyOfT kot;//定义仿函数对象
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data)  > kot(data))
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

	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 IsRBTree()
	{
		//检查根结点是否为黑色
		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);
	}
private:
	Node* _root = nullptr;
};

小呆瓜历险记
关注
C++ 【set、map模拟实现】
我心如火
12-11 897
set和map使用、模拟实现
C++STL map和set的底层理解及其模拟实现【保姆式教学】
qq_54626677的博客
02-04 2405
set文档介绍map的文档简介// 该节点的左孩子 AVLTreeNode < T > * _pRight;// 该节点的右孩子 AVLTreeNode < T > * _pParent;// 该节点的双亲 T _data;int _bf;// 该节点的平衡因子 };// 节点的颜色 enum Color {// 红黑树节点的定义 template < class ValueType > struct RBTreeNode {
【C++进阶】【STL】set和map的讲解及模拟实现
2301_79551553的博客
04-05 1197
1.了解了关联性容器和键值对的概念2.了解了以红黑树为基础的四大容器的作用3.重写了红黑树4.模拟了map和set，并分析了种种设置的原因赠人一赞，日行一善。
STL中的map
明朗晨光的专栏
01-17 1152
map的初始化，使用，以及该类中的函数
C++STL之map详解
热门推荐
行码棋
09-18 4万+
本文详细介绍map的各种用法和注意事项。
c++ STL中的map
$好记性还是要多记录$
05-06 2444
1、map容器 map是C++ STL的一个关联容器，它提供一对一的数据处理能力。其中，各个键值对的键和值可以是任意数据类型，包括 C++ 基本数据类型（int、double 等）、使用结构体或类自定义的类型。 第一个可以称为关键字(key)； 第二个可能称为该关键字的值(value)； 该容器存储的都是 pair<const K, T> 类型（其中 K 和 T 分别表示键和值的数据类型）的键值对元素。 使用 map 容器存储的各个键值对，键的值既不能重复也不能被修改。换句话说，map 容
【STL】容器 - set和map的使用与实现
Hello_World_213的博客
11-05 1345
STL - set与map的使用与实现(常用及重点接口详解)
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
余文溪的《C++ STL--数据结构与算法实现》这本书很可能详细介绍了如何利用STL来解决实际问题，并通过示例程序代码来加深理解。 STL中的核心概念有以下几个： 1. 容器（Containers）：这是STL的基础，它们是存储...
一个内存高效哈希映射和哈希集的c++实现- Tessil/sparse-map
01-27
《C++实现内存高效的哈希映射与哈希集——Tessil/sparse-map解析》 在计算机科学中，数据结构是编程的基础，哈希映射（HashMap）和哈希集（HashSet）作为常用的数据结构，被广泛应用于各种场景，如数据库索引、缓存...
C++ STL---set
一个可爱的孩纸
01-03 1206
前言 set是C++中的STL容器，可以有很多用处。我曾记得在很久很久以前（那时的我还没学set）……有一道题，我用最长不降子序列去重，写的累死，交上去……WA…… 咳咳咳，言归正传！今天，我们不讲难的，先学学基础的！ 啥是set set是C++中STL中的一个很有用的容器，内部是使用一种非常高效的平衡检索二叉树：红黑树。至于用途吧……怎么说呢……就是一个无限长度自动去重自动排序（从小到大）的一个数组，即为集合。 set的定义方法 set的定义方法与其他的STL差不多。set中的元素由于是需要排
以STL::map实现引用表
01-15
以STL::map实现引用表，如有错误，欢迎指教！
C++ - SGI 版本 STL源码
10-25
SGI（Silicon Graphics, Inc.）公司在90年代为C++社区贡献了一个广受欢迎的STL实现，因其易读性和高效性而备受赞誉。这个版本的STL源码包含了容器、迭代器、函数对象、算法和内存管理等核心组件。 1. **容器** - *...
STL.rar_C++ STL_FSET-885_STL_stl源码_visual c
09-24
1. 容器（Containers）：容器是用来存储一组对象的类模板，如vector、list、deque、set、map等。它们提供了插入、删除、遍历元素以及查询等操作。例如，vector是一个动态数组，可以高效地在末尾添加和删除元素；list...
红黑树
05-11 937
红黑树         红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的
STL之Map完整(Linux内核)内部实现
大昱的博客
01-18 4547
刚开始接触Map的时候，了解到Map采用映射的方式储存数据，为了满足自己的好奇心，自己参考相关书籍，并且调试Linux系统的Map源码，成功完成了Map完整代码的封装。总体来说Windows系统Map与Linux系统Map采用了相同的实现思路，只是实现细节有点较小的差异。 同样采用相同的数据结构红黑树做为Map内核链表绑定数据的存储路线(代码内部有Window、Linux系统红黑树相关的实现
【STL】从源码看map
LLZK_的博客
11-15 4739
map 与set相同，map同样是以红黑树RB_Tree为底层机制的关联式容器。map的每一个元素都拥有两个值，一个键值（key）和一个实值（value）。它的内部实现是用一个pair来保存这个两个值。所以，map的每一个元素又是一个pair。下面是STL源码中stl_pair.h对pair的定义。 template struct pair { typedef T1 first_type
stl map底层之红黑树插入步骤详解与代码实现
mxway的专栏
06-08 2万+
文章用图片的方式对红黑树插入过程的调整进行了详细解释。并给出红黑树插入调整实现的C++源码。
STL —— map用法及实例详解（超详细完整）
薛定谔的猫的博客
05-08 1万+
文章目录map的基本性质STL —— map的用法 map的基本性质 STL —— map的用法
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 269
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小呆瓜历险记

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

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

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

打赏作者

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

抵扣说明：

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

余额充值