哈希表封装unordered_map+unordered_set

最新推荐文章于 2024-07-25 15:54:48 发布
最新推荐文章于 2024-07-25 15:54:48 发布
阅读量342 收藏 2
点赞数 4
文章标签： 散列表 数据结构 哈希算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64404343/article/details/129715770
版权

目录

哈希表改造

哈希表结构 

仿函数实现 

哈希表迭代器 

结构

operator*和operator-> 

operator!=和==

operator++ 

构造函数 

拷贝构造 

析构函数 

拷贝构造 

哈希表完整代码 

unordered_set封装源码

unordered_map封装源码 

 

哈希表改造

我们知道unordered_map是K型结构，unordered_map是K，V型结构，那么如何通过一个哈希表实现对它们的封装呢？

下面我们对哈希表进行改造。（本篇采用开散列结构实现哈希表） 

T表示节点所存储的数据类型。 

哈希表结构 

template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			,_next(nullptr)
		{

		}
	};

 由于unordered_map是KV结构，我们我们需要增加一个模板参数来取出key值，也就是KeyofT,

并且哈希表需要将key值转换成可以取模的整数，所以再设置一个HashFunc参数，通过它们我们可以实现仿函数来达到我们的目的。

template<class K, class T,class KeyofT,class HashFunc=Hash<K>>
	class HashTable
	{
		typedef HashNode<T> Node;
	private:
		vector<Node*> _table;//存储节点指针
		size_t _n=0;//有效数据个数
	};

仿函数实现 

 

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

string类型通常也用作key，所以我们对string类型进行特化。 

template<class K>
struct Hash
{
	size_t operator()(const K& key)
	{
		return key;
	}
};
template<>
struct Hash<string>
{
	size_t operator()(const string& s)
	{
		size_t ret = 0;
		for (auto e : s)
		{
			ret *= 31;
			ret += e;
		}
		return ret;
	}
};

 

unordered_set结构：

 

template<class K, class hash = Hash<K>>
	class unordered_set
	{
	private:
		HashTable<K, K, SetKeyofT, hash> _ht;
	};

unordered_map结构： 

template<class K, class V, class hash = Hash<K>>
	class unordered_map
	{
		struct MapKeyofT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	private:
		HashTable<K, pair<K, V>, MapKeyofT, hash> _ht;
	};

哈希表迭代器 

首先明确unordered_map和unordered_set迭代器是单向的，所以我们内部哈希表的迭代器支持++操作即可。

我们采用的是开散列结构，如何实现迭代器++呢？

思路是先查找到一个非空哈希桶，++就是遍历该桶，那么如果该桶遍历完了呢？我们就要去下一个非空桶去，因此我们迭代器内部不仅要存储节点的地址，还要存储哈希表的地址。

结构

template<class K,class T,class Ref,class Ptr,class KeyofT,class HashFunc>
	struct HashTableIterator
	{
		typedef HashNode<T> Node;
		typedef HashTableIterator<K, T, Ref, Ptr, KeyofT, HashFunc> self;
		//存储节点指针和一个哈希表的地址
		Node* _node;
		HashTable<K, T, KeyofT, HashFunc>* _pht;
		HashTableIterator( Node* node, HashTable<K, T, KeyofT, HashFunc>* pht)
			:_node(node)
			,_pht(pht)
	
	};

operator*和operator-> 

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

operator!=和==

 迭代器内部存储节点地址，比较是否相等可以直接使用节点地址去比较。

bool operator!=(const self& it)const
		{
			return _node != it._node;
		}
		bool operator==(const self& it)const
		{
			return _node == it._node;
		}

operator++ 

 如果下一个节点不为空，直接遍历到下一个节点。

如果为空，则要去寻找一个新的非空桶。

self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				KeyofT kot;
				HashFunc hf;
				Node* cur = _node;
				size_t index = hf(kot(cur->_data)) % _pht->_table.size();
				index++;
				while (index < _pht->_table.size())
				{
					if (_pht->_table[index])
					{
						break;
					}
					else
					{
						index++;
					}
				}
				if (index == _pht->_table.size())
				{
					_node = nullptr;
				}
				else
				{
					_node = _pht->_table[index];
				}
			}
			return *this;
		}

