c++ - unordered_set与unordered_map模拟实现

最新推荐文章于 2024-08-11 17:36:33 发布
最新推荐文章于 2024-08-11 17:36:33 发布
阅读量1k 收藏 9
点赞数 22
分类专栏： c++入门到放弃 文章标签： c++ 开发语言 数据结构 c语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79539362/article/details/140935629
版权

文章目录

前言

1、unordered_set与unordered_map的介绍与接口使用可参考：unordered_set 、 unordered_map。
2、unordered_set和 unordered_map 的底层实现都是基于哈希表的。哈希表是一种通过哈希函数组织数据，以支持快速插入和搜索的数据结构。在 C++ STL（Standard Template Library）中，这两种容器利用哈希表的高效特性来提供快速的查找、插入和删除操作。
3、哈希表

namespace OpenHash
{
	//前置声明 -->给迭代器向上查找
	template<class K, class T, class KeyOfValue, class HF >
	class HashBucket;

	//哈希节点
	template<class T>
	struct HashBucketNode
	{
		HashBucketNode(const T& val)
			: _pNext(nullptr), _val(val)
		{}
		HashBucketNode<T>* _pNext;	
		T _val;	//数据
	};

	//迭代器
	template<class K,class T,class  KeyOfValue,class HF,class Ptr,class Ref>
	struct HsIterator
	{
		typedef HashBucketNode<T> Node;
		typedef HashBucket<K, T, KeyOfValue, HF> Hash;
		typedef HsIterator<K, T, KeyOfValue, HF,Ptr,Ref> Self;

		Node* _cur;
		const Hash* _hash;
		HsIterator(const  Hash* hash,  Node* cur ):_cur(cur),_hash(hash){}

		Self& operator++()
		{	
			KeyOfValue func;
			HF hf;
			if (_cur->_pNext != nullptr)
			{
				_cur = _cur->_pNext;
			}
			else
			{
				int hashi = hf(func(_cur->_val)) % _hash->_table.size();
				Node* cur = _hash->_table[++hashi];
				while (hashi < _hash->_table.size() && cur == nullptr)
				{
					cur = _hash->_table[hashi];
					hashi++;	
				}

				_cur = cur;
			}
			return *this;
		}

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

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

		Ref operator*()
		{
			return _cur->_val;
		}

		Ptr operator->()
		{
			return &(_cur->_val);
		}
	}; 

	template<class K,class T, class KeyOfValue, class HF >
	class HashBucket
	{
		typedef HashBucketNode<T> Node;	//节点重命名
		typedef HashBucket<K,T, KeyOfValue, HF> Self;	//自身重命名
	public:
		typedef  HsIterator<K, T, KeyOfValue, HF, T*, T&> Iterator;	//迭代器重命名
		typedef HsIterator<K, T, KeyOfValue, HF,const T*,const T&> ConstIterator;	//const迭代器重命名

		//迭代器作为有友元
		template<class K, class T, class  KeyOfValue, class HF, class Ptr, class Ref>
		friend struct HsIterator;

		//构造函数 哈希桶初始化大小为10
		HashBucket(size_t capacity = 10)
			: _table(10)
			, _size(0)
		{}

		//拷贝构造
		HashBucket(const Self& self)
		{
			_table.resize(10);
			//通过遍历Self和插入接口即可
			for (int i = 0; i < self._table.size(); i++)
			{
				Node* cur = self._table[i];
				while (cur)
				{
					Insert(cur->_val);
					cur = cur->_pNext;
				}
			}
		}

		//赋值重载
		Self& operator=(Self self)
		{
			Clear();
			Swap(self);
			return *this;
		}

		~HashBucket()
		{
			Clear();
		}

		Iterator Begin()
		{
			//找到第一个不为空的桶
			int i = 0;
			while (_table[i] == nullptr)
			{
				i++;
			}

			return Iterator(this, _table[i]);
		}

		Iterator End()
		{
			//用nullptr代表最后一个元素的后一个位置
			return Iterator(this, nullptr);
		}

		ConstIterator Begin() const
		{
			int i = 0;
			while (_table[i] == nullptr)
			{
				i++;
			}

			return ConstIterator(this, _table[i]);
		}

		ConstIterator End() const
		{
			return ConstIterator(this, nullptr);
		}

