【C++】哈希

ks不知火

已于 2024-10-24 17:59:26 修改

阅读量644

点赞数

分类专栏： C++ 文章标签： c++ 哈希算法开发语言 1024程序员节

于 2023-05-20 17:49:40 首次发布

本文链接：https://blog.csdn.net/kdjjdjdjjejje128/article/details/130183823

版权

C++ 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

文章目录

1、unordered系列关联式容器
2、哈希概念
3、哈希冲突
4、哈希函数
5、闭散列和开散列方法
6、哈希的应用
7、海量数据面试题
8、总结

1、unordered系列关联式容器

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

1-1、unordered_map和unordered_set

unordered_map文档
 unordered_set文档
这里的unordered_set和unordered_map其实没有什么可以讲的，和我们前面的map和set使用大部分都相同
主要一点的区别就是：

unordered_set和unordered_map的打印结果是无序的（不一定是按照插入顺序打印的，无序打印！！！），而map和set打印的结果是中序的
再就是unordered_set和unordered_map是不支持反向迭代器的，只能++，不能–

注意：map和set对K的要求是能够比较大小，因为map和set是搜索树要进行搜索；unordered_map和unordered_set对K的要求是能够转换成整型，因为整型才能够就行取余操作，计算出对应哈希表的位置

1-2、见见猪跑

我们拿前面的代码来测试

int main()
{
	unordered_set<int> us;
	us.insert(3);
	us.insert(1);
	us.insert(3);
	us.insert(2);
	us.insert(0);
	unordered_set<int>::iterator it = us.begin();
	while (it != us.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	string arr[] = { "苹果", "西瓜", "香蕉", "草莓", "苹果", "西瓜", 
		"苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	unordered_map<string, int> countMap;
	for (auto& e : arr)
	{
		//map<string, int>::iterator it = countMap
		/*auto it = countMap.find(e);
		if (it == countMap.end())
		{
			countMap.insert(make_pair(e, 1));
		}
		else
		{
			it->second++;
		}*/

		countMap[e]++;
	}
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
	return 0;
}

在这里插入图片描述
这个时候就有问题了，我们map和set看起来明明比unordered_set和unordered_map作用更广，还要这两个干什么呢？
这两个容器肯定是有自己的优势的，我们一步步来

1-3、代码测试

1、插入性能比较

int main()
{
	srand(time(0));
	vector<int> v;
	size_t N = 1000000;//可以加到更大
	for (size_t i = 0; i < N; ++i)
	{
		//这里采用大量随机值的测试样例！
		//v.push_back(rand());//少量随机值
		v.push_back(rand() + i);//大量随机值
		//v.push_back(i);//有序值
	}
	set<int> st;
	unordered_set<int> uns;

	size_t begin1 = clock();
	for (const auto& e : v)
	{
		st.insert(e);
	}
	size_t end1 = clock();

	size_t begin2 = clock();
	for (const auto& e : v)
	{
		uns.insert(e);
	}
	size_t end2 = clock();

	cout << "set insert : " << end1 - begin1 << endl;
	cout << "unordered_set insert : " << end2 - begin2 << endl;

	return 0;
}

在这里插入图片描述
2、查找性能比较（顺带把删除也比较了）

int main()
{
	srand(time(0));
	vector<int> v;
	size_t N = 1000000;//可以加到更大
	for (size_t i = 0; i < N; ++i)
	{
		//这里采用大量随机值的测试样例！
		//v.push_back(rand());//少量随机值
		v.push_back(rand() + i);//大量随机值
		//v.push_back(i);//有序值
	}
	set<int> st;
	unordered_set<int> uns;

	size_t begin1 = clock();
	for (const auto& e : v)
	{
		st.insert(e);
	}
	size_t end1 = clock();

	size_t begin2 = clock();
	for (const auto& e : v)
	{
		uns.insert(e);
	}
	size_t end2 = clock();

	cout << "set insert : " << end1 - begin1 << endl;
	cout << "unordered_set insert : " << end2 - begin2 << endl;

	cout << "set size : " << st.size() << endl;
	cout << "unordered_set size : " << st.size() << endl;

	size_t begin3 = clock();
	for (const auto& e : v)
	{
		st.find(e);
	}
	size_t end3 = clock();

	size_t begin4 = clock();
	for (const auto& e : v)
	{
		uns.find(e);
	}
	size_t end4 = clock();

	cout << "set find : " << end3 - begin3 << endl;
	cout << "unordered_set find : " << end4 - begin4 << endl;

	size_t begin5 = clock();
	for (const auto& e : v)
	{
		st.erase(e);
	}
	size_t end5 = clock();

	size_t begin6 = clock();
	for (const auto& e : v)
	{
		uns.erase(e);
	}
	size_t end6 = clock();

	cout << "set erase : " << end5 - begin5 << endl;
	cout << "unordered_set erase : " << end6 - begin6 << endl;
	return 0;
}

在这里插入图片描述
可以看到unordered容器的删除和查找是要快一点的

值得注意的是：

在数据有序的时候，set容器比unordered容器要快一点，但是查找不管什么情况下unordered容器都是最快的。再者就是，因为linux底层实现的原因，linux下面的unordered容器不管是什么方面都比set容器要快的

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

2、哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( $log_2 N$ )，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

我们可以将哈希理解为一种映射关系

当向该结构中：

插入元素：

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

搜索元素：

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

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

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小
在这里插入图片描述

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

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

答案是：产生了哈希冲突！！！

3、哈希冲突

对于两个数据元素的关键字 $k_i$ 和 $k_j$ (i != j)，有 $k_i$ != $k_j$ ，但有：Hash( $k_i$ ) == Hash( $k_j$ )，
即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞
(哈希冲突/碰撞：不同的值映射到相同的位置)

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。发生哈希冲突该如何处理呢？

这个时候就要用到哈希函数了，说简单点，就是处理哈希冲突的方法

4、哈希函数

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

哈希函数设计原则：

1、哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
2、哈希函数计算出来的地址能均匀分布在整个空间中
3、哈希函数应该比较简单

常见哈希函数

1. 直接定址法–(常用)

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

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)等方法。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

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

以上就是一些处理哈希冲突的方法，但是哈希冲突是无法避免的，我们只能进行减少处理。
其中，处理哈希冲突最常见的两种方法是：闭散列和开散列

5、闭散列和开散列方法

5-1、闭散列

闭散列：

也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？

5-1-1、线性探测

比如下面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

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

插入：

通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素
如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

线性探测中，哈希表的容量不能被占满。因为在插入最后几个数据的时候，相当于遍历了一遍哈希表，非常浪费时间
所以，线性探测使用了负载因子/载荷因子（也就是哈希表有效数据个数除以表的大小）
负载因子/载荷因子：

负载因子越小，冲突概率越小，空间消耗越大（空间换时间）
负载因子越大，冲突概率越大，空间利用率越大（时间换空间）

注意：这里的capacity我们在编写代码的时候（采用vector容器），其实是size的大小，也就是哈希表的有效数据个数。因为如果vector容器的size是15，capacity的容量是20，这个时候我们取余20得到的位置在16到20之间的会是不能插入的，因为vector的【】会强制检查【】内的值是否小于size，如果不是就会报错，并且capacity多余的空间就要浪费。这里最好的方法是保证size等于capacity。所以下图的capacity实际上代码过程中是size的大小

在这里插入图片描述

删除：

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素（给每一个位置加上一个状态标识）

线性探测优点：实现非常简单
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低

5-1-2、线性探测的代码

#pragma once
#include <vector>
#include<string>

template <class k>
struct HashFunc
{
	size_t operator()(const k& key)
	{
		return (size_t)key;
	}
};
//特化//
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 131;
			hash += e;
		}
		return hash;
	}
};
//struct HashFuncString
//{
//	size_t operator()(const string& key)
//	{
//		size_t hash = 0;
//		for (auto e : key)
//		{
//			hash *= 131;
//			hash += e;
//		}
//		return hash;
//	}
//};