构造函数 

由于哈希表内部采用vector，所以我们不需要显示写构造函数。 

//指定编译器去默认生成构造函数
		HashTable() = default;

拷贝构造 

HashTable(const HashTable<K, T, KeyofT, HashFunc>& ht)
		{
			_table.resize(ht._table.size());
			for (size_t i = 0; i < ht._table.size(); ++i)
			{
				Node* cur = ht._table[i];
				while (cur)
				{
					Node* newnode = new Node(cur->_data);
					newnode->_next = _table[i];
					_table[i] = newnode;
					cur = cur->_next;
				}
			}
		}

析构函数 

遍历每一个哈希桶，并将其中节点释放。 

HashTable(const HashTable<K, T, KeyofT, HashFunc>& ht)
		{
			_table.resize(ht._table.size());
			for (size_t i = 0; i < ht._table.size(); ++i)
			{
				Node* cur = ht._table[i];
				while (cur)
				{
					Node* newnode = new Node(cur->_data);
					newnode->_next = _table[i];
					_table[i] = newnode;
					cur = cur->_next;
				}
			}
		}

拷贝构造 

self& operator=(self ht)
		{
			_table.swap(ht._table);
			swap(_n, ht._n);
			return *this;
		}

哈希表完整代码 

//开散列，开放定址法，哈希桶
namespace LinkHash
{
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			,_next(nullptr)
		{

		}
	};

	template<class K, class T, class KeyofT, class HashFunc>
	class HashTable;
	template<class K,class T,class Ref,class Ptr,class KeyofT,class HashFunc>
	struct HashTableIterator
	{
		typedef HashNode<T> Node;
		typedef HashTableIterator<K, T, Ref, Ptr, KeyofT, HashFunc> self;
		//存储节点指针和一个哈希表的地址
		Node* _node;
		HashTable<K, T, KeyofT, HashFunc>* _pht;
		HashTableIterator( Node* node, HashTable<K, T, KeyofT, HashFunc>* pht)
			:_node(node)
			,_pht(pht)
		{

		}
		Ref operator*()
		{
			return _node->_data;
		}
		Ptr operator->()
		{
			return &(operator*());
		}
		bool operator!=(const self& it)const
		{
			return _node != it._node;
		}
		bool operator==(const self& it)const
		{
			return _node == it._node;
		}
		self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				KeyofT kot;
				HashFunc hf;
				Node* cur = _node;
				size_t index = hf(kot(cur->_data)) % _pht->_table.size();
				index++;
				while (index < _pht->_table.size())
				{
					if (_pht->_table[index])
					{
						break;
					}
					else
					{
						index++;
					}
				}
				if (index == _pht->_table.size())
				{
					_node = nullptr;
				}
				else
				{
					_node = _pht->_table[index];
				}
			}
			return *this;
		}
	};
	template<class K, class T,class KeyofT,class HashFunc=Hash<K>>
	class HashTable
	{
		typedef HashNode<T> Node;
		friend struct HashTableIterator<K, T, T&, T*, KeyofT, HashFunc>;
		typedef HashTable<K,T,KeyofT,HashFunc> self;
	public:
		typedef HashTableIterator<K, T, T&, T*, KeyofT, HashFunc> iterator;
		typedef HashTableIterator<K, const T, const T&, const T*, KeyofT, HashFunc> const_iterator;
		iterator begin()
		{
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i])
				{
					return iterator(_table[i], this);
				}
			}
			return end();
		}
		iterator end()
		{
			return iterator(nullptr, this);
		}
		const_iterator begin()const
		{
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i])
				{
					return const_iterator(_table[i], this);
				}
			}
			return end();
		}
		const_iterator end()const
		{
			return const_iterator(nullptr, this);
		}
		//指定编译器去默认生成构造函数
		HashTable() = default;
		
		HashTable(const HashTable<K, T, KeyofT, HashFunc>& ht)
		{
			_table.resize(ht._table.size());
			for (size_t i = 0; i < ht._table.size(); ++i)
			{
				Node* cur = ht._table[i];
				while (cur)
				{
					Node* newnode = new Node(cur->_data);
					newnode->_next = _table[i];
					_table[i] = newnode;
					cur = cur->_next;
				}
			}
		}
		~HashTable()
		{
			for (size_t i = 0; i < _table.size(); ++i)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
		}
		self& operator=(self ht)
		{
			_table.swap(ht._table);
			swap(_n, ht._n);
			return *this;
		}
		size_t GetNextPrime(size_t num)
		{
			static const unsigned long __stl_prime_list[28] =
			{
				53, 97, 193, 389, 769,
				1543, 3079, 6151, 12289, 24593,
				49157, 98317, 196613, 393241, 786433,
				1572869, 3145739, 6291469, 12582917, 25165843,
				50331653, 100663319, 201326611, 402653189, 805306457,
				1610612741, 3221225473, 4294967291
			};

			for (size_t i = 0; i < 28; ++i)
			{
				if (__stl_prime_list[i] > num)
				{
					return __stl_prime_list[i];
				}
			}

			return __stl_prime_list[27];
		}
		bool erase(const K& key)
		{
			if (_table.empty())
			{
				return false;
			}
			KeyofT kot;
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev == nullptr)
					{
						_table[index] = cur->_next;
					}
					else
					{
						Node* next = cur->_next;
						prev->_next = next;
					}
					--_n;
					delete cur;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}
		iterator Find(const K& key)
		{
			if (_table.empty())
			{
				return iterator(nullptr,this);
			}
			KeyofT kot;
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur,this);
				}
				cur = cur->_next;
			}
			return iterator(nullptr, this);
		}
		pair<iterator,bool> insert(const T& data)
		{
			KeyofT kot;
			auto ret = Find(kot(data));
			if (ret._node)
			{
				return make_pair(ret,false);
			}
			HashFunc hf;
			if (_n == _table.size())
			{
				//扩容
				//size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
				size_t newsize = GetNextPrime(_n);
				vector<Node*> newTable;
				newTable.resize(newsize);
				for (size_t i = 0; i < _table.size(); ++i)
				{
					if (_table[i])
					{
						Node* cur = _table[i];
						while (cur)
						{
							Node* next = cur->_next;
							size_t index = hf(kot(cur->_data)) % newsize;
							cur->_next = newTable[index];
							newTable[index] = cur;
							cur = next;
						}
						_table[i] = nullptr;
					}
				}
				_table.swap(newTable);
			}
			size_t index = hf(kot(data)) % _table.size();
			Node* newnode = new Node(data);
			newnode->_next = _table[index];
			_table[index] = newnode;
			++_n;
			return make_pair(iterator(newnode, this), true);
		}
		size_t size()const
		{
			return _n;
		}
	private:
		vector<Node*> _table;//存储节点指针
		size_t _n=0;//有效数据个数
	};
}

