c++ - 第18节 - 哈希

目录

1.unordered系列关联式容器

1.1.unordered_set

1.1.1.unordered_set的介绍

1.1.2.unordered_set的使用

1.2.unordered_map

1.2.1.unordered_map的介绍

1.2.2.unordered_map的使用

1.3.unordered_multiset和unordered_multimap

2.底层结构

2.1.哈希概念

2.2.哈希冲突

2.3.哈希函数

2.4.哈希冲突解决

2.4.1.闭散列

2.4.2 开散列

3.哈希开散列模拟实现STL中的unordered_map与unordered_set

3.1.封装开散列代码，同时实现unordered_map和unordered_set

3.2.开散列哈希表的迭代器

3.3.开散列哈希表容量为素数的优化

3.4.开散列哈希表模拟实现STL中unordered_map和unordered_set的代码

4.哈希的应用

4.1.位图

4.1.1.位图概念

4.1.2.位图的实现

4.1.3.位图的应用

4.2.布隆过滤器

4.2.1.布隆过滤器提出

4.2.2.布隆过滤器概念

4.2.3.布隆过滤器的实现

4.2.4.布隆过滤器删除

4.2.5.布隆过滤器优点

4.2.6.布隆过滤器缺陷

4.2.7.布隆过滤器应用场景

5. 海量数据面试题

5.1.哈希切割

5.2.位图应用

5.3.布隆过滤器

6.分布式存储

---

1.unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，这里只对unordered_map和unordered_set进行介绍，unordered_multimap和unordered_multiset学生可查看文档介绍。

1.1.unordered_set

1.1.1.unordered_set的介绍

unordered_set类的文档介绍：unordered_set - C++ Reference (cplusplus.com)

注：

1. unordered_set是存储key值的关联式容器。

2. 在unordered_set中，key值用于惟一地标识元素。

3. 在内部,unordered_set没有对key按照任何特定的顺序排序, 为了能在常数范围内找到key，unordered_set将相同哈希值的key放在相同的桶中。

4. unordered_set容器通过key访问单个元素要比set快，但它通常在遍历元素子集的范围迭代方面效率较低。

5. 它的迭代器是前向迭代器。

1.1.2.unordered_set的使用

此处只简单演示unordered_set与set的不同，其他接口与set相同，可参考set。

（1）set中的迭代器是双向迭代器，因此set中有begin、end、rbegin、rend函数。unordered_set中的迭代器是单向迭代器，因此unordered_set中有begin、end函数而没有rbegin、rend函数。

（2）set遍历访问的数据是有序的，unordered_set遍历访问的数据是无序的。

（3）set底层是红黑树，其搜索效率为，unordered_set底层是哈希，其搜索效率为O(1)，如下面代码所示

注：rand函数产生的随机数其实是有限制的，c语言rand函数有一个RAND_MAX，其最大只能产生三万多个随机数，因此如果上面的n值很大时，重复的数据是很多的，打印出来的size值（不重复的值）远小于n值。如果想让随机数变得更多可以如下图所示，给rand函数+循环变量i。

1.2.unordered_map

1.2.1.unordered_map的介绍

unordered_map类的文档介绍： unordered_map - C++ Reference (cplusplus.com)

注：

1. unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。

2. 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此

键关联。键和映射值的类型可能不同。

3. 在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。

4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。

5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问

value。

6. 它的迭代器是前向迭代器。

1.2.2.unordered_map的使用

此处只简单演示unordered_map与map的不同，其他接口与map相同，可参考map。

（1）map中的迭代器是双向迭代器，因此map中有begin、end、rbegin、rend函数。unordered_map中的迭代器是单向迭代器，因此unordered_map中有begin、end函数而没有rbegin、rend函数。

（2）map遍历访问的数据是有序的，unordered_map遍历访问的数据是无序的。

（3）map底层是红黑树，其搜索效率为，unordered_map底层是哈希，其搜索效率为O(1)。 

1.3.unordered_multiset和unordered_multimap

unordered_multiset和multiset用法及功能基本相同，unordered_multimap和multimap用法及功能基本相同，下面讲解unordered_multiset、unordered_multimap和multiset、multimap的不同：

（1）multiset、multimap中的迭代器是双向迭代器，因此multiset、multimap中有begin、end、rbegin、rend函数。unordered_multiset、unordered_multimap中的迭代器是单向迭代器，因此unordered_multiset、unordered_multimap中有begin、end函数而没有rbegin、rend函数。

（2）multiset、multimap遍历访问的数据是有序的，unordered_multiset、unordered_multimap遍历访问的数据是无序的。

（3）multiset、multimap底层是红黑树，其搜索效率为，unordered_multiset、unordered_multimap底层是哈希，其搜索效率为O(1)。 

---

2.底层结构

unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。

2.1.哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度为 ，时间复杂度为 ，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素

根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。

搜索元素

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置

取元素比较，若关键码相等，则搜索成功。

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快

问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

2.2.哈希冲突

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

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

发生哈希冲突该如何处理呢？

2.3.哈希函数

引起哈希冲突的一个原因可能是： 哈希函数设计不够合理。

哈希函数设计原则：

哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间

哈希函数计算出来的地址能均匀分布在整个空间中

哈希函数应该比较简单

常见哈希函数：

1.直接定址法(常用)

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B

优点：简单、均匀

缺点：需要事先知道关键字的分布情况

使用场景：适合查找比较小且连续的情况

面试题： 387. 字符串中的第一个唯一字符 - 力扣（LeetCode）

2.除留余数法(常用)

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，

按照哈希函数：Hash(key) = key%p(p<=m),将关键码转换成哈希地址

3.平方取中法(了解)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；

再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址

平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

4.折叠法(了解)

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这

几部分叠加求和，并按散列表表长，取后几位作为散列地址。

折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

5.随机数法(了解)

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中

random为随机数函数。

通常应用于关键字长度不等时采用此法

6.数学分析法(了解)

设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定

相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只

有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散

列地址。例如：

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同

的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还

可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移

位、前两数与后两数叠加(如1234改成12+34=46)等方法。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的

若干位分布较均匀的情况

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

2.4.哈希冲突解决

解决哈希冲突两种常见的方法是： 闭散列和 开散列

2.4.1.闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个”空位置中去。那如何寻找下一个空位置呢？有 线性探测和 二次探测两种方法。

1. 线性探测

比如2.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，

因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

线性探测 找下一个空位置的方法 为：Hi= (H0+i)%m 或者 Hi=(H0-i)%m，其中：i = 1,2,3…，H0是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置，m是表 的大小。

插入：

通过哈希函数获取待插入元素在哈希表中的位置

如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

线性探测优点：实现非常简单

线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即不同

关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降

低。如何缓解呢？使用二次探测可以缓解。

2. 二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位

置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题。

二次探测 ：从发生冲突的位置开始，跳跃向后探测，直到寻找到下一个空位置为止。

二次探测找下一个空位置的方法 为：Hi= (H0+i^2)%m 或者 Hi=(H0-i^2)%m，其中：i = 1,2,3…，H0是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置，m是表 的大小。

插入：

通过哈希函数获取待插入元素在哈希表中的位置

如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用二次探测找到下一个空位置，插入新元素

二次探测的优缺点：二次探测相对线性探测而言减轻了产生数据的“堆积”，但是其本质还是让不同的关键码占据了本属于其他关键码的位置，这样哈希冲突越多，搜索效率还是会降低。

基于线性探测和 二次探测的哈希表 代码实现