namespace closehash
{
	enum State//用来标志该位置的状况：empty空，exist有数据，delete删除
	{
		EMPTY,
		EXIST,
		DELETE,
	};
	template <class k, class v>
	struct HashData
	{
		pair<k, v> _kv;//自定义类型，会初始化
		State _state = EMPTY;//初始化
	};

	template <class k, class v, class Hash = HashFunc<k>>
	class HashTable
	{
		typedef HashData<k, v> Data;
	public:
		HashTable()
			:_n(0)
		{
			_tables.resize(10);//解决除0错误
		}
		bool Insert(const pair<k, v>& kv)
		{
			if (Find(kv.first))
				return false;
			//if (_n  % _tables.size() >= 0.7)//负载因子大于7就要扩容，不然线性探测几乎走了整个结构
			if (_n * 10 / _tables.size() >= 7)//内置类型不做处理，所以_n要初始化为0，这里就发生了除0错误
			{
				//旧表数据重新计算映射到新表
				//vector<Data> newTable;
				//newTable.resize(_tables.size() * 2);
				//for ()
				//{
				//	// ...这里重新推导下面的hashi和while循环等代码
				//}
				HashTable<k, v, Hash> newHL;
				newHL._tables.resize(_tables.size() * 2);
				for (auto& e : _tables)
				{
					if (e._state == EXIST)
					{
						newHL.Insert(e._kv);//优势就是复用insert。上面不能复用
					}
				}
				_tables.swap(newHL._tables);
			}
			Hash hf;
			size_t hashi = hf(kv.first) % _tables.size();
			while (_tables[hashi]._state == EXIST)
			{
				++hashi;
				hashi %= _tables.size();//为了防止hashi加到越界了，每次都要余等表的大小
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_n;
			return true;
		}
		Data* Find(const k& key)
		{
			Hash hf;
			size_t hashi = hf(key) % _tables.size();
			size_t starti = hashi;//用来记录hashi最开始的地址，如果hashi走了一圈又回到了这里，那么就找不到key
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state == EXIST && _tables[hashi]._kv.first == key)
				//如果表的标志为有数据，且值相等，返回
				{
					return &_tables[hashi];
				}
				++hashi;
				hashi %= _tables.size();
				if (hashi == starti)如果哈希表都是删除标记和存在标记，那么哈希表就永远不为空
				{
					break;
				}
			}
			return nullptr;
		}
		bool Erase(const k& key)
		{
			Data* ret = Find(key);
			if (ret)
			{
				ret->_state = DELETE;
				--_n;
				return true;
			}
			else
			{
				return false;
			}
		}
	private:
		vector<Data> _tables;
		size_t _n = 0;//哈希表有效数据个数
	};

	void TestHT1()
	{
		HashTable<int, int> ht;
		int a[] = { 18, 8, 7, 27, 57, 3, 38, 18 };
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}

		ht.Insert(make_pair(17, 17));
		ht.Insert(make_pair(5, 5));
		cout << ht.Find(7) << endl;
		cout << ht.Find(8) << endl;

		ht.Erase(7);
		cout << ht.Find(7) << endl;
		cout << ht.Find(8) << endl;
	}

	void TestHT2()//整型可以直接取余，字符串不行
	{
		string arr[] = { "苹果", "西瓜", "香蕉", "草莓", "苹果", "西瓜",
					"苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		//HashTable<string, int, HashFuncString> cnthl;
		HashTable<string, int> cnthl;//特化
		for (auto& e : arr)
		{
			HashData<string, int>* ret = cnthl.Find(e);
			if (ret)
			{
				ret->_kv.second++;
			}
			else
			{
				cnthl.Insert(make_pair(e, 1));
			}
		}

		HashFunc<string> hf;
		cout << hf("abc") << endl;
		cout << hf("bac") << endl;
		cout << hf("cba") << endl;
		cout << hf("aad") << endl;
	}
}