		//返回值：为了unordered_map的重载[]能够使用
		pair<bool, Iterator>Insert(const T & val)
		{
			//将数据转化为键值
			KeyOfValue func;

			//不允许重复键值
			Iterator it = Find(func(val));
			if ( it != End())
			{
				return make_pair(false,it);
			}

			//将键值转化为整形（哈希地址）
			HF ik;
			int hashi = ik(func(val)) % _table.size();

			//超过负载因子
			if (_size == _table.size())
			{
				//库容2倍
				vector<Node*> tmp(_table.size() * 2);

				//将原来的数据转移到tmp
				for (int i = 0; i < _table.size(); i++)
				{
					if (_table[i] != nullptr)
					{
						Node* cur = _table[i];
						while (cur)
						{
							//重新获取哈希地址
							int k = ik(func(cur->_val)) % tmp.size();
							//头插入tmp
							Node* next = cur->_pNext;
							cur->_pNext = tmp[k];
							tmp[k] = cur;
							cur = next;
						}
					}
				}
				//将容器进行交换
				_table.swap(tmp);
			}

			//插入
			Node* cur = new Node(val);
			cur->_pNext = _table[hashi];
			_table[hashi] = cur;
			_size++;

			return make_pair(true, Iterator(this,cur));
		}

		// 删除哈希桶中为data的元素(data不会重复)
		bool Erase(const K& key)
		{
			//将数据转化为键值
			KeyOfValue func;

			//将数据转化为键值
			HF ik;
			int hashi = ik(key) % _table.size();

			//获取头节点
			Node* cur = _table[hashi];
			//前驱指针
			Node* prev = nullptr;
			while (cur)
			{
				//找到，重新连接
				if (func(cur->_val) == key)
				{
					if (prev == nullptr)
					{
						_table[hashi] = cur->_pNext;
					}
					else
					{
						prev->_pNext = cur->_pNext;
					}
					_size--;
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_pNext;
			}
			
			return false;
		}

		Iterator Find(const K& key)
		{
			//将数据转化为键值
			KeyOfValue func;

			//将数据转化为键值
			HF ik;
			int hashi = ik(key) % _table.size();

			//获取头节点
			Node* cur = _table[hashi];

			//查找
			while (cur)
			{
				if (func(cur->_val) == key)
				{
					return Iterator(this,cur);
				}
				cur = cur->_pNext;
			}

			return Iterator(this, nullptr);
		}

		//大小
		size_t Size()const
		{
			return _size;
		}

		//是否为空
		bool Empty()const
		{
			return 0 == _size;
		}

		//清空
		void Clear()
		{
			//遍历容器清空每个节点
			for (int i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->_pNext;
					delete cur;
					cur = next;
				}
				//最后置空
				_table[i] = nullptr;
			}
			//大小为0
			_size = 0;
		}

		//交换
		void Swap(Self& ht)
		{
			//交换内部容器即可
			_table.swap(ht._table);
			swap(_size, ht._size);
		}

	private:
		vector<Node*> _table;	//储存哈希桶头节点指针
		size_t _size = 0;      // 哈希表中有效元素的个数
	};
};

一、unordered_set模拟实现

1、底层实现

unordered_set 的底层是一个哈希表。但是，它只存储元素本身，而不是键值对。因此，每个元素的值同时也是其唯一的键。

2、特点

无序性：元素的顺序不保证，且可能会随着插入和删除操作而改变。
元素的唯一性：unordered_set 中的每个元素都是唯一的。
快速查找：同样地，平均情况下，查找、插入和删除操作的时间复杂度都是 O(1)。

3、代码实现
（1）基础框架

//哈希函数
template<class	K>
class HashFunc
{
public:
	size_t operator()(const K& val)
	{
		return val;
	}
};
//特化版本的哈希函数
template<>
class HashFunc<string>
{
public:
	size_t operator()(const string& s)
	{
		const char* str = s.c_str();
		unsigned int seed = 131; // 31 131 1313 13131 131313
		unsigned int hash = 0;
		while (*str)
		{
			hash = hash * seed + (*str++);
		}

		return hash;
	}
};

//数据转化为键值的函数
template<class K>
struct KeyOfValue
{
	const K& operator()(const K& data)
	{
		return data;
	}
};