HashTable.h文件：

#pragma once
#include

namespace CloseHash
{
	enum State
	{
		EMPTY,
		EXITS,
		DELETE
	};

	template
	struct HashData
	{
		pair _kv;
		State _state = EMPTY;
	};

	template
	struct DefaultHash
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	template<>
	struct DefaultHash
	{
		size_t operator()(const string& key)
		{
			// BKDR
			size_t hash = 0;
			for (auto ch : key)
			{
				hash = hash * 131 + ch;
			}

			return hash;
		}
	};

	template>
	class HashTable
	{
		typedef HashData Data;
	public:
		bool Insert(const pair& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}

			// 负载因子到0.7及以上，就扩容
			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
			{
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				// 扩容以后，需要重新映射
				HashTable newHT;
				newHT._tables.resize(newSize);
				// 遍历旧表，插入newHT
				for (auto& e : _tables)
				{
					if (e._state == EXITS)
					{
						newHT.Insert(e._kv);
					}
				}
				newHT._tables.swap(_tables);
			}

			HashFunc hf;
			size_t starti = hf(kv.first);
			starti %= _tables.size();

			size_t hashi = starti;
			size_t i = 1;
			// 线性探测/二次探测
			while (_tables[hashi]._state == EXITS)
			{
				hashi = starti + i;
				++i;
				hashi %= _tables.size();
			}

			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXITS;
			_n++;

			return true;
		}

		Data* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}

			HashFunc hf;
			size_t starti = hf(key);
			starti %= _tables.size();

			size_t hashi = starti;
			size_t i = 1;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}

				hashi = starti + i;
				++i;
				hashi %= _tables.size();
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			Data* ret = Find(key);
			if (ret)
			{
				ret->_state = DELETE;
				--_n;
				return true;
			}
			else
			{
				return false;
			}
		}

	private:
		vector _tables;
		size_t _n = 0; // 存储关键字个数
	};
}

注：

1.查找元素x时，首先通过哈希函数获取待插入元素在哈希表中的位置，如果该位置是元素x则找到了，如果该位置不是元素x，则使用对应的探索方式（线性探索或二次探测）依次往后找下一个位置是否是x，如果某一次找到的位置是x则找到了，如果某一次找到的位置是空则找不到。

2.采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。如下图一所示，删除元素4，如果直接删除掉，后面44查找起来可能会受影响。因此应该采用标记的伪删除法来删除一个元素，如下图二所示一个元素有三种状态，要删除某个元素时只改变该元素的状态为DELETE，不删除该元素。

 

3.如下图所示，在插入函数中，我们使用无符号整型starti来获取对应的值，进而通过哈希函数计算得到要插入的位置。这里哈希函数中，应该用starti去模顺序表vector的size而不是capacity，因为顺序表vector是不能在大于size的位置插入数据的，如果是starti模capacity，得到的结果刚好大于size，是无法插入的。

在插入时，如果哈希函数计算得到位置的状态为空EMPTY或者删除DELETE时，可以进行插入，如果哈希函数计算得到位置的状态为存在EXITS时，则继续探索下一个位置，直到探索到的位置状态为空或删除时再进行插入。

思考：哈希表什么情况下进行扩容？如何扩容？

哈希表HashTable类中，我们利用成员变量_n来记录存储关键字的个数，每次插入一个元素对成员变量_n++，如果_n除以哈希表_tables的大小大于等于0.7则进行扩容。

代码_n/_tables.size()>=0.7是有问题的，因为_n和_tables.size()的返回值都是无符号整型的，应该将其强转成浮点型，这里我们不强转，可以用代码_n*10/_tables.size()>=7间接实现该功能。

哈希表的扩容不是简单的进行扩容，而是应该根据要扩容的大小重新创建一个vector，根据新vector的size大小即扩容后的大小，重新计算原来每一个元素的位置并插入到新vector中，然后释放旧vector。

这里我们可以使用一种简单的方式来实现，创建一个新的哈希表HashTable类对象，遍历旧的vector，将遍历到的每个数据插入到新的哈希表HashTable类对象中，这样在插入的过程中就自动根据扩容后的大小算好了旧表元素在新表中的位置并进行插入操作。最后将新哈希表HashTable类中的vector和我们本身的vector进行交换即可，代码如下图所示。

上面的插入函数代码没有去除数据冗余，适合于multiset和multimap类，在插入时我们可以复用find函数去除数据冗余，这样就适合于set和map类，如下图所示。

4.根据哈希表HashTable插入函数的特点，我们可以知道，哈希表的插入函数效率变化图应该类似于下图所示，正常情况下插入的很快，当某一次插入需要扩容时，效率变得很慢，因为这里扩容不仅仅是空间上进行扩容，每个元素还需要重新进行映射位置，因此时间上也会有损耗。

这就是前面验证set和unordered_set插入、查找、删除效率时，当重复数据多时unordered_set插入效率很高、当重复数据少时unordered_set插入效率低的原因。因为重复数据多时数据量小扩容少，重复数据多时，数据量大扩容多。

5.哈希表HashTable的find查找函数首先通过哈希函数计算出查找数据的位置，如果该位置元素状态不是空并且是要查找的数据则返回该元素的地址，如果该位置元素状态不是空但不是要查找的数据，则依次探索下一个位置，直到探索到某元素状态不是空并且是要查找的数据，返回该元素地址，如果遇到探索位置元素状态为空，则没有要查找的元素返回空指针，代码如下图所示。

上面的代码还有两个问题。第一个问题，如果哈希表为空即_table.size=0，则有starti模0的问题。第二个问题是删除的元素还能被找到，因此我们还需要加一个元素状态不为DELETE的判断。解决两个问题的find函数改进代码如下图所示。

6.哈希表HashTable的erase删除函数只需要复用find函数找到要删除的元素位置，如果找到了要删除的元素位置则将该元素的状态改为DELET进行伪删除并返回true，如果没找到要删除的元素位置则返回false，如下图所示。

7.哈希表HashTable的模板参数K和V的类型不确定，也就是哈希表存储的键值对数据pair的first和second数据类型不确定。参数K的类型不确定，如果我们直接使用size_t starti = kv.first获取插入的值，然后哈希函数计算位置，这样只适合于整型，面对字符串、自定义对象或更复杂的情况如何解决呢？

在哈希表HashTable的模板参数中传一个仿函数类来解决，那么使用者使用哈希表HashTable什么类型的模板参数K，就传对应类型的仿函数类即可，如下图所示。仿函数类对象实现把key元素转换成映射的整数，其中不同的元素尽可能转换成不同的整数（如果不同的元素转换成了相同的整数，那么就会造成访问冲突，访问冲突越多哈希表效率越低）。

我们使用DefaultHash仿函数类作为默认的仿函数类解决参数K为整型的情况如下图所示，如果参数K为整型直接返回对应的整型值即可。

我们使用StringHash仿函数类解决参数K为string类的情况如下图一所示，如果参数K为string类，将字符串每个字符的ASCII码加起来进行返回即可。

博客：各种字符串Hash函数 - clq - 博客园 (cnblogs.com)中提到了很多种更加优秀的匹配string类的仿函数，降低了不同元素转换成相同整数的可能，减少了访问冲突。我们使用其中《The C Programming Language》的方案，如下图二所示。

 

如果是Student类，仿函数类可以返回学号、身份证、电话号码等，如果没有这些唯一项信息，可以多项拼接，例如班级+名字。