思考：哈希表什么情况下进行扩容？如何扩容？
这里就用到我们上面提到的负载因子/载荷因子了
在这里插入图片描述

这里我们只是了解一些线性探测的方法，所以begin等方法没有实现。重要知识点我们放在后面的哈希桶

5-1-3、二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： $H_i$ = ( $H_0$ + $i^2$ )% m, 或者： $H_i$ = ( $H_0$ - $i^2$ )% m。其中：i = 1,2,3…， $H_0$ 是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。
对于下面如果要插入44，产生冲突，使用解决后的情况为：
在这里插入图片描述
简单来说：

线性探测是算出插入位置之后，发生冲突，就像后偏移 i（1，2，3，4…）位置，越界就取余哈希表的大小
二次探测是算出插入位置之后，发生冲突，就向后偏移 $i^2$ （1，4，9，16，25）位置，越界就取余哈希表大小

这里没有实现二次探测的代码，主要就是记录start的位置（上面取余的结果），然后将++hashi改成++ $i^2$

研究表明：

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

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

5-2、开散列

5-2-1、开散列的概念

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

从上图可以看出，

开散列中每个桶中放的都是发生哈希冲突的元素

5-2-2、开散列的代码

除留余数法，最好模一个素数，如何每次快速取一个类似两倍关系的素数？
在这里插入图片描述
这里库直接弄了一个素数表，我们在扩容的时候不用扩二倍或者其他倍数，直接依次扩素数表里面的素数，将这些素数作为哈希表的大小

#pragma once
#include <vector>
#include<string>

template <class k>
struct HashFunc
{
	size_t operator()(const k& key)
	{
		return (size_t)key;
	}
};
//特化//
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 131;
			hash += e;
		}
		return hash;
	}
};

namespace buckethash
{
	template<class k, class v>
	struct HashNode
	{
		pair<k, v> _kv;
		HashNode<k, v>* _next;
		HashNode(const pair<k, v>& kv)
			:_kv(kv)
			,_next(nullptr)
		{}
	};

