• 【C++】通过哈希表实现map和set

    前言 

            在前面，我们通过红黑树这一底层结构实现了map和set。它们是关联式容器。而现在，我们将通过哈希表这一数据结构重新实现map和set，即unordered系列的关联式容器。因为它们的遍历是无序的，和平衡二叉树不同，不能做到排序。

            既然不能做到排序，但是原本的map和set也能兼容这个功能，那么为什么要新增unordered_map和unordered_set呢？新增自然有其道理，因为是哈希思想，即映射关系，查找的效率非常高，让我们一起来看看吧~

    红黑树实现map和set博客链接：

            【C++】map&set利用红黑树进行简单封装_柒海啦的博客-CSDN博客

    目录

    一、哈希概念

    1.哈希函数

    2.哈希冲突

    1.闭散列解决哈希冲突

            1.1 线性探测

            1.2 二次探测

            1.3 扩容问题

    2.开散列解决哈希冲突

    二、闭散列实现哈希表

    三、开散列实现哈希表

    四、利用开散列哈希表模拟实现map和set

    一、哈希概念

            理解一个哈希概念是重要前提。

            我们知道，在之前的顺序存储和红黑树中，我们插入和取出元素，都是通过比较去找的。即通过相同元素之间比较关系建立起的数据结构。顺序结构的查找时间复杂度为O(N)，平衡搜索树结构的查找时间为树的高度O(log_2N)。

            但是查找效率还是不高。前面说了，哈希的核心就是映射关系，即哈希的插入和取出元素不再通过比较去实现，而是通过元素本身去映射一个位置。下次取的时候直接从这个映射位置找到即可。

            Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

            Hash算法是一个广义的算法，也可以认为是一种思想，使用Hash算法可以提高存储空间的利用率，可以提高数据的查询效率，也可以做数字签名来保障数据传递的安全性。所以Hash算法被广泛地应用在互联网应用中。（百度百科）

            那么重点就是如何去映射一个位置，已经关于此位置衍生出来的一系列问题。

    1.哈希函数

            通过上面我们了解到，想要元素映射到一个位置，就需要哈希函数进行映射。

            下面我们通过一个例子引入哈希函数以及相关映射概念。

    题目链接：

    387. 字符串中的第一个唯一字符 - 力扣（Leetcode）

            看到这一题，你的第一想法是什么？总不会是遍历每一个字符，然后每一个字符和字符串中的其他字符进行比较吧，这样的话效率太低了，时间复杂度为O(N^2)。

            这个时候就可以借助哈希的思想，也是哈希函数-直接寻址法： 

            既然是不重复的字符，那么就和此字符的出现次数有关，我们可以将此字符映射到一个数组位置，此位置就代表此字符，然后当前位置就存储此字符的出现次数即可。题目要求我们找到第一个不重复的字符，只需要按顺序遍历每个字符，取出它映射下标的次数，为1就是第一个不重复的，直接返回对应字符即可。

            那么为什么是直接寻址法呢？因为是字符串，所以字母只有26个字母，我们的数组也只需要26个空间即可，每次就直接对应一个地址即可：

    1. class Solution {
    2. public:
    3.     int firstUniqChar(string s) {
    4.         int arr[26] = { 0 };
    5.         for (auto e : s) arr[e - 'a']++;  //直接定址法
    6.         for (int i = 0; i < s.size(); ++i)
    7.         {
    8.             if (arr[s[i] - 'a'] == 1) return i;
    9.         }
    10.         return -1;
    11.     }
    12. };

            这样实现的时间复杂度就是O(N)，效率快了太多了。

            如上也就可以看到e - 'a'就是一个直接定址法，此法比较常用也是最基本的hash函数。

    常见的哈希函数：

            1. 直接定制法

                    取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况。

            2. 除留余数法

                    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。

            3. 平方取中法（了解）

            4. 折叠法（了解）

            5. 随机数法（了解）

            6. 数学分析法（了解）

    注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

            可以看到，上面抛出了一个问题，那就是哈希冲突。什么是哈希冲突呢？

    2.哈希冲突

            先给定义：

            对于两个数据元素的关键字和 (i != j)，有 != ，但有：Hash( ) == Hash( )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

            比如上述的哈希函数中的除留余数法，假设除数为10，那么0和10留下的余数就是一致的，此时两者就映射到同一位置上了。

            但是直接定址法就不会出现问题，因为是一个元素映射的一个唯一的位置。但是，如果我们给的不是一串字母，而是1 20 890呢？这样的话，如果元素数值差异较大，但是数量较少的话会严重浪费储存空间，这不就和我们的预想反着来了嘛。所以才会有除留余数法。这样的话就不受元素差异影响了，只需考虑开多少空间的问题。

            回到哈希冲突，如何解决这个问题呢？下面提供了两种解决方法：

    1.闭散列解决哈希冲突

            我们使用数组对元素进行存储。

            从问题的根源出发，原因就是哈希函数产生的哈希地址冲突了。那么我们不妨每个哈希地址设置一种状态，没有插入就为空，第一次插入就设置为存在，第二次插入此位置，因为此位置的状态为存在，所以就往后找空位置。

            如何向后找空位置呢？下面提供了两种方法：

            1.1 线性探测

            线性探测说直白点就是每次遇到冲突了就地址+1，移动到下一个位置，如果还是冲突的话就继续+1遇到空位置为止。

            那么删除呢？我们是直接把元素对应的哈希地址置为空吗？显然不是。因为通过上面的哈希冲突我们知道，那就是在初次映射得到的哈希地址一致，那么重复的元素都是从当前位置开始往后进行线性探测，如果其中一个元素（后面还跟着元素）被置为空的话，那么就找不到后面的重复映射的元素了。所以我们还需要加入一种状态，那就是删除状态。所以删除的时候就置为删除状态就可以了。

            插入也改一下，在哈希冲突时，线性探测往后找，遇到空或者删除状态就插入。查找也非常简单，每次映射到对应的哈希地址，去找对应位置存储的元素，一致就返回，不一致往后一个一个去找，直到遇到空即可。

            1.2 二次探测

            首先可以看一下线性探测的缺点：由于每次发生哈希冲突后都是连续的往后找，那么数据就很容易的堆积到一起，此时的冲突概率就会越来越大，冲突越来越大的话就可以发现效率会越来越慢。所以为了缓解这个问题，提出了二次探测。

            实际上也就是在原来冲突的哈希地址的基础上，每次找下一个位置为(H0 + i ^ 2) % m的地址。其中H0位当前哈希地址，i为1234....，m为当前哈希表的总长。

            插入删除查找类似，只不过不是一个一个往后找吗，而是每次以上面的公式去找下一个为位置。

            1.3 扩容问题

            首先先谈谈容量问题。

            你认为哈希表的扩容能像以前那样满了直接扩吗？显然不能，因为存在冲突概率。哈希表自然是为了提高效率的，如果一个哈希表中存储的全是冲突元素，那哈希的作用不就微乎其微了吗，那还不如直接遍历一遍数组省去哈希函数的麻烦。

            所以我们需要降低冲突概率，冲突概率用负载因子进行计算，下面给出负载因子的计算公式：

            负载因子=插入元素个数 / 散列表的长度

            在大量实验证明下，一般闭散列（开放定址法）我们保持住0.7即可保证较高效率。即当哈希表中大于负载因子的时候就需要重新扩容。

            扩容也不是简简单单直接将值拷贝过去即可，而是需要重新进行映射。复用插入代码即可。

    2.开散列解决哈希冲突

            闭散列我们可以明显的发现问题：一旦冲突的话就是一大片冲突。虽然二次探测稍微缓和了一点但是没有从本质上解决问题。

            那么我们可以这样想，如果发生了哈希冲突不是往后面找位置进行占用，而是挂在当前位置下呢？所以，这里我们就可以借助单链表，数组也就变成了存放指针的数组。

            开散列也称哈希桶，每个数组元素就相当于一个桶，桶里存放的就是存在哈希冲突的元素。插入的时候，就直接头插即可（尾插的话要往下也可以，但是效率不好）。寻找的话也是根据哈希地址找到对应的桶，然后遍历桶里的元素去寻找即可，删除就是找到对应元素的结点，链表的删除即可。

            因为是开散列，所以只要指针数组满了就扩容即可。那么每次扩多大呢？经过实验发现，每次扩成一个素数，似乎效率更高，所以我们不妨每次以素数的大小去扩。另外，需要注意此时的扩容就不能像上面直接复用了，因为是指针，所以浅拷贝不说，另外桶在当前容量下是冲突的，但是一旦变了容量的话那就不一定冲突了。所以需要老老实实的每个结点再次插入。

    二、闭散列实现哈希表

    代码如下：（下面只以线性探测为例，二次探测类似）

    1. // 闭散列
    2. namespace CloseHash
    3. {
    4. 	enum class State  // 设置状态，防止删除&插入&查找存在冲突
    5. 	{
    6. 		EMPTY,  // 空
    7. 		DELETE,  // 删除
    8. 		EXIST  // 存在
    9. 	};
    10.  
    11. 	template<class K, class V>
    12. 	struct HashElem  // 元素类型
    13. 	{
    14. 		pair _kv;
    15. 		State _state = State::EMPTY;  // 默认给空
    16. 	};
    17.  
    18. 	template<class K, class V>
    19. 	ostream& operator<<(ostream& out, const HashElem& he)
    20. 	{
    21. 		out << "[" << he._kv.first << ":" << he._kv.second << "]";
    22. 		return out;
    23. 	}
    24.  
    25. 	template<class K, class V, class Hash = HashFunc>
    26. 	class HashTable
    27. 	{
    28. 	public:
    29. 		// 构造函数 - 可以一上来开空间
    30. 		HashTable(size_t capacity = 3)
    31. 			:_data(capacity), _size(0)
    32. 		{}
    33.  
    34. 		// 插入
    35. 		bool Insert(const pair& kv)
    36. 		{
    37. 			// 防止数据冗余，首先对进入的kv的frist进行一个查找
    38. 			if (Find(kv.first)) return false;
    39. 			// 首先考虑扩不扩容
    40. 			CheckCapacity();
    41. 			size_t hashi = Hash()(kv.first) % _data.size();  // 除留余数法 使用了匿名对象
    42. 			while (_data[hashi]._state == State::EXIST)  // 遇到标记删除和空均可插入
    43. 			{
    44. 				hashi++;  // 线性探测
    45. 				// 注意是一个循环进行的过程，超过边界了没有遇到空或者删除就到第一个去，循环数组
    46. 				hashi %= _data.size();
    47. 			}
    48. 			_data[hashi]._kv = kv;
    49. 			_data[hashi]._state = State::EXIST;
    50. 			++_size;
    51. 			return true;
    52. 		}
    53.  
    54. 		// 删除
    55. 		bool Erase(const K& key)
    56. 		{
    57. 			HashElem* tmp = Find(key);
    58. 			if (tmp == nullptr) return false;  // 没有找到
    59. 			tmp->_state = State::DELETE;
    60. 			--_size;
    61. 			return true;
    62. 		}
    63.  
    64. 		HashElem* Find(const K& key)
    65. 		{
    66. 			if (_size == 0) return nullptr;
    67. 			int hashi = Hash()(key) % _data.size();
    68. 			while (_data[hashi]._state != State::EMPTY)
    69. 			{
    70. 				if (_data[hashi]._state == State::EXIST && _data[hashi]._kv.first == key)
    71. 				{
    72. 					return &_data[hashi];
    73. 				}
    74. 				hashi++;
    75. 				hashi %= _data.size();  // 循环查找
    76. 			}
    77. 			return nullptr;  // 没有找到
    78. 		}
    79.  
    80. 		void CheckCapacity()  // 检查是否扩容 - 根据负载因子：负载因子 = 当前数据个数 / 当前存储空间长度 - 闭散列负载因子建议控制在0.7左右
    81. 		{
    82. 			// 此时扩容就不再是以前单纯的扩展空间和迁移数据了，对于哈希表来说，由于是根据除留余数法进行的，所以一旦存储长度发生变化，就需要重新进行映射
    83. 			if (_data.size() == 0 || _size * 1.0 / _data.size() >= 0.7)
    84. 			{
    85. 				size_t newcapacity = _size == 0 ? 10 : _data.size() * 2;
    86. 				HashTable newHash(newcapacity);  // 重新建立一个哈希表
    87. 				// 开完空间首先重新映射
    88. 				for (auto& e : _data)
    89. 				{
    90. 					if (e._state == State::EXIST) newHash.Insert(e._kv);
    91. 				}
    92. 				_data.swap(newHash._data);  // vector自带的swap交换函数
    93. 			}
    94. 		}
    95.  
    96. 		void Print()
    97. 		{
    98. 			for (auto& e : _data)
    99. 			{
    100. 				if (e._state == State::EXIST) cout << "[" << e._kv.first << ":" << e._kv.second << "]" << " ";
    101. 			}
    102. 			cout << endl;
    103. 		}
    104.  
    105. 		size_t Capacity()
    106. 		{
    107. 			return _data.size();
    108. 		}
    109.  
    110. 		size_t Size()
    111. 		{
    112. 			return _size;
    113. 		}
    114. 	private:
    115. 		vector> _data;
    116. 		size_t _size;  // 实际有效数据个数
    117. 	};
    118. }

    哈希仿函数：

    1. template<class K>
    2. struct HashFunc
    3. {
    4. 	size_t operator()(const K& k)
    5. 	{
    6. 		return (size_t)k;  // 针对于数而言
    7. 	}
    8. };

     

    三、开散列实现哈希表

     代码如下：

    1. namespace OpenHash  // 哈希桶 - 开散列 - 存在哈希冲突，就挂结点在下面
    2. {
    3. 	template<class K, class V>
    4. 	struct HashBucketNode
    5. 	{
    6. 		pair _kv;
    7. 		HashBucketNode* _next;
    8.  
    9. 		HashBucketNode(const pair& kv)
    10. 			:_kv(kv), _next(nullptr)
    11. 		{}
    12. 	};
    13.  
    14. 	template<class K, class V, class Hash = HashFunc>
    15. 	class HashBucket
    16. 	{
    17. 		typedef HashBucketNode Node;
    18. 	public:
    19. 		HashBucket(size_t capacity = 3)
    20. 			:_size(0)
    21. 		{
    22. 			_data.resize(capacity, nullptr);  // 全部初始化为空
    23. 		}
    24.  
    25. 		~HashBucket()
    26. 		{
    27. 			for (size_t i = 0; i < _data.size(); ++i)
    28. 			{
    29. 				Node* cur = _data[i];
    30. 				while (cur)
    31. 				{
    32. 					Node* next = cur->_next;
    33. 					delete cur;
    34. 					cur = next;
    35. 				}
    36. 				_data[i] = nullptr;
    37. 			}
    38. 		}
    39.  
    40. 		bool Insert(const pair& kv)
    41. 		{
    42. 			if (Find(kv.first)) return false;  // 防止数据冗余
    43. 			CheckCapacity(); // 扩容
    44.  
    45. 			size_t hashi = Hash()(kv.first) % _data.size();
    46. 			Node* cur = new Node(kv);
    47. 			cur->_next = _data[hashi];
    48. 			_data[hashi] = cur;
    49. 			++_size;
    50. 			return true;
    51. 		}
    52.  
    53. 		bool Find(const K& key)
    54. 		{
    55. 			size_t hashi = Hash()(key) % _data.size();
    56. 			Node* cur = _data[hashi];
    57. 			while (cur)
    58. 			{
    59. 				if (cur->_kv.first == key) return true;
    60. 				cur = cur->_next;
    61. 			}
    62. 			return false;
    63. 		}
    64.  
    65. 		bool Erase(const K& key)
    66. 		{
    67. 			if (_size == 0) return false;
    68. 			size_t hashi = Hash()(key) % _data.size();
    69.  
    70. 			Node* pre = nullptr;
    71. 			Node* cur = _data[hashi];
    72. 			while (cur)
    73. 			{
    74. 				if (cur->_kv.first == key)
    75. 				{
    76. 					// 此时是头删
    77. 					if (pre == nullptr)
    78. 					{
    79. 						pre = cur->_next;
    80. 						_data[hashi] = pre;
    81. 					}
    82. 					else  // 中间删
    83. 					{
    84. 						pre->_next = cur->_next;
    85. 					}
    86. 					delete cur;
    87. 					--_size;
    88.  
    89. 					return true;
    90. 				}
    91. 				pre = cur;
    92. 				cur = cur->_next;
    93. 			}
    94. 			// 没有找到
    95. 			return false;
    96. 		}
    97.  
    98. 		size_t BucketsCount()  // 返回当前桶的个数 - 也就是哈希表的表长
    99. 		{
    100. 			return _data.size();
    101. 		}
    102.  
    103. 		size_t BucketsSize()  // 当前数据个数
    104. 		{
    105. 			return _size;
    106. 		}
    107.  
    108. 		void Print()
    109. 		{// 测试遍历用
    110. 			for (size_t i = 0; i < _data.size(); ++i)
    111. 			{
    112. 				Node* cur = _data[i];
    113. 				while (cur)
    114. 				{
    115. 					cout << "[" << cur->_kv.first << ":" << cur->_kv.second << "]";
    116. 					cur = cur->_next;
    117. 				}
    118. 			}
    119. 			cout << endl;
    120. 		}
    121. 	private:
    122. 		vector _data;
    123. 		size_t _size;  // 存储的有效数据个数
    124.  
    125. 		// 每次返回一个素数 - 这样每次摸上一个素数 - 扩容就按这个标准来
    126. 		inline size_t __stl_next_prime(size_t n)
    127. 		{
    128. 			static const size_t __stl_num_primes = 28;
    129. 			static const size_t __stl_prime_list[__stl_num_primes] =
    130. 			{
    131. 				53, 97, 193, 389, 769,
    132. 				1543, 3079, 6151, 12289, 24593,
    133. 				49157, 98317, 196613, 393241, 786433,
    134. 				1572869, 3145739, 6291469, 12582917, 25165843,
    135. 				50331653, 100663319, 201326611, 402653189, 805306457,
    136. 				1610612741, 3221225473, 4294967291
    137. 			};
    138.  
    139. 			for (size_t i = 0; i < __stl_num_primes; ++i)
    140. 			{
    141. 				if (__stl_prime_list[i] > n)
    142. 				{
    143. 					return __stl_prime_list[i];
    144. 				}
    145. 			}
    146.  
    147. 			return -1;
    148. 		}
    149.  
    150. 		void CheckCapacity()
    151. 		{
    152. 			// 扩展空间
    153. 			if (_data.size() == 0 || _size == _data.size())  // 哈希桶  控制负载因子不超过1 实际数据个数 / 哈希表长 
    154. 			{
    155. 				vector newdata;
    156. 				newdata.resize(__stl_next_prime(_size), nullptr);  // 首先全部都是空的
    157. 				// 此时不可以像闭散列那样进行复用映射了，因为复用映射此时就是浅拷贝
    158. 				for (size_t i = 0; i < _data.size(); i++)
    159. 				{
    160. 					Node* cur = _data[i];
    161. 					while (cur)  // 依次重新进行映射，然后转移结点数据
    162. 					{
    163. 						Node* next = cur->_next;
    164.  
    165. 						size_t hashi = Hash()(cur->_kv.first) % newdata.size();
    166. 						cur->_next = newdata[hashi];
    167. 						newdata[hashi] = cur;
    168.  
    169. 						cur = next;
    170. 					}
    171. 					_data[i] = nullptr;
    172. 				}
    173. 				_data.swap(newdata);
    174. 			}
    175.  
    176. 		}
    177.  
    178. 	};
    179. }

    四、利用开散列哈希表模拟实现map和set

            和当初利用红黑树结构封装类似，同样的我们需要哈希表实现一个迭代器。由于其是无序的，所以只需要设计一个向前遍历的迭代器即可，其余操作类似，这里直接上代码了：

            哈希表实现：

    1. namespace OpenHash  // 哈希桶 - 开散列 - 存在哈希冲突，就挂结点在下面
    2. {
    3. 	template<class T>
    4. 	struct HashBucketNode
    5. 	{
    6. 		T _data;
    7. 		HashBucketNode* _next;
    8.  
    9. 		HashBucketNode(const T& data)
    10. 			:_data(data), _next(nullptr)
    11. 		{}
    12. 	};
    13. 	// 模板类声明
    14. 	template<class K, class T, class Hash, class KeyOfT>
    15. 	class HashBucket;
    16.  
    17. 	template<class K, class T, class Hash, class KeyOfT>
    18. 	struct __HashBucketIterator
    19. 	{
    20. 		typedef HashBucketNode Node;
    21. 		typedef HashBucket Hb;
    22. 		typedef __HashBucketIterator Self;
    23.  
    24. 		Node* node;
    25. 		Hb* hb;
    26.  
    27. 		__HashBucketIterator(Node* Node, Hb* Hb)
    28. 			:node(Node), hb(Hb)
    29. 		{}
    30.  
    31. 		T& operator*()
    32. 		{
    33. 			return node->_data;
    34. 		}
    35.  
    36. 		T* operator->()
    37. 		{
    38. 			return &node->_data;
    39. 		}
    40.  
    41. 		Self& operator++()  // 前置++
    42. 		{
    43. 			if (node->_next)  // 存在就不用通过哈希表去找了
    44. 			{
    45. 				node = node->_next;
    46. 			}
    47. 			else
    48. 			{
    49. 				KeyOfT kot;
    50. 				size_t hashi = Hash()(kot(node->_data)) % hb->_data.size();
    51. 				Node* cur = hb->_data[++hashi];
    52. 				while (cur == nullptr)
    53. 				{
    54. 					hashi++;
    55. 					if (hashi >= hb->_data.size()) break;
    56. 					cur = hb->_data[hashi];
    57. 				}
    58. 				node = cur;
    59. 			}
    60. 			return *this;
    61. 		}
    62.  
    63. 		bool operator==(const Self& s) const
    64. 		{
    65. 			return s.node == node;
    66. 		}
    67.  
    68. 		bool operator!=(const Self& s) const 
    69. 		{
    70. 			return !(s == *this);
    71. 		}
    72. 	};
    73. 	template<class K, class T, class Hash, class KeyOfT>
    74. 	class HashBucket
    75. 	{
    76. 		typedef HashBucketNode Node;
    77.  
    78. 		template<class K, class T, class Hash, class KeyOfT>
    79. 		friend struct __HashBucketIterator;  // 友元类  注意模板类的声明
    80.  
    81. 	public:
    82. 		typedef __HashBucketIterator iterator;
    83.  
    84. 		iterator begin()
    85. 		{
    86. 			Node* cur = nullptr;
    87. 			for (size_t i = 0; i < _data.size(); ++i)
    88. 			{
    89. 				cur = _data[i];
    90. 				if (cur) break;
    91. 			}
    92. 			return iterator(cur, this);
    93. 		}
    94.  
    95. 		iterator end()
    96. 		{
    97. 			return iterator(nullptr, this);
    98. 		}
    99.  
    100. 		HashBucket(size_t capacity = 3)
    101. 			:_size(0)
    102. 		{
    103. 			_data.resize(capacity, nullptr);  // 全部初始化为空
    104. 		}
    105.  
    106. 		~HashBucket()
    107. 		{
    108. 			for (size_t i = 0; i < _data.size(); ++i)
    109. 			{
    110. 				Node* cur = _data[i];
    111. 				while (cur)
    112. 				{
    113. 					Node* next = cur->_next;
    114. 					delete cur;
    115. 					cur = next;
    116. 				}
    117. 				_data[i] = nullptr;
    118. 			}
    119. 		}
    120.  
    121. 		pairbool> Insert(const T& data)
    122. 		{
    123. 			KeyOfT kot;
    124. 			iterator ret = Find(kot(data));
    125. 			if (ret != end()) return pairbool>(ret, false);
    126. 			CheckCapacity(); // 扩容
    127.  
    128. 			size_t hashi = Hash()(kot(data)) % _data.size();
    129. 			Node* cur = new Node(data);
    130. 			cur->_next = _data[hashi];
    131. 			_data[hashi] = cur;
    132. 			++_size;
    133. 			return make_pair(iterator(cur, this), true);
    134. 		}
    135.  
    136. 		iterator Find(const K& key)
    137. 		{
    138. 			KeyOfT kot;
    139. 			size_t hashi = Hash()(key) % _data.size();
    140. 			Node* cur = _data[hashi];
    141. 			while (cur)
    142. 			{
    143. 				if (kot(cur->_data) == key) return iterator(cur, this);
    144. 				cur = cur->_next;
    145. 			}
    146. 			return iterator(nullptr, this);
    147. 		}
    148.  
    149. 		bool Erase(const K& key)
    150. 		{
    151. 			if (_size == 0) return false;
    152. 			KeyOfT kot;
    153. 			size_t hashi = Hash()(key) % _data.size();
    154.  
    155. 			Node* pre = nullptr;
    156. 			Node* cur = _data[hashi];
    157. 			while (cur)
    158. 			{
    159. 				if (kot(cur->_data) == key)
    160. 				{
    161. 					// 此时是头删
    162. 					if (pre == nullptr)
    163. 					{
    164. 						pre = cur->_next;
    165. 						_data[hashi] = pre;
    166. 					}
    167. 					else  // 中间删
    168. 					{
    169. 						pre->_next = cur->_next;
    170. 					}
    171. 					delete cur;
    172. 					--_size;
    173.  
    174. 					return true;
    175. 				}
    176. 				pre = cur;
    177. 				cur = cur->_next;
    178. 			}
    179. 			// 没有找到
    180. 			return false;
    181. 		}
    182.  
    183. 		size_t BucketsCount()  // 返回当前哈希表的表长
    184. 		{
    185. 			return _data.size();
    186. 		}
    187.  
    188. 		size_t BucketsSize()  // 当前数据个数
    189. 		{
    190. 			return _size;
    191. 		}
    192.  
    193. 	private:
    194. 		vector _data;
    195. 		size_t _size;  // 存储的有效数据个数
    196.  
    197. 		// 每次返回一个素数 - 这样每次摸上一个素数 - 扩容就按这个标准来
    198. 		inline size_t __stl_next_prime(size_t n)
    199. 		{
    200. 			static const size_t __stl_num_primes = 28;
    201. 			static const size_t __stl_prime_list[__stl_num_primes] =
    202. 			{
    203. 				53, 97, 193, 389, 769,
    204. 				1543, 3079, 6151, 12289, 24593,
    205. 				49157, 98317, 196613, 393241, 786433,
    206. 				1572869, 3145739, 6291469, 12582917, 25165843,
    207. 				50331653, 100663319, 201326611, 402653189, 805306457,
    208. 				1610612741, 3221225473, 4294967291
    209. 			};
    210.  
    211. 			for (size_t i = 0; i < __stl_num_primes; ++i)
    212. 			{
    213. 				if (__stl_prime_list[i] > n)
    214. 				{
    215. 					return __stl_prime_list[i];
    216. 				}
    217. 			}
    218.  
    219. 			return -1;
    220. 		}
    221.  
    222. 		void CheckCapacity()
    223. 		{
    224. 			// 扩展空间
    225. 			if (_data.size() == 0 || _size == _data.size())  // 哈希桶  控制负载因子不超过1 实际数据个数 / 哈希表长 
    226. 			{
    227. 				KeyOfT kot;
    228. 				vector newdata;
    229. 				newdata.resize(__stl_next_prime(_size), nullptr);  // 首先全部都是空的
    230. 				// 此时不可以像闭散列那样进行复用映射了，因为复用映射此时就是浅拷贝
    231. 				for (size_t i = 0; i < _data.size(); i++)
    232. 				{
    233. 					Node* cur = _data[i];
    234. 					while (cur)  // 依次重新进行映射，然后转移结点数据
    235. 					{
    236. 						Node* next = cur->_next;
    237.  
    238. 						size_t hashi = Hash()(kot(cur->_data)) % newdata.size();
    239. 						cur->_next = newdata[hashi];
    240. 						newdata[hashi] = cur;
    241.  
    242. 						cur = next;
    243. 					}
    244. 					_data[i] = nullptr;
    245. 				}
    246. 				_data.swap(newdata);
    247. 			}
    248.  
    249. 		}
    250.  
    251. 	};
    252. }

    UnorderedMap：

    1. #pragma once
    2. #include "HashTable.h"
    3.  
    4. // 封装哈希表实现的map结构
    5. namespace OpenHash
    6. {
    7. 	template<class K, class V, class Hash = HashFunc>
    8. 	class UnorderedMap
    9. 	{
    10. 		struct MapKeyOfT
    11. 		{
    12. 			const K& operator()(const pair& kv)
    13. 			{
    14. 				return kv.first;
    15. 			}
    16. 		};
    17. 	public:
    18. 		typedef typename HashBucket, Hash, MapKeyOfT>::iterator iterator;
    19.  
    20. 		UnorderedMap(size_t capacity = 3)
    21. 			:_hb(capacity)
    22. 		{}
    23.  
    24. 		iterator begin()
    25. 		{
    26. 			return _hb.begin();
    27. 		}
    28.  
    29. 		iterator end()
    30. 		{
    31. 			return _hb.end();
    32. 		}
    33.  
    34. 		pairbool> insert(const pair& kv)
    35. 		{
    36. 			return _hb.Insert(kv);
    37. 		}
    38.  
    39. 		V& operator[](const K& key)
    40. 		{
    41. 			pairbool> ret = _hb.Insert(make_pair(key, V()));
    42. 			return (ret.first)->second;
    43. 		}
    44.  
    45. 		iterator find(const K& key)
    46. 		{
    47. 			return _hb.Find(key);
    48. 		}
    49.  
    50. 		bool erase(const K& key)
    51. 		{
    52. 			return _hb.Erase(key);
    53. 		}
    54.  
    55. 	private:
    56. 		HashBucket, Hash, MapKeyOfT> _hb;  // 底层封装哈希表
    57. 	};
    58. }

     UnorderedSet：

    1. #pragma once
    2. #include "HashTable.h"
    3.  
    4. // 封装哈希实现的Set
    5. namespace OpenHash
    6. {
    7. 	template<class K, class Hash = HashFunc>
    8. 	class UnorderedSet
    9. 	{
    10. 		struct SetKeyOfT
    11. 		{
    12. 			const K& operator()(const K& key)
    13. 			{
    14. 				return key;
    15. 			}
    16. 		};
    17. 	public:
    18. 		typedef typename HashBucket::iterator iterator;
    19.  
    20. 		iterator begin()
    21. 		{
    22. 			return _hb.begin();
    23. 		}
    24.  
    25. 		iterator end()
    26. 		{
    27. 			return _hb.end();
    28. 		}
    29.  
    30. 		pairbool> insert(const K& key)
    31. 		{
    32. 			return _hb.Insert(key);
    33. 		}
    34.  
    35. 		bool erase(const K& key)
    36. 		{
    37. 			return _hb.Erase(key);
    38. 		}
    39.  
    40. 		iterator find(const K& key)
    41. 		{
    42. 			return _hb.Find(key);
    43. 		}
    44.  
    45.  
    46. 	private:
    47. 		HashBucket _hb;
    48. 	};
    49. }
  • 相关阅读:
    STM32WB55开发(6)----FUS更新
    20221130今天的世界发生了什么
    解决vue2设置cross-env设置环境变量不起作用问题
    pg 函数匹配规则
    【代码随想录】算法训练营 第五天 第三章 哈希表 Part 1
    【大数据技术】搭好的集群使用Spark-SQL连接Hive后，无法再次正常使用hive查询数据
    路由器基础（十一）：ACL 配置
    Spring Cloud
    美团CTF个人决赛WP
    第一章：随机过程预备知识
  • 原文地址：https://blog.csdn.net/weixin_61508423/article/details/128043581