8.库里面的unorder_set、unorder_map、unorder_multiset、unorder_multimap即使是sring类也不需要显式的传仿函数类，如下图一所示，这是因为源代码对默认的仿函数类DefaultHash进行了特化，如下图所示二。

9.哈希表HashTable类中不需要专门去写构造函数、析构函数、拷贝构造函数、赋值运算符重载函数。

补充内容：研究表明当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

2.4.2 开散列

1. 开散列概念

开散列法又叫链地址法(开链法)（哈希桶），首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

如下图所示，数据不存在哈希表中，哈希表中存储的是链表指针，冲突的数据以链表的形式挂起来。开散列中每个桶中放的都是发生哈希冲突的元素。

开散列中使用单链表即可，因为每个桶中的元素顺序没有要求，每次插入元素头插即可，并且单链表中少存一个指针，空间占有更少。

2. 开散列实现

HashTable.h文件：

#pragma once
#include

template
struct DefaultHash
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};


template<>
struct DefaultHash
{
	size_t operator()(const string& key)
	{
		// BKDR
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;
		}

		return hash;
	}
};

namespace Bucket
{
	template
	struct HashNode
	{
		pair _kv;
		HashNode* _next;

		HashNode(const pair& kv)
			:_kv(kv)
			, _next(nullptr)
		{}
	};

	template>
	class HashTable
	{
		typedef HashNode Node;
	public:
		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}

				_tables[i] = nullptr;
			}
		}

		bool Insert(const pair& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}

			HashFunc hf;

			// 负载因子 == 1 扩容
			if (_tables.size() == _n)
			{
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector newTable;
				newTable.resize(newSize, nullptr);
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hf(cur->_kv.first) % newSize;
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

				newTable.swap(_tables);
			}

			size_t hashi = hf(kv.first);
			hashi %= _tables.size();

			// 头插到对应的桶即可
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

			++_n;

			return true;
		}

		Node* Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}

			HashFunc hf;
			size_t hashi = hf(key);
			//size_t hashi = HashFunc()(key);

			hashi %= _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}

				cur = cur->_next;
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return false;
			}

			HashFunc hf;
			size_t hashi = hf(key);
			hashi %= _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}

					delete cur;

					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}

	private:
		// 指针数组
		vector _tables;
		size_t _n = 0;
	};
}

注：

1.开散列哈希表的insert插入函数，也是首先通过哈希函数计算出要插入元素的位置，如果哈希表vector中该位置桶不为空，则新元素节点头插到该桶中即可，如果哈希表vector中该位置桶为空，则让哈希表vector中该位置桶指针指向新元素节点，新元素节点指向空即可。其实上面两种情况可以用同一段代码解决，如下图所示。

开散列的哈希表也需要扩容，如果开散列哈希表不扩容，那么可能存在大量的哈希冲突，每个桶中的链表过长影响效率。开散列的哈希表负载因子可以大一点（负载因子小冲突概率小时间效率高空间效率低，负载因子大冲突概率大时间效率低空间效率高），因为开散列处理哈希冲突直接头插即可效率较高，我们取负载因子为1，下面代码当_tables.size()==_n时扩容，就相当于负载因子为1时扩容。扩容方式可以采取和闭散列相同的扩容方式，如下图所示。

上面这种开散列扩容方式和闭散列扩容方式相同，但是开散列使用这种方式是有缺陷的，开散列使用这种方式那么之前哈希表每个桶中的节点将被释放掉不再使用，然后创建完全相同的节点挂在新的哈希表上。我们在扩容的时候其实不需要创建新的节点而是使用原本的节点即可，如下图所示。

2.开散列哈希表的find查找函数，首先通过哈希函数计算出要插入元素的位置，然后遍历该位置的桶中是否有要找元素，找到对应元素返回该元素节点指针，如果没有找到则返回空指针。如果哈希表最开始里面没有数据时，返回空指针，如下图所示。

3.开散列哈希表的~HashTable析构函数，开散列哈希表需要显式的写析构函数，因为如果使用系统自动生成的析构函数，那么系统会去自动调用vector的析构函数释放指针数组成员变量_tables，但是每个桶中的节点空间并不会自动去释放，造成空间泄漏。因此我们应该显式的写析构函数将每个桶中节点空间释放掉。这样自己写的析构函数将桶结点空间释放掉，系统自动调用vector析构函数将指针数组成员变量_tables空间释放掉。

4.开散列哈希表的Erase删除函数，其正常代码实现如下图所示。

5.开散列哈希表的构造函数不需要显式的写，析构函数需要显式的写，拷贝构造函数和赋值运算符重载函数需要显示的写进行深拷贝（如果不写会调用vector的拷贝构造和赋值运算符重载，vector的拷贝构造和赋值运算符重载是深拷贝，vector里面的数据如果是自定义类型，就会去调用对应的拷贝构造函数，这里vector里面的数据是node*类型，也就是指针类型，是内置类型，对于内置类型vector的拷贝构造和赋值运算符重载是进行浅拷贝，那么拷贝的vector和原vector中的指针数据会指向同一个桶）。这里开散列哈希表的拷贝构造函数和赋值运算符重载函数实现我们不再赘述。

6.和闭散列相同，为了让开散列哈希表支持字符串、自定义对象或更复杂的情况，我们增加一个开散列哈希表HashTable模板参数HashFunc，其缺省值给成DefaultHash，如下图所示。

和闭散列相同，使用DefaultHash仿函数类作为默认的仿函数类，解决参数K为整型的情况，特化一个版本来解决参数K为string类的情况，这里不再赘述。

---

3.哈希开散列模拟实现STL中的unordered_map与unordered_set

3.1.封装开散列代码，同时实现unordered_map和unordered_set

将开散列进行封装，使之可以同时实现unordered_map和unordered_set

这里与对红黑树RBTree进行封装，使之可以同时实现map和set的思路相同。我们将开散列哈希表中每个桶节点HashNode的数据泛化成其模板参数T类型的成员变量_data，开散列哈希表HashTable的模板参数改为K、T和HashFunc，如下图一所示。

如果是unordered_map，那么哈希表HashTable的第一个模板参数传K，第二个模板参数传pair。如果是unordered_set，那么哈希表HashTable的第一个模板参数传K，第二个模板参数传K。

在unordered_map和unordered_set中，使用开散列哈希表HashTable创建对象，除了第一个模板参数和第二个模板参数传对应的类型外，还需要传MapKeyOfT和SetKeyOfT仿函数类作为key值提取函数，哈希表HashTable的模板参数也同时加上一个KeyOfT参数来获取仿函数类如下图所示。

哈希表HashTable的模板参数HashFunc是一个仿函数类，默认传的是DefaultHash仿函数类，解决K是整型的情况，还有一个特化版本，解决K是string类的情况。如果K是自定义类型的，例如是日期Date类型的，就需要我们自己去传仿函数类给哈希表的模板HashFunc参数。

但是我们使用时只能给unordered_map和unordered_set传模板参数而无法直接给哈希表HashTable传模板参数，所以我们应该给unordered_map和unordered_set加一个模板参数HashFunc来获取用户传的哈希函数，然后unordered_map和unordered_set内部调用哈希表HashTable时再将用户传的哈希函数传给哈希表HashTable即可，如下图所示。

3.2.开散列哈希表的迭代器

unordered_set类代码：

#pragma once

#include "HashTable.h"

namespace bit
{
	template>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename Bucket::HashTable::iterator iterator;

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

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