unordered_set封装源码

 

namespace HashArea
{
	template<class K, class hash = Hash<K>>
	class unordered_set
	{
		struct SetKeyofT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename LinkHash::HashTable<K, K, SetKeyofT, hash>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		iterator Find(const K& key)
		{
			return _ht.Find(key);
		}
		bool erase(const K& key)
		{
			return _ht.erase(key);
		}
		pair<iterator, bool> insert(const K& key)
		{
			return  _ht.insert(key);
		}

	private:
		LinkHash::HashTable<K, K, SetKeyofT, hash> _ht;
	};
	
}

unordered_map封装源码 

namespace HashArea
{
	template<class K, class V, class hash = Hash<K>>
	class unordered_map
	{
		struct MapKeyofT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename LinkHash::HashTable<K, pair<K, V>, MapKeyofT, hash>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		bool erase(const K& key)
		{
			return _ht.erase(key);
		}
		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _ht.insert(kv);
		}
		iterator Find(const K& key)
		{
			return _ht.Find(key);
		}
		size_t size()const
		{
			return _ht.size();
		}
		V& operator[](const K& key)
		{
			auto ret = _ht.insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		LinkHash::HashTable<K, pair<K, V>, MapKeyofT, hash> _ht;
	};
}

 

 

嚞譶
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
用哈希简单封装unordered_map和unordered_set
h1091068389的博客
08-07 403
stl中的unordered_map和unordered_set内部实现了迭代器，可以使用迭代器访问其中的内容，这里我们也在哈希中实现一个迭代器操作，然后通过封装实现unordered_map和unordered_set的迭代器，实现代码如下，迭代器里面主要需要注意的是operator++操作。因此他们的基本结构可以分别这样设计：其中在原来哈希的基础上又多了一个KeyOfT的仿函数，他的作用主要是确定需要进行比较的关键字，例如map中需要比较的是T中的first，而set就是key。......
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
C++ 哈希表及unordered_set + unordered_map容器
冰果滴的博客
09-14 3115
前言：unordered_set和unordered_map是C++11中新增加的两个关联式容器，使用方式与set和map基本相同，但是unordered_set和unordered_map的底层是哈希表，而set和map的底层是红黑树。并且unordered_set不能排序；unordered_set和unordered_map是单向迭代器；效率要高一下，时间复杂度为O(1)。
C++数据结构 —— 哈希表、unordered_map/set封装
weixin_59913110的博客
03-17 1427
顺序结构以及平衡二叉搜索树结构中，在查找一个元素时需要经过比较。顺序查找时间复杂度为O(N)，平衡二叉搜索树查找时间复杂度为O(log_2N)。理想的搜索方法便是不经过任何比较，通过常数次的操作从表中得到搜索的元素。如果构造一种存储结构，如果某种函数使元素的存储位置与它存储的元素之间形成一种映射关系，那么在查找中可以通过该函数很快找到搜索元素。该方式称为哈希(散列)方法，哈希方法使用的转换函数称为哈希函数， 构造出来的数据结构称为哈希表。
C++：采用哈希表封装unordered_map和unordered_set
weixin_43908419的博客
05-18 721
本文使用哈希表对C++STL库中的unordered_map和unordered_set容器进行了封装模拟实现
STL.rar_hash stl_stl 封装_搜索树
09-24
哈希表是一种能够快速查找的数据结构，STL通过`<unordered_set>`和`<unordered_map>`这两个容器来实现。哈希表基于哈希函数，可以实现平均时间复杂度为O(1)的查找、插入和删除操作。`<unordered_set>`用于存储不...
Data_Structure:C ++的数据结构
03-27
C++标准库中的unordered_map和unordered_set容器实现了哈希表。 堆是一种部分有序的树形数据结构，常用于优先队列的实现。C++标准库中的priority_queue和heap函数提供了堆的相关操作。 图是一种节点和边构成的数据...
C++标准模板库指南_C++_
10-03
- `unordered_map`和`unordered_multimap`：哈希表实现的键值对容器，提供快速的平均查找和插入性能。 2. 迭代器： 迭代器是STL中的核心概念，它类似于指针，但具有更丰富的操作和类型安全。迭代器允许程序员以...
STL.zip_C++STL
09-19
- `unordered_set`和`unordered_multiset`：哈希表实现的集合，元素唯一，提供平均O(1)的查找、插入和删除速度。 - `unordered_map`和`unordered_multimap`：哈希表实现的关联容器，键唯一，提供平均O(1)的查找、...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 161
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 292
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 412
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 724
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 959
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1155
介绍了二叉搜索树的实现与模拟
数据结构：顺序表的实现
最新发布
2303_81073778的博客
07-25 184
3.test.c文件。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 456
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
哈希表是unordered_map还是unordered_set
03-18
哈希表既可以用unordered_map实现，也可以用unordered_set实现。哈希表是一种根据关键字值直接进行访问的数据结构，它通过将关键字映射到表中的一个位置来实现快速查找。unordered_map是一种关联容器，它将键值对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嚞譶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值