//unordered_set
template<class K, class HF = HashFunc<K>>
class unordered_set
{
	//哈希表重命名
	typedef OpenHash::HashBucket<K, const K, KeyOfValue<K>, HF> HT;
public:
	//对哈希表迭代器进行重命名
	typename typedef  HT::Iterator iterator;
	typename typedef  HT::ConstIterator const_iterator;

private:
	//哈希表
	HT _ht;
};

unordered_set模板参数
K：即充当键值也充当数据
HF：哈希函数，用于计算哈希值

unordered_set成员变量
_ht: 哈希表

给哈希表传模板参数
K : 代表键值类型，该类型变量用于查找删除等接口
const K:代表数据类型，因为不能被修改所以加上const修饰，该类型变量用于插入等
KeyOfValue<K>：将数据转化为键值（在unordered_set中不明显，因为键值类型与数据类型一致，主要在unordered_map中体现）
HF：哈希函数，用于计算哈希值

（2）接口实现
这里的接口都是直接复用哈希表的接口，包括插入、删除、查找等，析构不用我们自己实现，因为结束时析构自动调用哈希表的析构函数进行清理。

//构造函数
	unordered_set() : _ht()
	{}

	//拷贝构造函数
	unordered_set(const unordered_set& p) :_ht(p._ht)
	{}

	//赋值函数
	unordered_set& operator=(const unordered_set& p)
	{
		_ht = p._ht;

		return *this;
	}

	//迭代器
	iterator begin()
	{
		return _ht.Begin();
	}
	iterator end()
	{
		return _ht.End();
	}
	const_iterator begin() const
	{
		return _ht.Begin();
	}
	const_iterator end()const
	{
		return _ht.End();
	}

	//元素个数
	size_t size()const { return _ht.Size(); }

	//是否为空
	bool empty()const { return _ht.Empty(); }

	//查找
	iterator find(const K& key) { return _ht.Find(key); }

	//插入
	pair<bool, iterator> insert(const K& valye)
	{
		return _ht.Insert(valye);
	}

	//删除
	bool  erase(const K& position)
	{
		return _ht.Erase(position);
	}

（3）测试

void test_set()
{
	//默认构造
	unordered_set<int> s;
	//插入
	s.insert(1);
	s.insert(2);
	s.insert(3);
	s.insert(4);
	
	cout << "s1:";
	//拷贝构造
	unordered_set<int> s1(s);
	//迭代器遍历
	unordered_set<int>::iterator it1 = s1.begin();
	while (it1 != s1.end())
	{
		cout << *it1 << " ";
		++it1;
	}

	cout << endl;
	cout << "s2:";
	//赋值
	unordered_set<int> s2;
	s2 = s;
	//删除
	s2.erase(1);
	s2.erase(2);
	//迭代器遍历
	unordered_set<int>::iterator it2 = s2.begin();
	while (it2 != s2.end())
	{
		cout << *it2 << " ";
		++it2;
	}
}

在这里插入图片描述

二、unordered_map模拟实现

1、底层实现

unordered_map 的底层是一个哈希表，每个元素都是一个键值对（key-value pair）。通过哈希函数，键（key）被映射到一个特定的位置（也称为桶或槽位），这个位置存储了相应的值（value）。如果多个键经过哈希函数计算后得到相同的位置，就发生了哈希冲突，此时通常通过链表或红黑树等数据结构来解决冲突。

2、特点

无序性：元素的顺序不保证，且可能会随着插入和删除操作而改变。
快速查找：平均情况下，查找、插入和删除操作的时间复杂度都是 O(1)。
键的唯一性：每个键在 unordered_map 中必须是唯一的。

3、代码实现
（1）基础框架

//哈希函数
template<class	K>
class HashFunc
{
public:
	size_t operator()(const K& val)
	{
		return val;
	}
};
//特化string
template<>
class HashFunc<string>
{
public:
	size_t operator()(const string& s)
	{
		const char* str = s.c_str();
		unsigned int seed = 131; 
		unsigned int hash = 0;
		while (*str)
		{
			hash = hash * seed + (*str++);
		}

		return hash;
	}
};

//数据转化为键值
template<class K, class V>
struct KeyOfValue
{
	const K& operator()(const pair<K, V>& data)
	{
		return data.first;
	}
};

template<class K, class V, class HF = HashFunc<K>>
class unordered_map
{
	//对哈希表重命名
	typedef OpenHash::HashBucket<K, pair<const K, V>, KeyOfValue<K, V>, HF>  HT;
	
public:
	//迭代器重命名
	typename typedef  HT::Iterator iterator;
	typename typedef  HT::ConstIterator const_iterator;

private:
	//哈希表
	HT _ht;
};