		pair insert(const K& key)
		{
			return _ht.Insert(key);
		}

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

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}
	private:
		Bucket::HashTable _ht;
	};

	struct Date
	{
		Date(int year = 1, int month = 1, int day = 1)
			:_year(year)
			, _month(month)
			, _day(day)
		{}

		bool operator==(const Date& d) const
		{
			return _year == d._year
				&& _month == d._month
				&& _day == d._day;
		}

		int _year;
		int _month;
		int _day;
	};

	struct DateHash
	{
		size_t operator()(const Date& d)
		{
			//return d._year + d._month + d._day;
			size_t hash = 0;
			hash += d._year;
			hash *= 131;
			hash += d._month;
			hash *= 1313;
			hash += d._day;

			//cout << hash << endl;

			return hash;
		}
	};

	void test_set()
	{
		unordered_set s;
		s.insert(2);
		s.insert(3);
		s.insert(1);
		s.insert(2);
		s.insert(5);
		s.insert(12);

		//unordered_set::iterator it = s.begin();
		unordered_set::iterator it;
		it = s.begin();

		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;


		for (auto e : s)
		{
			cout << e << " ";
		}
		cout << endl;

		unordered_set sd;
		sd.insert(Date(2022, 3, 4));
		sd.insert(Date(2022, 4, 3));
	}
}

unordered_map类代码：

#pragma once

#include "HashTable.h"

namespace bit
{
	template>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename Bucket::HashTable, MapKeyOfT, HashFunc>::iterator iterator;

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

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

		pair insert(const pair& kv)
		{
			return _ht.Insert(kv);
		}

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

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

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

	private:
		Bucket::HashTable, MapKeyOfT, HashFunc> _ht;
	};

	void test_map()
	{
		unordered_map dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("left", "左边"));
		dict.insert(make_pair("left", "剩余"));
		dict["string"];
		dict["left"] = "剩余";
		dict["string"] = "字符串";

		unordered_map::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first << " " << it->second << endl;
			++it;
		}

		cout << endl;

		for (auto& kv : dict)
		{
			cout << kv.first << " " << kv.second << endl;
		}
	}
}

开散列哈希表迭代器部分代码：

template
class __HTIterator
{
	typedef HashNode Node;
	typedef __HTIterator Self;
public:
	Node* _node;
	HashTable* _pht;

	__HTIterator() {}

	__HTIterator(Node* node, HashTable* pht)
		:_node(node)
		, _pht(pht)
	{}

	Self& operator++()
	{
		if (_node->_next)
		{
			_node = _node->_next;
		}
		else
		{
			KeyOfT kot;
			HashFunc hf;
			size_t hashi = hf(kot(_node->_data)) % _pht->_tables.size();
			++hashi;
			//找下一个不为空的桶
			for (; hashi < _pht->_tables.size(); ++hashi)
			{
				if (_pht->_tables[hashi])
				{
					_node = _pht->_tables[hashi];
					break;
				}
			}

			// 没有找到不为空的桶，用nullptr去做end标识
			if (hashi == _pht->_tables.size())
			{
				_node = nullptr;
			}
		}

		return *this;
	}

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

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

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

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

注：

1.开散列哈希表迭代器__HTIterator需要一个指针成员变量_node和一个哈希表指针成员变量_pht，指针成员变量_node标识此时迭代器走到的位置，哈希表指针成员变量_pht负责支持实现哈希表迭代器的++功能。

2.哈希表迭代器__HTIterator中实现operator++运算符重载函数，如果迭代器的指针成员变量_node指向节点的下一个节点不是空，则_node=_node->_next指向下一个节点，如果迭代器的指针成员变量_node指向节点的下一个节点是空，则计算此时的桶号hashi，然后往后遍历找到下一个不为空的桶，如果找到了下一个不为空的桶，让_node指向该不为空的桶的第一个节点，如果没找到下一个不为空的桶，也就是后面的桶全为空，那么就给_node赋值为空标识走到了end。

3.哈希表HashTable中begin函数需要找到第一个不为空的桶的第一个节点，找到节点的指针作为_node，this指针指向的哈希表地址正好作为_pht，生成哈希表的迭代器，返回该哈希表的迭代器。如果哈希表为空即找不到第一个不为空的桶则返回end。哈希表HashTable中end函数返回迭代器的_node我们用空指针来标识。begin函数和end函数如下图所示

4.哈希表迭代器__HTIterator中operator*、operator->、operator!=和operator==代码实现如下图所示

5.在unordered_map和unordered_set中要将哈希表的迭代器类型重定义iterator作为自己的迭代器，然后修改并复用哈希表的begin、end、Insert、Find、Erase函数来实现自己的begin、end、insert、find、erase函数功能，并且unordered_map中要复用自己的insert函数实现operator[]运算符重载函数，如下图所示。

这里哈希表的迭代器进行类型重定义时要用typename修饰，原因和红黑树封装map和set那里相同，这里不再赘述。

6.哈希表迭代器__HTIterator中使用了哈希表指针成员变量_pht，而编译器遵循向上查找原则，哈希表是在哈希表迭代器的后面定义的，那么要在哈希表迭代器的前面对哈希表进行声明，如下图所示

7.哈希表迭代器__HTIterator中找下一个不为空的桶时要访问哈希表的私有成员变量_tables，因此我们要将哈希表迭代器设置成哈希表的友元，这里哈希表迭代器__HTIterator和哈希表HashTable都是类模板，类模板要设置友元要加上模板参数部分，如下图所示

3.3.开散列哈希表容量为素数的优化

很多研究证明，哈希表的容量如果是一个素数可以有效降低哈希冲突的概率。

如何保证每一次扩容扩容后的结果都是素数呢？我们观察STL源码中是如何解决的。

如下图所示，源码中给了一个静态的素数表，素数表中每一个数都是素数且后一个数约是前一个数的两倍。

在我们的实现中可以增加一个GetNextPrime函数，找比当前素数值大的下一个素数，用来当作哈希表扩容的大小。其中每个素数后面跟着ul，ul是unsigned long代表该素数是unsigned long类型的。

3.4.开散列哈希表模拟实现STL中unordered_map和unordered_set的代码

UnorderedSet.h文件：

#pragma once

#include "HashTable.h"

namespace bit
{
	template>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename Bucket::HashTable::iterator iterator;

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

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

		pair insert(const K& key)
		{
			return _ht.Insert(key);
		}

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

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}
	private:
		Bucket::HashTable _ht;
	};

	struct Date
	{
		Date(int year = 1, int month = 1, int day = 1)
			:_year(year)
			, _month(month)
			, _day(day)
		{}

		bool operator==(const Date& d) const
		{
			return _year == d._year
				&& _month == d._month
				&& _day == d._day;
		}

		int _year;
		int _month;
		int _day;
	};

	struct DateHash
	{
		size_t operator()(const Date& d)
		{
			//return d._year + d._month + d._day;
			size_t hash = 0;
			hash += d._year;
			hash *= 131;
			hash += d._month;
			hash *= 1313;
			hash += d._day;

			//cout << hash << endl;

			return hash;
		}
	};

	void test_set()
	{
		unordered_set s;
		s.insert(2);
		s.insert(3);
		s.insert(1);
		s.insert(2);
		s.insert(5);
		s.insert(12);

		//unordered_set::iterator it = s.begin();
		unordered_set::iterator it;
		it = s.begin();

		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;


		for (auto e : s)
		{
			cout << e << " ";
		}
		cout << endl;

		unordered_set sd;
		sd.insert(Date(2022, 3, 4));
		sd.insert(Date(2022, 4, 3));
	}
}