	template<class k, class v, class Hash = HashFunc<k>>
	class HashTable
	{
		typedef HashNode<k, v> Node;
	public:
		HashTable()
			:_n(0)
		{
			_tables.resize(10);//解决除0错误
			//_stl_next_prime(0);

		}
		~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<k,v>& kv)
		{
			if (Find(kv.first))//去重
				return false;
			//if(_tables.size() == _n)
			//负载因子为1（也就是平均下来每个位置下面都挂一个桶，
			//也可以一半的位置挂两个桶，一半不挂），就扩容
			if (_n / _tables.size() == 1)
			{
				//HashTable<k, v, Hash> newHL;
				//newHL._tables.resize(_tables.size() * 2);
				//for (auto& cur : _tables)
				//{
				//	while(cur)
				//	{
				//		newHL.Insert(cur->_kv);
				//		cur = cur->_next;
				//	}
				//}
				//_tables.swap(newHL._tables);

				直接移动旧表的节点，不需要重新拷贝旧表节点插入以及释放旧表节点
				节点的地址不会改变！！！
				vector<Node*> newTables;
				newTables.resize(_tables.size() * 2, nullptr);
				//newTables.resize(_stl_next_prime(_tables.size()), nullptr);
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = Hash()(cur->_kv.first) % newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}
			size_t hashi = Hash()(kv.first) % _tables.size();
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}
		Node* Find(const k& key)
		{
			size_t hashi = Hash()(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				else
				{
					cur = cur->_next;
				}
			}
			return nullptr;
		}
		bool Erase(const k& key)
		{
			size_t hashi = Hash()(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (cur == _tables[hashi])//如果删除的节点是头节点，更新哈希表的头指针为下一个节点
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_n;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}
		inline unsigned long __stl_next_prime(unsigned long n)
		{
			static const int __stl_num_primes = 28;
			static const unsigned long __stl_prime_list[__stl_num_primes] =
			{
				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 (int i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > n)
				{
					return __stl_prime_list[i];//依次取表里面的素数，如果比表的大小大，就直接返回素数
				}
			}
			return __stl_prime_list[__stl_num_primes - 1];//如果
		}
	private:
		vector<Node*> _tables;//指针数组
		size_t _n = 0;
	};
	void TestHT1()
	{
		HashTable<int, int> ht;
		int a[] = { 18, 8, 7, 27, 57, 3, 38, 18,17,88,38 };
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}

		ht.Insert(make_pair(17, 17));
		ht.Insert(make_pair(5, 5));
		ht.Erase(57);
		ht.Erase(17);

	}
	void TestHT2()
	{
		string arr[] = { "苹果", "西瓜", "香蕉", "草莓", "苹果", "西瓜",
					"苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		//HashTable<string, int, HashFuncString> cnthl;
		HashTable<string, int> cnthl;//特化
		for (auto& e : arr)
		{
			HashNode<string, int>* ret = cnthl.Find(e);
			if (ret)
			{
				ret->_kv.second++;
			}
			else
			{
				cnthl.Insert(make_pair(e, 1));
			}
		}
	}
}

5-2-3、开散列代码的进一步封装（重点）

unorderedset.h

#pragma once
#include "HashTable.h"