unordered_map模板参数
K：键值类型
V：数据类型
HF：哈希函数

unordered_map成员变量
_ht:哈希表

给哈希表传模板参数
K：键值，用于删除、查找等接口
KeyOfValue<K, V>：将数据转化为键值
pair<const K, V>：作为数据，其中const K作为键值类型（因为键值不能改需要通过const修饰），V作为映射的数据类型，通过KeyOfValue<K, V> 函数返回键值（如在插入时只传入pair<const K, V>类型数据，无法通过数据进行比较，所以需要通过该函数转化）。
HF：哈希函数

（2）接口实现
A . 重载[ ] : 该接口的特点是如果该键值的不存在，则进行插入（键值映射的数据用默认构造初始化），如果存在就返回键值映射的数据，所以需要与插入接口的配合，通过插入接口的返回值来配合。

//重载[]
V& operator[](const K& key)
{
	pair < bool, iterator > ret = _ht.Insert(make_pair(key, V()));
	return ret.second->second;
}

B . 其他接口都是直接复用哈希表的接口，包括插入、删除、查找等，析构不用我们自己实现，因为结束时析构自动调用哈希表的析构函数进行清理。

//构造函数
unordered_map() : _ht()
{}

//拷贝构造
unordered_map(const unordered_map& p) :_ht(p._ht)
{}

//赋值
unordered_map & operator=(const unordered_map& p)
{
	_ht = p._ht;

	return *this;
}

//迭代器
iterator begin()
{
	return _ht.Begin();
}
iterator end()
{
	return _ht.End();
}
const_iterator begin() const
{
	return _ht.Begin();
}
const_iterator end()const
{
	return _ht.End();
}

//元素个数
size_t size()const
{ 
	return _ht.Size();
}
//是否为空
bool empty()const 
{ 
	return _ht.Empty();
}

//查找
iterator find(const K& key) 
{ 
	return _ht.Find(key);
}
//
 插入
pair<bool,iterator> insert(const pair<K, V>& valye)
{
	return _ht.Insert(valye);
}

//删除
bool erase(const K&  key)
{
	return _ht.Erase(key);
}

（3）测试

 void test_map()
{
	//默认构造
	unordered_map<int, int> m;
	//插入
	m.insert({ 1,1 });
	m.insert({ 2,2 });
	m.insert({ 3,3 });
	m.insert({ 4,4 });

	cout << "m1:";
	//拷贝构造
	unordered_map<int, int> m1 = m;
	//迭代器遍历
	unordered_map<int, int>::iterator it1 = m1.begin();
	while (it1 != m1.end())
	{
		cout << it1->first << ":" << it1->second << "   ";
		++it1;
	}
	cout << endl;
	cout << "m2:";
	//赋值
	unordered_map<int, int> m2;
	m2 = m;
	//删除
	m2.erase(1);
	m2.erase(2);
	//重载[]
	m2[3] = 100;
	m2[5] = 100;
	//迭代器遍历
	unordered_map<int, int>::iterator it2 = m2.begin();
	while (it2 != m2.end())
	{
		cout << it2->first << ":" << it2->second << "   ";
		++it2;
	}
}

在这里插入图片描述