UnorderedMap.h文件：

#pragma once

#include "HashTable.h"

namespace bit
{
	template>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename Bucket::HashTable, MapKeyOfT, HashFunc>::iterator iterator;

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

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

		pair insert(const pair& kv)
		{
			return _ht.Insert(kv);
		}

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

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

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

	private:
		Bucket::HashTable, MapKeyOfT, HashFunc> _ht;
	};

	void test_map()
	{
		unordered_map dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("left", "左边"));
		dict.insert(make_pair("left", "剩余"));
		dict["string"];
		dict["left"] = "剩余";
		dict["string"] = "字符串";

		unordered_map::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first << " " << it->second << endl;
			++it;
		}

		cout << endl;

		for (auto& kv : dict)
		{
			cout << kv.first << " " << kv.second << endl;
		}
	}
}

HashTable.h文件：

#pragma once
#include

template
struct DefaultHash
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};


template<>
struct DefaultHash
{
	size_t operator()(const string& key)
	{
		// BKDR
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;
		}

		return hash;
	}
};

namespace Bucket
{
	template
	struct HashNode
	{
		T _data;
		HashNode* _next;

		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};

	template
	class HashTable;

	template
	class __HTIterator
	{
		typedef HashNode Node;
		typedef __HTIterator Self;
	public:
		Node* _node;
		HashTable* _pht;

		__HTIterator() {}

		__HTIterator(Node* node, HashTable* pht)
			:_node(node)
			, _pht(pht)
		{}

		Self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				KeyOfT kot;
				HashFunc hf;
				size_t hashi = hf(kot(_node->_data)) % _pht->_tables.size();
				++hashi;
				//找下一个不为空的桶
				for (; hashi < _pht->_tables.size(); ++hashi)
				{
					if (_pht->_tables[hashi])
					{
						_node = _pht->_tables[hashi];
						break;
					}
				}

				// 没有找到不为空的桶，用nullptr去做end标识
				if (hashi == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}

			return *this;
		}

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

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

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

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

	// unordered_map ->HashTable, MapKeyOfT> _ht;
	// unordered_set ->HashTable _ht;
	template
	class HashTable
	{
		template
		friend class __HTIterator;

		typedef HashNode Node;
	public:
		typedef __HTIterator iterator;

		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				Node* cur = _tables[i];
				if (cur)
				{
					return iterator(cur, this);
				}
			}

			return end();
		}

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

		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}

				_tables[i] = nullptr;
			}
		}

		size_t GetNextPrime(size_t prime)
		{
			const int PRIMECOUNT = 28;
			static const size_t primeList[PRIMECOUNT] =
			{
				53ul, 97ul, 193ul, 389ul, 769ul,
				1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
				49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
				1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
				50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
				1610612741ul, 3221225473ul, 4294967291ul
			};

			// 获取比prime大那一个素数
			size_t i = 0;
			for (; i < PRIMECOUNT; ++i)
			{
				if (primeList[i] > prime)
					return primeList[i];
			}

			return primeList[i];
		}

		pair Insert(const T& data)
		{
			HashFunc hf;
			KeyOfT kot;

			iterator pos = Find(kot(data));
			if (pos != end())
			{
				return make_pair(pos, false);
			}

			// 负载因子 == 1 扩容
			if (_tables.size() == _n)
			{
				//size_t newSize = _tables.size() == 0 ? 11 : _tables.size() * 2;
				size_t newSize = GetNextPrime(_tables.size());
				if (newSize != _tables.size())
				{
					vector newTable;
					newTable.resize(newSize, nullptr);
					for (size_t i = 0; i < _tables.size(); ++i)
					{
						Node* cur = _tables[i];
						while (cur)
						{
							Node* next = cur->_next;

							size_t hashi = hf(kot(cur->_data)) % newSize;
							cur->_next = newTable[hashi];
							newTable[hashi] = cur;

							cur = next;
						}

						_tables[i] = nullptr;
					}

					newTable.swap(_tables);
				}
			}

			size_t hashi = hf(kot(data));
			hashi %= _tables.size();

			// 头插到对应的桶即可
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

			++_n;

			return make_pair(iterator(newnode, this), false);;
		}

		iterator Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return iterator(nullptr, this);
			}

			KeyOfT kot;
			HashFunc hf;
			size_t hashi = hf(key);
			//size_t hashi = HashFunc()(key);

			hashi %= _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur, this);
				}

				cur = cur->_next;
			}

			return iterator(nullptr, this);
		}

		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return false;
			}

			HashFunc hf;
			KeyOfT kot;
			size_t hashi = hf(key);
			hashi %= _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}

					delete cur;

					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}

	private:
		// 指针数组
		vector _tables;
		size_t _n = 0;
	};
}

test.cpp文件：

#include
#include 
#include 

---

4.哈希的应用

4.1.位图

4.1.1.位图概念

面试题：给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。

方法一：遍历，时间复杂度O(N)

方法二：先排序：NlogN，后二分查找: logN，时间复杂度O(NlogN)

方法三：位图解决

数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一

个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0

代表不存在。比如：

因为数据集中是无符号整数，无符号整数的最大值为0xffffffff，大约为四十二亿九千万，所以开四十二亿九千万个比特位空间作为位图空间，四十二亿九千万个比特位空间是500M内存空间。遍历数据集中40亿个不重复的无符号整数，将每一个无符号整数对应位图的那个比特位由0改成1。这样判断任意一个给定的无符号整数是否在数据集中只需要判断给定的无符号整数对应位图的那个比特位是否为1即可，为1则给定的无符号整数在数据集中，为0则给定的无符号整数不在数据集中。

注：

1.STL库中的bitset就是位图数据结构，如下图所示，其核心接口有test、set、reset。

2.位图只能处理整型数据，无法处理浮点数据以及字符串数据等。

4.1.2.位图的实现

BitSet.h文件：

#pragma once
#include 

namespace bit
{
	// N个比特位的位图  10  16
	template
	class bitset
	{
	public:
		bitset()
		{
			// +1保证足够比特位，最多浪费8个
			_bits.resize(N / 8 + 1, 0);
		}

		//x映射的位标记成1
		void set(size_t x)
		{
			// x映射的比特位在第几个char对象
			size_t i = x / 8;

			// x在char第几个比特位
			size_t j = x % 8;

			_bits[i] |= (1 << j);
		}

		void reset(size_t x)
		{
			// x映射的比特位在第几个char对象
			size_t i = x / 8;

			// x在char第几个比特位
			size_t j = x % 8;

			_bits[i] &= (~(1 << j));
		}

		bool test(size_t x)
		{
			// x映射的比特位在第几个char对象
			size_t i = x / 8;

			// x在char第几个比特位
			size_t j = x % 8;

			return _bits[i] & (1 << j);
		}

	private:
		std::vector _bits;
		//vector _bits;
	};

	void test_bit_set1()
	{
		bitset<100> bs;
		bs.set(18);
		bs.set(19);

		cout << bs.test(18) << endl;
		cout << bs.test(19) << endl;
		cout << bs.test(20) << endl;


		bs.reset(18);
		bs.reset(18);

		cout << bs.test(18) << endl;
		cout << bs.test(19) << endl;
		cout << bs.test(20) << endl;


		//开无符号整数最大值的内存空间
		//bitset<0xFFFFFFFF> bigBS;
		//bitset<-1> bigBS;

	}
}