namespace bzh
{
	template <class k, class Hash = HashFunc<k>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const k& operator()(const k& key)
			{
				return key;
			}
		};
	public:
		//类模板没有实例化，取类型的话，编译器区分不清是静态变量还是类型
		//加typename就是告诉编译器，这个是类型，等后面实例化再来取
		typedef typename buckethash::HashTable<k, k, Hash, SetKeyOfT>::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:
		buckethash::HashTable<k, k, Hash, SetKeyOfT> _ht;
	};

	void test_unordered_set()
	{
		unordered_set<int> us;
		us.insert(13);
		us.insert(3);
		us.insert(23);
		us.insert(5);
		us.insert(5);
		us.insert(6);
		us.insert(15);
		us.insert(223342);
		us.insert(22);

		unordered_set<int>::iterator it = us.begin();
		while (it != us.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

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

unorderedmap.h

#pragma once
#include "HashTable.h"

namespace bzh
{
	template <class k, class v, class Hash = HashFunc<k>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const k& operator()(const pair<const k, v>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename buckethash::HashTable<k, pair<const k, v>,
			Hash, MapKeyOfT>::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 pair<k, v>& data)
		{
			return _ht.Insert(data);
		}
		v& operator[](const k& key)插入/修改/查找
		{
			pair<iterator, bool> ret = _ht.Insert(make_pair(key, v()));
			return ret.first->second;
		}
	private:
		buckethash::HashTable<k, pair<const k,v>, Hash, MapKeyOfT> _ht;
	};
	void test_unordered_map()
	{
		string arr[] = { "苹果", "西瓜", "香蕉", "草莓", "苹果", "西瓜",
					"苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

		unordered_map<string, int> countMap;
		for (auto& e : arr)
		{
			countMap[e]++;
		}

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

HashTable.h

#pragma once
#include <vector>
#include<string>

template <class k>
struct HashFunc
{
	size_t operator()(const k& key)
	{
		return (size_t)key;
	}
};
//特化//
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 131;
			hash += e;
		}
		return hash;
	}
};

namespace buckethash
{
	template<class T>
	struct HashNode
	{
		//pair<k, v> _kv;
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			,_next(nullptr)
		{}
	};

	//前置声明，迭代器需要哈希表，哈希表需要迭代器
	template<class k, class T, class Hash, class KeyOfT>
	class HashTable;

	template<class k, class T, class Hash, class KeyOfT>///迭代器
	struct __HTIterator
	{
		typedef HashNode<T> Node;
		typedef __HTIterator<k, T, Hash, KeyOfT> Self;

		typedef HashTable<k, T, Hash, KeyOfT> HT;

		Node* _node;//_node和_ht都是非const的
		HT* _ht;

		__HTIterator(Node* node, HT* ht)//这里的node和ht是const的，这就导致无法进行初始化
			//想要使得_node和_ht能够被初始化，那么就要将_node和_ht改成const修饰
			:_node(node)
			, _ht(ht)
		{}

		T& operator*()//如果_node和_ht改成const修饰，那么这里的普通迭代器就不能够发生修改
		{
			return _node->_data;
		}

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

		bool operator != (const Self& s) const
		{
			return _node != s._node;
		}
		Self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				// 当前桶走完了，要找下一个桶的第一个
				KeyOfT kot;
				Hash hash;
				size_t hashi = hash(kot(_node->_data)) % _ht->_tables.size();
				++hashi;
				while (hashi < _ht->_tables.size())
				{
					if (_ht->_tables[hashi])
					{
						_node = _ht->_tables[hashi];
						break;
					}
					else
					{
						++hashi;
					}
				}

				// 后面没有桶了
				if (hashi == _ht->_tables.size())
					_node = nullptr;
			}
			return *this;
		}
	};
	template<class k, class T, class Hash,class KeyOfT>
	//可以这样写，把Hash放到后面，但是没有意义，Hash一定是上面的unordered_set或者map传过来的
	//template<class k, class T,class KeyOfT,class Hash = HashFunc<k>>
	class HashTable
	{
		typedef HashNode<T> Node;

		template<class k, class T, class Hash, class KeyOfT>
		friend struct __HTIterator;
	public:
		typedef __HTIterator<k, T, Hash, KeyOfT> iterator;
		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				if (_tables[i])
				{
					return iterator(_tables[i], this);
					//这里const迭代器要单独弄一个出来因为const迭代器使用之后，_tables[i]和this
					//都是const迭代器修饰的了
				}
			}
			return iterator(nullptr, this);
		}
		iterator end()
		{
			return iterator(nullptr, this);
		}

		HashTable()
			:_n(0)
		{
			_tables.resize(10);//解决除0错误
			//_stl_next_prime(0);
		}
		~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;
			}
		}
		pair<iterator,bool> Insert(const T& data)
		{
			KeyOfT koft;
			iterator it = Find(koft(data));
			if (it != end())//去重
				return make_pair(it, false);
			//if(_tables.size() == _n)
			//负载因子为1（也就是平均下来每个位置下面都挂一个桶，
			//也可以一半的位置挂两个桶，一半不挂），就扩容
			if (_n / _tables.size() == 1)
			{
				//HashTable<k, v, Hash> newHL;
				//newHL._tables.resize(_tables.size() * 2);
				//for (auto& cur : _tables)
				//{
				//	while(cur)
				//	{
				//		newHL.Insert(cur->_kv);
				//		cur = cur->_next;
				//	}
				//}
				//_tables.swap(newHL._tables);

				直接移动旧表的节点，不需要重新拷贝旧表节点插入以及释放旧表节点
				节点的地址不会改变！！！
				vector<Node*> newTables;
				newTables.resize(_tables.size() * 2, nullptr);
				//newTables.resize(_stl_next_prime(_tables.size()), nullptr);
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = Hash()(koft(cur->_data)) % newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}
			size_t hashi = Hash()(koft(data)) % _tables.size();
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return make_pair(iterator(newnode, this), true);
		}
		iterator Find(const k& key)
		{
			KeyOfT koft;
			size_t hashi = Hash()(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (koft(cur->_data) == key)
				{
					return iterator(cur,this);
				}
				else
				{
					cur = cur->_next;
				}
			}
			return end();
		}
		bool Erase(const k& key)
		{
			size_t hashi = Hash()(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (cur == _tables[hashi])
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_n;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}
		inline unsigned long __stl_next_prime(unsigned long n)
		{
			static const int __stl_num_primes = 28;
			static const unsigned long __stl_prime_list[__stl_num_primes] =
			{
				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 (int i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > n)
				{
					return __stl_prime_list[i];//依次取表里面的素数，如果比表的大小大，就直接返回素数
				}
			}
			return __stl_prime_list[__stl_num_primes - 1];//如果
		}

	private:
		vector<Node*> _tables;//指针数组
		size_t _n = 0;
	};

注意：不管是开散列还是闭散列的扩容都不能直接拷贝原哈希表数据到新表，这样映射关系就不对了

5-3、字符串哈希算法

字符串哈希算法链接

6、哈希的应用

6-1、位图

6-1-1、位图的概念

面试题

给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。【腾讯】
这里的40亿不是表示最大数是40亿，而是有40亿个数，最大数可能是42亿9千万

这里根据我们前面的知识，大概有下面几种方法：

a. 遍历，时间复杂度O(N)

b. 排序(O(NlogN))，利用二分查找: logN

c. 位图解决（用比特位标记数字在不在，最多消耗42亿9千万个比特位，也就是512mb(0.5个g)）

先来看看前面的a和b方法:
1、排序加二分
2、红黑树
3、哈希表
但是，题目说了，40亿个不重复的整数，40亿字节是4g，40亿整型就是16g（这还不算红黑树和哈希表的额外开销），这么一看，上面3种方法大概率不可行（除非是超级计算机）
所以下面的位图才是解决的关键方法