爱吃汉堡.
关注
  • 22
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Data-Structures_Algorithm
03-11
- **哈希表**：使用哈希函数实现快速查找，C++中的`std::unordered_map`和`std::unordered_set`是实现。 2. **排序与搜索算法** - **排序算法**：包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序...
-Data_structureReview
03-13
C++标准库中的`std::unordered_map`和`std::unordered_set`提供了散列表实现。 9. **排序算法**：常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。了解各种排序算法的时间复杂度和...
[C++]STL---unordered_set与unordered_map的模拟实现
m0_58963318的博客
04-26 849
深度剖析unordered_set与ordered_map的模拟实现
C++进阶--unordered_set、unordered_map的介绍和使用
sushang的博客
01-15 3704
1.unordered_set是不按特定顺序存储键值的关联式容器，其允许通过键值快速的索引到对应的元素。2.在unordered_set中，元素的值同时也是唯一的标识它的key。3.在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的key，unordered_set将相同哈希值的键值放在相同的桶中。4.unordered_set容器通过key访问单个元素要比set快，但它通常在遍历元素子集的范围迭代方面效率较低。5.它的迭代器至少是前向迭代器。
c++中 unordered_map 与 unordered_set 用法指南
人生只有一次，不妨大胆一点～～
06-01 1314
c++中 unordered_map 与 unordered_set 用法指南
C++ STL(八) -------- unordered_set、unordered_map的介绍+使用+比较
向未来❀去探索 的博客
09-04 1511
unordered_set、unordered_map的介绍+使用+比较
初识C++之unordered_map与unordered_set
Masquerena114514的博客
04-07 2092
本文主要讲述了通过对哈希桶的改造，使得unordered_set和unordered_map能够对同一个哈希桶进行封装并模拟实现
C++ —— unordered_set、unordered_map的介绍及使用
weixin_66905164的博客
06-19 932
unordered_multimap容器与unordered_map容器的底层数据结构是一样的，都是哈希表，其次，它们所提供的成员函数的接口都是基本一致的，这里就不再列举了，这两种容器唯一的区别就是，unordered_multimap容器允许键值冗余，即unordered_multimap容器当中存储的键值对的key值是可以重复的。在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的3.key，unordered_set将相同哈希值的键值放在相同的桶中。
c++ map与unordered_map区别及使用
热门推荐
别说话写代码的博客
12-01 26万+
转自：https://blog.csdn.net/BillCYJ/article/details/78985895 需要引入的头文件不同 map: #include &lt; map &gt; unordered_map: #include &lt; unordered_map &gt; 内部实现机理不同 map： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二...
【C++进阶】八、STL---unordered_set & unordered_set的介绍及使用
枫叶先生的博客
03-15 1871
unordered_set & unordered_set的介绍及使用
【C++】unordered_set 和 unordered_map 使用 | 封装
qq_62939852的博客
05-27 2110
哈希桶HashBucket中需要将其内部的HashNode 的参数进行修改将原来的模板参数 K，V 改为 T同样由于不知道传入数据的是K还是K V类型的 ，所以 使用 T 类型的data代替之前实现的模板参数 K ，V分别代表 key 与value修改后 ， 第一个参数 拿到单独的K类型，是为了 使用 Find erase接口函数的参数为K第二个参数 T 决定了 拿到的是K类型 还是 K V 类型。
STL-70个算法.rar_C++_stl 练习
09-23
STL提供了一些核心的数据结构，如vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（红黑树实现的键值对映射）和unordered_set/unordered_map（哈希表实现的集合和映射）。...
robin-hood-hashing：基于C ++ 11141720的基于robin hood哈希的快速且内存高效的哈希表
01-30
robin_hood::unordered_map和robin_hood::unordered_set是std::unordered_map / std::unordered_set独立于平台的替代品，对于实际的用例而言，它既更快，更高效。 安装及使用 直接纳入 将添加到您的C ++项目。 ...
C++ - SGI 版本 STL源码
10-25
- **unordered_map/unordered_multimap**: 类似于map，但使用哈希表实现。 2. **迭代器** - 迭代器是STL的核心概念，它充当了容器和算法之间的桥梁。有五种类型的迭代器：输入迭代器、输出迭代器、前向迭代器、...
使用 `std::optional` 实现线程安全的智能指针
最新发布
ALex_zry的博客
08-11 206
的使用方式，因为概念可以用于更精确地指定模板参数的要求。此外，C++20 还引入了模块（Modules），这可能会使得包含和使用。在 C++20 中并没有引入显著的新特性或改进。本身并不提供线程安全的特性，因为它只是用来表示值的存在或缺失。不过，C++20 引入了概念（Concepts），这可能会影响。并确保线程安全，你应该依赖于适当的同步机制，而不是依赖于。截至目前（2023年），C++20 标准已经发布，但。的访问是线程安全的，例如，在访问。对象，除非使用了适当的同步机制。，这样即使在多线程环境中，
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 347
STL中的迭代器失效（vector为例）
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 317
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 461
c++ error: ‘*’ does not name a type； did you mean ‘**’?
c++哈希表unordered_set unordered_map
10-12
unordered_set和unordered_map都是C++ STL中的容器，它们都是基于哈希表实现的。unordered_set是一个集合容器，其中的元素是唯一的，而unordered_map是一个关联容器，其中的元素是键值对，每个键只能出现一次。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值