注：

1.编译器无法按照比特位来开空间，要么使用char类型一次开一个字节空间八个比特位，或者使用int类型一次开四个字节空间三十二个比特位，我们这里使用char类型开空间，如下图所示。

2.bitset构造函数，根据模板参数N创建N个比特位的位图，N/8+1是计算N个比特位需要多少个char类型的空间，其中+1保证足够比特位，最多浪费8个，bitset构造函数代码如下图所示。

3.set函数的功能是给定一个无符号整数，将无符号整数对应位图的那个比特位由0改成1，首先size_t i = x / 8计算无符号整数映射的比特位在第i个char对象，然后size_t j = x % 8计算无符号整数映射在char第j个比特位，最后_bits[i] |= (1 << j)将第i个char空间从右往左数第j个比特位置为1即可，代码如下图所示。

4.reset函数的功能是给定一个无符号整数，将无符号整数对应位图的那个比特位由1改成0，首先size_t i = x / 8计算无符号整数映射的比特位在第i个char对象，然后size_t j = x % 8计算无符号整数映射在char第j个比特位，最后_bits[i] &= (~(1 << j))将第i个char空间从右往左数第j个比特位置为0即可，代码如下图所示。

5.test函数的功能是判断给定的一个无符号整数在不在，也就是判断给定的一个无符号整数对应位图的那个比特位是1还是0，是1则返回true，是0则返回false。首先size_t i = x / 8计算无符号整数映射的比特位在第i个char对象，然后size_t j = x % 8计算无符号整数映射在char第j个比特位，最后返回_bits[i] & (1 << j)，代码如下图所示。

4.1.3.位图的应用

1. 快速查找某个数据是否在一个集合中

2. 排序 + 去重

3. 求两个集合的交集、并集等

4. 操作系统中磁盘块标记

4.2.布隆过滤器

4.2.1.布隆过滤器提出

我们在使用新闻客户端看新闻时，它会给我们不停地推荐新的内容，它每次推荐时要去重，去掉那些已经看过的内容。问题来了，新闻客户端推荐系统如何实现推送去重的？ 用服务器记录了用户看过的所有历史记录，当推荐系统推荐新闻时会从每个用户的历史记录里进行筛选，过滤掉那些已经存在的记录。 如何快速查找呢？

1. 用哈希表存储用户记录，缺点：浪费空间。

2. 用位图存储用户记录，缺点：位图一般只能处理整形，如果内容编号是字符串，就无法处理了。

3. 将哈希与位图结合，即布隆过滤器。

4.2.2.布隆过滤器概念

布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存在”，它是用多个哈希函数，将一个数据映射到位图结构中。此种方式不仅可以提升查询效率，也可以节省大量的内存空间。

注：

1.布隆过滤器同时使用多个哈希函数进行映射，一个数据映射多个位置，这样即使某个哈希函数存在哈希冲突，也不会误判，只有所有哈希函数同时哈希冲突才会误判，误判概率较低。

2.布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特位一定为1。所以可以按照以下方式进行查找：分别计算每个哈希值对应的比特位置存储的是否为零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。

注意：布隆过滤器如果说某个元素不存在时，该元素一定不存在，如果该元素存在时，该元素可能存在，因为有些哈希函数存在一定的误判。

比如：在布隆过滤器中查找"alibaba"时，假设3个哈希函数计算的哈希值为：1、3、7，刚好和其他元素的比特位重叠，此时布隆过滤器告诉该元素存在，但实该元素是不存在的。

3.布隆过滤器误判概率较低，但也有误判的可能性，所以如果一个数据经过所有哈希函数映射的多个位置都是1，也只能推出该数据可能存在，如果一个数据经过所有哈希函数映射的多个位置有0，可以推出该数据一定不存在。

4.布隆过滤器同时使用多个哈希函数进行映射，哈希函数使用的越多误判概率越低，但空间消耗越高。博客 详解布隆过滤器的原理，使用场景和注意事项 - 知乎 (zhihu.com)中介绍了如何选取哈希函数个数，来平衡误判和空间消耗的问题。

在该博客中提到哈希函数个数k、布隆过滤器长度m和插入元素个数n之间的关系公式，如下图所示，如果满足该公式则可以达到较好的性能。

4.2.3.布隆过滤器的实现

BloomFilter.h文件：

#pragma once

namespace bit
{
	struct BKDRHash
	{
		size_t operator()(const string& s)
		{
			// BKDR
			size_t value = 0;
			for (auto ch : s)
			{
				value *= 31;
				value += ch;
			}
			return value;
		}
	};

	struct APHash
	{
		size_t operator()(const string& s)
		{
			size_t hash = 0;
			for (long i = 0; i < s.size(); i++)
			{
				if ((i & 1) == 0)
				{
					hash ^= ((hash << 7) ^ s[i] ^ (hash >> 3));
				}
				else
				{
					hash ^= (~((hash << 11) ^ s[i] ^ (hash >> 5)));
				}
			}
			return hash;
		}
	};

	struct DJBHash
	{
		size_t operator()(const string& s)
		{
			size_t hash = 5381;
			for (auto ch : s)
			{
				hash += (hash << 5) + ch;
			}
			return hash;
		}
	};


	struct JSHash
	{
		size_t operator()(const string& s)
		{
			size_t hash = 1315423911;
			for (auto ch : s)
			{
				hash ^= ((hash << 5) + ch + (hash >> 2));
			}
			return hash;
		}
	};

	template
		class BloomFilter
	{
	public:
		void Set(const K& key)
		{
			size_t hash1 = HashFunc1()(key) % M;
			size_t hash2 = HashFunc2()(key) % M;
			size_t hash3 = HashFunc3()(key) % M;
			size_t hash4 = HashFunc4()(key) % M;

			_bs.set(hash1);
			_bs.set(hash2);
			_bs.set(hash3);
			_bs.set(hash4);
		}

		bool Test(const K& key)
		{
			size_t hash1 = HashFunc1()(key) % M;
			if (_bs.test(hash1) == false)
			{
				return false;
			}

			size_t hash2 = HashFunc2()(key) % M;
			if (_bs.test(hash2) == false)
			{
				return false;
			}

			size_t hash3 = HashFunc3()(key) % M;
			if (_bs.test(hash3) == false)
			{
				return false;
			}

			size_t hash4 = HashFunc4()(key) % M;
			if (_bs.test(hash4) == false)
			{
				return false;
			}

			return true; // 存在误判
		}

	private:
		bitset _bs;
	};

	void TestBloomFilter1()
	{
		// 插入10个值
		BloomFilter<43> bf;

		string a[] = { "苹果", "香蕉", "西瓜", "111111111", "eeeeeffff", "草莓", "休息", "继续", "查找", "set" };

		for (auto& e : a)
		{
			bf.Set(e);
		}

		for (auto& e : a)
		{
			cout << bf.Test(e) << endl;
		}
		cout << endl;

		cout << bf.Test("芒果") << endl;
		cout << bf.Test("string") << endl;
		cout << bf.Test("ffffeeeee") << endl;
		cout << bf.Test("31341231") << endl;
		cout << bf.Test("ddddd") << endl;
		cout << bf.Test("3333343") << endl;

	}