数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0 代表不存在。
比如：

在这里插入图片描述

假设整数x
x映射的值，在第几个char的对象上面呢？——x/8（从0开始，x为10，在第一个char上面）
x映射的值，在这个char对象第几个比特位上面呢？——x%8（从0开始，x为10，在第二位）

在这里插入图片描述

位图概念

所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的

注意：位图不是万能的，位图只能针对整型

6-1-2、位图的实现

#pragma once

namespace bit
{
	template<size_t N>
	class bitset
	{
	public:
		bitset()
		{
			_bit.resize(N / 8 + 1, 0);
		}
		void set(size_t x)//设置值
		{
			size_t i = x / 8;
			size_t j = x % 8;
			_bit[i] |= (1 << j);
			// 00000000——第i个char位图
			// 00000001——0...1...0——1左移j位
			// 0...1...0——最终或等的结果，将数字x设置为存在1
		}
		void reset(size_t x)//删除值
		{
			size_t i = x / 8;
			size_t j = x % 8;
			_bit[i] &= (~(1 << j));
		}
		bool test(size_t x)//测试值
		{
			size_t i = x / 8;
			size_t j = x % 8;
			return _bit[i] & (1 << j);//整型提升无所谓，结果0就是不存在，结果非0就存在
		}
	private:
		vector<char> _bit;
	};
	void test_bitset()
	{
		//bitset<100> bs1;

		//bitset<-1> bs2;
		bitset<0xffffffff> bs2;

		bs2.set(10);
		bs2.set(10000);
		bs2.set(8888);

		cout << bs2.test(10) << endl;
		cout << bs2.test(10000) << endl;
		cout << bs2.test(8888) << endl;
		cout << bs2.test(8887) << endl;
		cout << bs2.test(9999) << endl << endl;

		bs2.reset(8888);
		bs2.set(8887);

		cout << bs2.test(10) << endl;
		cout << bs2.test(10000) << endl;
		cout << bs2.test(8888) << endl;
		cout << bs2.test(8887) << endl;
		cout << bs2.test(9999) << endl;
	}
}

6-1-3、位图的优缺点

位图的优点：
1、节省空间
2、快

位图的缺点：
1、一般要求范围集中，范围特别分散，空间消耗就会上升
2、只针对整型

6-1-4、位图的应用

快速查找某个数据是否在一个集合中
排序 + 去重
求两个集合的交集、并集等
操作系统中磁盘块标记

最后有题目练习

6-2、布隆过滤器

6-2-1、布隆过滤器提出

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

用哈希表存储用户记录，缺点：浪费空间
用位图存储用户记录，缺点：位图一般只能处理整形，如果内容编号是字符串，就无法处理了。
将哈希与位图结合，即布隆过滤器

6-2-2、布隆过滤器概念

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

在这里插入图片描述

布隆过滤器

举例：
在这里插入图片描述
但是字符串是存在误判的，因为整型有范围的，而字符串没有

误判：
在是准确的还是不在是准确的呢？

答案是不在是准确的，因为可能数据本来不在，但是这个位置冲突了，出现误判

那么有没有什么方法能够降低误判概率呢？

我们可以使一个数据映射多个位置，也就是采用多个哈希函数进行映射

在这里插入图片描述

6-2-2、布隆过滤器的实现

在这里插入图片描述

布隆过滤器是没有reset，也就是删除的，因为一个位可能对应多个值，如果直接删除，会影响到其他数据
那么，能不能强制布隆过滤器支持删除呢？
只能通过计数来处理，布隆过滤器就不存放字符串是否在不在的标记位了，而是存放多少个字符串指向该位置的个数

在这里插入图片描述

#pragma once
#include <bitset>

namespace bit
{
	struct BKDRHash
	{
		size_t operator()(const string& key)
		{
			size_t hash = 0;
			for (auto ch : key)
			{
				hash *= 131;
				hash += ch;
			}
			return hash;
		}
	};

	struct APHash
	{
		size_t operator()(const string& key)
		{
			unsigned int hash = 0;
			int i = 0;

			for (auto ch : key)
			{
				if ((i & 1) == 0)
				{
					hash ^= ((hash << 7) ^ (ch) ^ (hash >> 3));
				}
				else
				{
					hash ^= (~((hash << 11) ^ (ch) ^ (hash >> 5)));
				}

				++i;
			}
			return hash;
		}
	};

	struct DJBHash
	{
		size_t operator()(const string& key)
		{
			unsigned int hash = 5381;

			for (auto ch : key)
			{
				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;
		}
	};

	// 假设N是最多存储的数据个数；平均存储一个值,开辟X个位
	template<size_t N,
		size_t X = 6,//改变x，误判概率就发生改变，x越大，误判越低
		class K = string,
		class HashFunc1 = BKDRHash,
		class HashFunc2 = APHash,
		class HashFunc3 = DJBHash,
		class HashFunc4 = JSHash>
	class BloomFilter
	{
	public:
		void set(const K& key)
		{
			size_t hash1 = HashFunc1()(key) % (N * X);
			size_t hash2 = HashFunc2()(key) % (N * X);
			size_t hash3 = HashFunc3()(key) % (N * X);
			size_t hash4 = HashFunc4()(key) % (N * X);

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

		bool test(const K& key)
		{
			size_t hash1 = HashFunc1()(key) % (N * X);
			if (!_bs.test(hash1))
			{
				return false;
			}

			size_t hash2 = HashFunc2()(key) % (N * X);
			if (!_bs.test(hash2))
			{
				return false;
			}

			size_t hash3 = HashFunc3()(key) % (N * X);
			if (!_bs.test(hash3))
			{
				return false;
			}

			size_t hash4 = HashFunc4()(key) % (N * X);
			if (!_bs.test(hash4))
			{
				return false;
			}
						 // 前面的判断不在都是准确，不存在误判
			return true; // 可能存在误判，映射几个位置都冲突，就会误判
		}
	private:
		std::bitset<N * X> _bs;//官方库的bitset
	};

	void test_bloomfilter1()
	{
		string str[] = { "猪八戒", "孙悟空", "沙悟净", "唐三藏", "白龙马1","1白龙马",
			"白1龙马","白11龙马","1白龙马1" };
		BloomFilter<10> bf;
		for (auto& str : str)
		{
			bf.set(str);
		}
		for (auto& s : str)
		{
			cout << bf.test(s) << endl;
		}
		cout << endl;

		srand(time(0));//如果出现1，就表示有误判了
		for (const auto& s : str)
		{
			cout << bf.test(s + to_string(rand())) << endl;
		}
	}

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

		std::vector<std::string> 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(i));
		}

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

		// v2跟v1是相似字符串，但不一样
		std::vector<std::string> 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);//加999999保证两个字符串不一样
			v2.push_back(url);
		}

		size_t n2 = 0;
		for (auto& str : v2)
		{
			if (bf.test(str))//如果bf里面有str，就表示误判了
			{
				++n2;//统计误判数据个数
			}
		}
		cout << "相似字符串误判率:" << (double)n2 / (double)N << endl;

		// 不相似字符串集
		std::vector<std::string> v3;
		for (size_t i = 0; i < N; ++i)
		{
			string url = "zhihu.com";
			url += std::to_string(i + rand());
			v3.push_back(url);
		}

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

6-2-3、布隆过滤器的优点

增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无关
哈希函数相互之间没有关系，方便硬件并行运算
布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势
在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势
数据量很大时，布隆过滤器可以表示全集，其他数据结构不能
使用同一组散列函数的布隆过滤器可以进行交、并、差运算

6-2-4、布隆过滤器的缺点

有误判率，即存在假阳性(False Position)，即不能准确判断元素是否在集合中(补救方法：再建立一个白名单，存储可能会误判的数据)
不能获取元素本身
一般情况下不能从布隆过滤器中删除元素
如果采用计数方式删除，可能会存在计数回绕问题

6-2-5、布隆过滤器的应用

在这里插入图片描述

7、海量数据面试题

7-1、哈希切割

给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？
与上题条件相同，如何找到top K的IP？如何直接用Linux系统命令实现？

先来看看前面的一问：给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？
这里初看好像位图，哈希，红黑树等等内容好像都不行，因为100G太大了，但实际上还是要用map或者unordered_map来完成

第一步就是将100G文件切分成100个1G文件并且编号——Ai(A0,A1…A99)
在这里插入图片描述
这样一来，相同的ip就一定进入了编号相同的小文件，我们先统计A0这个map/unordered_map中出现次数最多的ip地址，然后释放掉A0，再统计A1最多的ip地址与A0的比较，保存A0和A1最多的ip地址，继续与A2…A99比较

比较完之后，我们看着结束了，其实还存在问题：
如果单个文件Ai大小超过了1G怎么办？
这里要分两种情况：

情况1：小文件冲突ip很多，都是不同的ip，大多数ip不重复。map统计不下

方法：递归切分
我们可以换个字符串哈希函数（换个HashFunc函数），递归再切分（重新切分该小文件）

情况2：小文件冲突ip很多，都是相同的ip，大多数ip重复。map可以统计

这里我们直接采用map进行统计次数（map的方括号【】可以统计次数），如果是第二种情况，是可以继续统计的，因为重复ip过多，只是计数变大，小文件还有内存，可以继续插入
如果是第一种情况，那么map的insert插入会失败（同样是【】起到了作用），原因就是没有内存了，相当于new节点失败了，new失败就会抛异常，这里同理

那么如何找到top K的IP？
既然都说top K了，那么必然就要使用到堆了，这里引入一个堆，然后排序就行，将次数最多或者最少次数的ip放到堆的前k个位置就行

如何直接用Linux系统命令实现？

cat test.txt | awk '{print $2}' | sort |uniq - c | sort -n -r | head -n 1
上面的shell脚本就可以查看ip次数最多

7-2、位图应用

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