	void TestBloomFilter2()
	{
		srand(time(0));
		const size_t N = 100000;
		BloomFilter<6 * N> bf;

		std::vector v1;
		std::string url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";

		for (size_t i = 0; i < N; ++i)
		{
			v1.push_back(url + std::to_string(1234 + i));
		}

		for (auto& str : v1)
		{
			bf.Set(str);
		}

		std::vector v2;
		for (size_t i = 0; i < N; ++i)
		{
			std::string url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";
			url += std::to_string(999999 + i);
			v2.push_back(url);
		}

		size_t n2 = 0;
		for (auto& str : v2)
		{
			if (bf.Test(str))
			{
				++n2;
			}
		}
		cout << "相似字符串误判率:" << (double)n2 / (double)N << endl;

		std::vector v3;
		for (size_t i = 0; i < N; ++i)
		{
			string url = "zhihu.com";
			url += std::to_string(rand());
			v3.push_back(url);
		}

		size_t n3 = 0;
		for (auto& str : v3)
		{
			if (bf.Test(str))
			{
				++n3;
			}
		}
		cout << "不相似字符串误判率:" << (double)n3 / (double)N << endl;
	}
}

注：
1.布隆过滤器BloomFilter的模板参数由数据类型K、布隆过滤器长度M和多个仿函数类构成，需要多少个哈希函数进行映射模板中就有多少个仿函数类，这里我们使用BKDRHash、APHash、DJBHash三个哈希函数，如下图一所示。布隆过滤器的底层其实是位图，我们使用STL库中的位图bitset来实现，如下图二所示。

2.布隆过滤器BloomFilter的Set函数接口功能是将给定数据根据多个哈希函数映射的对应比特位设置成1，Set函数的实现如下图所示。

3.布隆过滤器BloomFilter的Test函数接口功能是检测给定数据是否存在，即判断定数据根据多个哈希函数映射的对应比特位是否全为1，如果全为1则返回true，如果不全为1则返回false，Test函数的实现如下图所示。这里Test函数即使返回true给定数据也是可能存在，不能确保一定存在。

4.根据前面提到的哈希函数个数k、布隆过滤器长度m和插入元素个数n之间的关系公式，如下图一所示，我们使用3个哈希函数即k=3，如果我们要插入10个数据，那么根据公式布隆过滤器长度m等于43可以达到较好的性能，如下图二所示。

5.因为布隆过滤器BloomFilter的模板参数中参数M是一定需要传的，而参数K大概率是字符串可以给默认缺省值，多个哈希函数都可以给字符串哈希函数的默认缺省，所以我们调整一下顺序将参数M放在第一个，其余参数放在后面给缺省值，使用的时候只需要给参数M即可，如下图所示。

6.如下图所示代码，在TestBloomFilter2中，我们可以改变插入元素个数N，检测相似字符串误判率和不相似字符串误判率。将哈希函数增加到四个并改变插入元素个数N，测相似字符串误判率和不相似字符串误判率，可以看出增加一个哈希函数，误判率整体有所下降，但根据公式k大了布隆过滤器长度大了即开空间就大了空间消耗增加了。

注意如果将哈希函数增加到四个，那么哈希函数个数k为4，插入元素个数N，布隆过滤器长度m应为5.8×N，我们给成6×N。这里如果尝试将6改成更大的值，那么误判率还会有所下降，但是空间消耗会增加。

4.2.4.布隆过滤器删除

布隆过滤器不能直接支持删除工作，因为在删除一个元素时，可能会影响其他元素。

比如：删除上图中"tencent"元素，如果直接将该元素所对应的二进制比特位置0，“baidu”元素也被删除了，因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。

一种支持删除的方法：将布隆过滤器中的每个比特位扩展成一个小的计数器，插入元素时给k个计数器(k个哈希函数计算出的哈希地址)加一，删除元素时，给k个计数器减一。这样每个比特位变成了多个比特位的计数器，通过多占用几倍存储空间（计数器所占空间）的代价来增加删除操作。

缺陷：

1. 无法确认元素是否真正在布隆过滤器中

2. 存在计数回绕（计数溢出后重新从0开始计数）

4.2.5.布隆过滤器优点

1. 增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无关

2. 哈希函数相互之间没有关系，方便硬件并行运算

3. 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势

4. 在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势

5. 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能

6. 使用同一组散列函数的布隆过滤器可以进行交、并、差运算

4.2.6.布隆过滤器缺陷

1. 有误判率，即存在假阳性(False Position)，即不能准确判断元素是否在集合中(补救方法：再建立一个白名单，存储可能会误判的数据)

2. 不能获取元素本身

3. 一般情况下不能从布隆过滤器中删除元素

4. 如果采用计数方式删除，可能会存在计数回绕问题

4.2.7.布隆过滤器应用场景

1.注册的时候，通过布隆过滤器快速判断一个昵称是否使用过。如果不在，那么该昵称没有用过可以使用；如果在，那么大概率昵称使用过，小概率昵称没使用过误判了，如果要确保准确，再去数据库查找确认即可。

2.黑名单，通过布隆过滤器快速判断一个人是否在黑名单中。如果不在，那么该人不在黑名单中可以通行；如果在，那么大概率该人在黑名单中，小概率该人不在黑名单中误判了，如果要确保准确，再去数据库查找确认即可。

注：很多数据系统会生成一个对应的布隆过滤器，查找数据时在布隆过滤器查找，如果在布隆过滤器中，可能存在误判，继续去数据系统中查找，然后返回在或不在，如果不在布隆过滤器中，则直接返回不在。

---

5. 海量数据面试题

5.1.哈希切割

1.给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？

如何找到top K的IP？

思路一：将100G大小的log file文件平均分成100个1G大小的文件A0、A1......A99。内存中创建一个map来记录ip和对应次数，每一次遍历一个文件记录文件中的ip。这种思路有一个问题是如果ip过多导致map过大内存中可能存不下。

思路二：创建一百个小文件A0、A1......A99，依次读取log file文件中的ip，利用哈希函数i=HashFunc(ip)%100，将log file文件中每一个ip通过哈希函数分配到对应序号的小文件中，这样相同的ip一定进入了同一个小文件，这一步骤就叫做哈希切分。然后使用map统计小文件中的ip和对应次数，利用pair记录次数最多的ip和对应次数，map依次遍历每一个小文件遍历完一个小文件后clear清空map再遍历下一个，每一次遍历完一个小文件将本次记录的最多ip次数和pair中的次数比较，如果次数多余pair则更新pair。这样map遍历完全部的100个小文件后pair中的ip就是出现次数最多的IP地址。

如果要找top K的IP，那么将pair换成优先级队列priority_queue,_>(其中_部分是用来比较大小的仿函数)创建一个小堆结构即可。

这个思路有一个缺点就是哈希切分后的100个小文件有的小文件可能很大，有的小文件可能很小，文件大的原因可能是某个相同的ip太多或映射冲突到这个编号文件的ip太多。

解决方法一：可以创建1000个小文件，哈希函数改为i=HashFunc(ip)%1000，该方法不能保证一定解决问题。

解决方法二：如果是相同的ip太多导致的小文件过大，那么map统计时只需要次数++即可，因此这种情况导致的小文件大不会有问题。如果是映射冲突到这个编号文件的ip太多，那么map统计时可能导致map过大，因此这种情况导致的小文件大是有问题的，我们利用try catch进行异常捕获，如果捕获到内存不足的异常说明是这种情况导致的内存不足，可以针对这个小文件再次换个哈希函数，进行哈希切分，再切分成小文件，对小文件依次统计。

5.2.位图应用

1.给定100亿个整数，设计算法找到只出现一次的整数？