这里我们可以采用两个比特位记录的方法：
00——没有出现
01——出现1次
10——出现1次以上
这样标记完之后我们遍历一遍就出来了
在这里插入图片描述
但是这里我们还有更简单的方法——开两个位图

#pragma once

namespace bit
{
	template<size_t N>
	class bitset
	{
	public:
		bitset()
		{
			_bit.resize(N / 8 + 1, 0);
		}
		void set(size_t x)//设置值
		{
			size_t i = x / 8;
			size_t j = x % 8;
			_bit[i] |= (1 << j);
			// 00000000——第i个char位图
			// 00000001——0...1...0——1左移j位
			// 0...1...0——最终或等的结果，将数字x设置为存在1
		}
		void reset(size_t x)//删除值
		{
			size_t i = x / 8;
			size_t j = x % 8;
			_bit[i] &= (~(1 << j));
		}
		bool test(size_t x)//测试值
		{
			size_t i = x / 8;
			size_t j = x % 8;
			return _bit[i] & (1 << j);//整型提升无所谓，结果0就是不存在，结果非0就存在
		}
	private:
		vector<char> _bit;
	};
	void test_bitset()
	{
		//bitset<100> bs1;

		//bitset<-1> bs2;
		bitset<0xffffffff> bs2;

		bs2.set(10);
		bs2.set(10000);
		bs2.set(8888);

		cout << bs2.test(10) << endl;
		cout << bs2.test(10000) << endl;
		cout << bs2.test(8888) << endl;
		cout << bs2.test(8887) << endl;
		cout << bs2.test(9999) << endl << endl;

		bs2.reset(8888);
		bs2.set(8887);

		cout << bs2.test(10) << endl;
		cout << bs2.test(10000) << endl;
		cout << bs2.test(8888) << endl;
		cout << bs2.test(8887) << endl;
		cout << bs2.test(9999) << endl;
	}

	template<size_t N>
	class two_bitset
	{
	public:
		
		void set(size_t x)//设置值
		{
			if (!_bs1.test(x) && !_bs2.test(x))// 00
			{
				_bs2.set(x);//01
			}
			else if (!_bs1.test(x) && _bs2.test(x))// 01
			{
				_bs1.set(x);
				_bs2.reset(x);//10
			}
			//出现一次以上的数就不管了
		}
		void PrintOnce()//打印只出现一次的数
		{
			for (size_t i = 0; i < N; ++i)
			{
				if (!_bs1.test(i) && _bs2.test(i))
				{
					cout << i << " ";
				}
			}
			cout << endl;
		}
	private:
		bitset<N> _bs1;
		bitset<N> _bs2;
	};
	void test_twobit()
	{
		two_bitset<100> tbs;
		int arr[] = { 3, 5, 6, 7, 8, 9, 33, 55, 67, 3, 3, 3, 5, 9, 33 };
		for (auto e : arr)
		{
			tbs.set(e);
		}
		tbs.PrintOnce();
	}
}

这里的100亿数据对我们位图没有影响、1000亿、10000亿也是如此；因为位图只与数据的范围有关，而一个数的最大值是2³²-1，所以这100亿有很多重复数据

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

在这里插入图片描述

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

这里的第一眼和第一题的想法一样：

00：0次
01：1次
10：2次
11：3次及以上

改变一下代码就行

7-3、布隆过滤器

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

近似算法：
也就是允许误差，这就很简单了，直接使用布隆过滤器。将文件1放入布隆过滤器，通过文件2在布隆过滤器里面比对，相同的就是交集
但这也就导致了，两个文件相同的query进入了交集，而有些不相同的也进入了交集

精确算法：
在这里插入图片描述
Ai和Bi文件去重，然后把一个文件放入哈希表或者将两个文件放入哈希表，然后对着找相同的query，放入交集

这里的小文件Ai和Bi小文件也会满，而满了也是有上面7-1题目中的两种情况，处理方法也是一模一样的：
小文件Ai或者Bi满了，query重复过多可以继续统计，query重复少就要换HashFunc哈希函数重新切割该小文件

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

上面已经提到过了，采用计数的方法，字符串映射到布隆过滤器的多个地址就不存放0/1是否存在的标记位了，而是存放计数次数。每有一个字符串映射到了布隆过滤器相同的位置，该位置的计数就加一，每删除一个数据，该数据对应的所有位置的计数都减一

在这里插入图片描述

8、总结

本期内容还是很丰富的，前面的哈希表求取哈希地址的内容是重点，大家要根据实际情况来采用求取哈希地址的方法，不一定是除留余数法
在模拟实现的时候，这里和我们前面的模拟红黑树逻辑上是大致相同的，看代码也可以看出来，主要弄懂为什么哈希要两个迭代器，一个const和非const，不能够向红黑树那样复用（代码部分有解释）

后面的位图和布隆过滤器也是重中之重，面试考到两者的概率还是比较高的，但是上面的内容足够应对面试了，想要深入学习的同学也可以继续看看源码或者在git/gitee/博客园等地方寻找优质内容学习
酷壳陈浩