答：找在给定的整形数据中只出现一次的整数，可以将整数出现次数标记为出现0次、出现1次、出现2次及以上，刚好是三种状态，那么可以使用两个二进制比特位来代表数据出现次数的信息，如果两个二进制比特位为00，代表出现0次，为01代表出现1次，为10代表出现2次及以上。

因为数据集中是无符号整数，无符号整数的最大值为0xffffffff，大约为四十二亿九千万，所以要开大约为四十二亿九千万×2个比特位空间作为位图空间，四十二亿九千万×2个比特位空间是1G内存空间。

代码实现：

BitSet.h文件：

#pragma once
#include 

namespace bit
{
	// N个比特位的位图  10  16
	template
	class bitset
	{
	public:
		bitset()
		{
			// +1保证足够比特位，最多浪费8个
			_bits.resize(N / 8 + 1, 0);
		}

		//x映射的位标记成1
		void set(size_t x)
		{
			// x映射的比特位在第几个char对象
			size_t i = x / 8;

			// x在char第几个比特位
			size_t j = x % 8;

			_bits[i] |= (1 << j);
		}

		void reset(size_t x)
		{
			// x映射的比特位在第几个char对象
			size_t i = x / 8;

			// x在char第几个比特位
			size_t j = x % 8;

			_bits[i] &= (~(1 << j));
		}

		bool test(size_t x)
		{
			// x映射的比特位在第几个char对象
			size_t i = x / 8;

			// x在char第几个比特位
			size_t j = x % 8;

			return _bits[i] & (1 << j);
		}

	private:
		std::vector _bits;
	};

	template
	class two_bitset
	{
	public:
		void set(size_t x)
		{
			int in1 = _bs1.test(x);
			int in2 = _bs2.test(x);
			if (in1 == 0 && in2 == 0)
			{
				_bs2.set(x);
			}
			else if (in1 == 0 && in2 == 1)
			{
				_bs1.set(x);
				_bs2.reset(x);
			}
		}

		bool is_once(size_t x)
		{
			return _bs1.test(x) == 0 && _bs2.test(x) == 1;
		}

	private:
		bitset _bs1;
		bitset _bs2;
	};

	void test_two_bitset()
	{
		int a[] = { 4, 3, 2, 4, 5, 2, 2, 4, 7, 8, 9, 2, 1,3,7 };
		two_bitset<10> tbs;
		for (auto e : a)
		{
			tbs.set(e);
		}

		for (size_t i = 0; i < 10; ++i)
		{
			if (tbs.is_once(i))
			{
				cout << i << endl;
			}
		}
	}
}

注：

1.我们这里的实现可以用两个bitset来实现two_bitset，每一个无符号整数对应位图的一个比特位，那么使用两个bitset位图一个无符号整数就可以认为对应两个比特位。如下图所示，_bs1位图的比特位代表高位的比特位，_bs2位图的比特位代表低位的比特位。

2.set函数的功能是给定一个无符号整数，将无符号整数对应位图的那两个比特位加一（两个比特位如果是10除外，因为10就代表出现2次及以上），即如果是00变成01，如果是01变成10，如果是10不再变化，代码实现如下图所示。

3.is_once函数的功能是给定一个无符号整数，返回该整数在数据集中是否只出现一次，即无符号整数对应位图的那两个比特位如果是01则返回true，如果不是则返回false，代码实现如下图所示。

2.给两个文件，分别有100亿个整数，我们只有1G内存，如何找到两个文件交集？

答：数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0代表不存在。假设两个文件分别是A文件和B文件，A文件开一个位图1，B文件开一个位图2，遍历A文件和B文件，将每一个无符号整数对应位图的那个比特位由0改成1，就得到了位图1和位图2，这个步骤同时完成了去重的功能。将两个位图进行按位与运算，得到的位图中所有比特位为1的位置对应的整数就是交集整数。

因为数据集中是无符号整数，无符号整数的最大值为0xffffffff，大约为四十二亿九千万，因为要开两个位图，所以要开大约为四十二亿九千万×2个比特位空间作为位图空间，四十二亿九千万×2个比特位空间是1G内存空间。

3.位图应用变形：1个文件有100亿个int，1G内存，设计算法找到出现次数不超过2次的所有整数。

答：找在给定的整形数据中出现次数不超过两次的整数，可以将整数出现次数标记为出现0次、出现1次、出现2次，出现3次及以上，刚好是四种状态，那么可以使用两个二进制比特位来代表数据出现次数的信息，如果两个二进制比特位为00，代表出现0次，为01代表出现1次，为10代表出现2次，为11代表出现3次及以上。

因为数据集中是int，int的最小值为-2147483647-1，最大值为2147483647，范围大约为四十二亿九千万，因为要开两个位图，所以要开大约为四十二亿九千万×2个比特位空间作为位图空间，四十二亿九千万×2个比特位空间是1G内存空间。

5.3.布隆过滤器

1.给两个文件，分别有100亿个query，我们只有1G内存，如何找到两个文件交集？分别给出

精确算法和近似算法

精确算法：假设每个query平均30字节，十亿字节是1G，100亿query就是300G。假设两个文件分别是A文件和B文件，每一个文件是300G，我们进行哈希切割可以模1000，这样每个小文件平均300M，即使个别大一点内存也可以存下。通过哈希函数i=HashFunc(query)%1000将文件A和文件B哈希分割成A0、A1......A999和B0、B1......B999小文件，这样A和B文件中相同的query一定进入了编号相同的小文件，那么A和B文件找交集就转换成了A0和B0找交集、A1和B1找交集......A999和B999找交集。小文件找交集可以将一个小文件中的数据插入set进行去重，然后遍历对应的另一个小文件看每个数据是否在set中，如果在则是交集。

近似算法：使用布隆过滤器，将一个文件生成对应的布隆过滤器，然后遍历另一个文件数据，如果数据在布隆过滤器中就是交集，不在就不是交集。

2.如何扩展BloomFilter使得它支持删除元素的操作

答：将布隆过滤器中的每个比特位扩展成一个小的计数器，插入元素时给k个计数器(k个哈希函数计算出的哈希地址)加一，删除元素时，给k个计数器减一。这样每个比特位变成了多个比特位的计数器，通过多占用几倍存储空间（计数器所占空间）的代价来增加删除操作。

---

6.分布式存储

例如：腾讯要存储用户朋友圈数据，如何存储。

微信有10亿+用户，假设平均每个用户朋友圈占用100M，那么10亿个用户朋友圈总共占用10亿×100M大约1亿G存储空间，1亿G的数据还需要多备份几份，一台机器肯定存不下，需要很多台机器共同存储。

那么刷朋友圈请求数据，怎么知道数据在哪台机器上呢？发朋友圈，数据应该存在哪台机器上呢？

这就涉及到分布式存储，每一个用户有一个ID，使用哈希映射就能解决问题。如下图所示有100台服务器存储数据，发朋友圈存储数据的时候使用哈希函数i=HashFunc(ID)%100就得到了数据应该存储在编号为几的服务器上。查找的时候也是根据哈希函数将用户ID映射成对应编号的服务器，在对应服务器中查找数据。

如果随着每个人的朋友圈数据越来越多，100台服务器的存储空间可能不够了，需要扩展服务器到150台，如果要扩展服务器那么之前的哈希映射关系就全乱了（和哈希表扩容一样），需要重新映射，代价太大。

解决方案：一致性哈希。这里作为扩展学习，有兴趣可以自己去了解。