1. 哈希结构

1.1 哈希的概念

1.2 哈希冲突(碰撞)

1.3 哈希函数

2. 闭散列/开散列解决哈希冲突

2.1 闭散列概念和代码

2.1.1 闭散列线性探测（实现）

闭散列线性探测完整代码

2.1.2 闭散列二次探测（了解）

2.2 开散列(哈希桶)概念和代码

2.2.1 除留余数法获取素数

2.2.2 开散列(哈希桶)完整代码

3. 开散列与闭散列比较

4. 哈希笔试选择题

答案

本篇完。

1. 哈希结构

写OJ时经常看到用到哈希的概念的话，效率就会比较高

1.1 哈希的概念

（以前也学了和哈希相关的概念，绝对映射，相对映射等等）

比如写过的这题：387. 字符串中的第一个唯一字符 - 力扣（LeetCode）

class Solution {
public:
	int firstUniqChar(string s) {
		int countArr[26] = { 0 };
		for (auto e : s)
		{
			countArr[e-'a']++;//相对映射到数组里++
		}
		for (int i = 0;i < s.size(); i++)
		{
			if (countArr[(s[i]-'a')] == 1)//从原字符串遍历字符的相对映射
			{
				return i;//第一个相对映射为1的就返回其下标
			}
		}
		return -1;//没有出现一次的，输出-1
	}
};

哈希的概念：

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，

因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O（N），

平衡树中为树的高度，即O（logN），搜索的效率取决于搜索过程中元素的比较次数。

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

如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立

一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素

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

搜索元素

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

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

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，

构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合 {1，7，6，4，5，9}；设哈希函数为：hash(key) = key % capacity;

capacity为存储元素底层空间总的大小。

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

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

1.2 哈希冲突(碰撞)

（上面的问题，插入44的话应该插入到4的位置，但是4的位置被占用了，这就是哈希冲突(碰撞)）

不同的元素，在往哈希表中存储时，通过哈希函数计算出了相同的位置，

即多个元素要插在同一个位置，（不同关键字通过相同哈希哈数计算出相同的哈希地址）

该种现象称为哈希冲突或哈希碰撞。

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

1.3 哈希函数

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

哈希函数设计原则：

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

其值域必须在0到m - 1之间哈希函数计算出来的地址能均匀分布在整个空间中。

哈希函数应该比较简单，常见哈希函数：

1. 直接定址法(常用)

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

优点：简单、均匀

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

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

下面这种不连续的就不适用，因为浪费了很多空间：（存6个数开了1000个空间）

2. 除留余数法(常用)

（上面的问题用除留余数法就能很好解决，把999存到下标9的位置...）

设散列表中允许的地址数为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. 闭散列/开散列解决哈希冲突

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

2.1 闭散列概念和代码

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，

说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。

那如何寻找下一个空位置呢？

2.1.1 闭散列线性探测（实现）

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

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

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

插入

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

如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，

使用线性探测找到下一个空位置，插入新元素

删除

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素

会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。

因此线性探测采用标记的伪删除法来删除一个元素。哈希表每个空间给个标记

EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除，这里用枚举：

enum State { EMPTY, EXIST, DELETE };

扩容

如果哈希表满了呢，此时新插入的数据就没有位置放了，所以必须进行扩容。

哈希表是否扩容是根据负载/载荷因子来决定的，一般情况当负载因子约为0.7~0.8时进行扩容。

负载/载荷因子 = 哈希表中有效数据的个数 / 哈希表的大小。

之所以按照负载因子来扩容，是为了减轻哈希碰撞。

负载因子越小，冲突概率越小，消耗空间越多。
负载因子越大，冲突概率越大，空间利用率越高。

到这先写闭散列线性探测的一部分：

哈希表的底层使用vector，这样可以非常方便的进行扩容，获取哈希表大小等操作。

为了方便实例化vector，使用typedef将存放的数据重命名为Data。

#pragma once

#include <iostream>
#include <vector>
using namespace std;

enum State
{
	EMPTY,
	EXIST,
	DELETE
};

template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};

template<class K, class V>
class HashTable
{
public:
	bool Insert(const pair<K, V>& kv)
	{
		//if (Find(kv.first)) // 查找后面写
		//{
		//	return false;
		//}

		//if (_table.size() == 0 || 10 * _size / _table.size() >= 7) // 负载因子到了就扩容
		//{
		//	size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		//	vector<HashData<K, V>> newTables; //创建一个vector，很麻烦，所以用下面的方法(复用了)
		//	newTables.resize(newSize);
		//	
		//	for () // 旧表的数据映射到新表
		//	{
		//	}
		//}

		if (_tables.size() == 0 || 10 * _size / _tables.size() >= 7) // 负载因子到了就扩容
		{
			size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			HashTable<K, V> newHT;
			newHT._tables.resize(newSize);

			for (const auto& e : _tables) // 旧表的数据映射到新表
			{
				if (e._state == EXIST)
				{
					newHT.Insert(e._kv);
				}
			}

			_tables.swap(newHT._tables);
		}

		size_t hashi = kv.first % _tables.size(); // 如果是负数会整形提升成无符号再取模，没问题

		while (_tables[hashi]._state == EXIST) // 线性探测
		{
			hashi++;
			hashi %= _tables.size();
		}

		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_size;

		return true;
	}
protected:
	//vector<pair<K, V>> _tables; 为了弄标志位，弄成下一行
	vector<HashData<K, V>> _tables;
	size_t _size = 0; // 存储有效数据的个数
};

判断负载因子时，如果用_n/size()的话，得到的值始终都是0，因为是两个整数相除，

所以将使用扩大十倍的方式来判断负载因子大于0.7。

扩容后，并不是简单的将旧表中的数据复制到新表中，

还需要按照新容量得到的映射关系来存放数据。

这里巧妙地进行了复用，创建一个新哈希表，容量设置为原本的二倍，

然后复用Insert将旧表中的数据插入到新表中。

现在动手写查找：

根据key值在哈希表中进行查找时，必须根据哈希函数的映射方式去查找，

这样才能符合哈希表设计的初衷。

拿着key值，按照哈希函数的映射关系直接定位到哈希表的位置，

这一步是让哈希表查找效率是O(1)的关键。
在查找过程中，不仅要比较key值，还要看位置的状态，有可能key值相同，

但是状态是DELETE，此时就不能算作找到，只有key相同，并且状态是TSIST才算是找到。

查找到状态是EMPTY即可，否则就成了遍历了，这样仍然能保证查找的此时是常数次。

删除上面讲了，现在随便把删除写了，然后写个打印函数，HashTable.h：

#pragma once

#include <iostream>
#include <vector>
using namespace std;

enum State
{
	EMPTY,
	EXIST,
	DELETE
};

template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};

template<class K, class V>
class HashTable
{
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (Find(kv.first))
		{
			return false;
		}

		//if (_table.size() == 0 || 10 * _size / _table.size() >= 7) // 负载因子到了就扩容
		//{
		//	size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		//	vector<HashData<K, V>> newTables; //创建一个vector，很麻烦，所以用下面的方法(复用了)
		//	newTables.resize(newSize);
		//	
		//	for () // 旧表的数据映射到新表
		//	{
		//	}
		//}

		if (_tables.size() == 0 || 10 * _size / _tables.size() >= 7) // 负载因子到了就扩容
		{
			size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			HashTable<K, V> newHT;
			newHT._tables.resize(newSize);

			for (const auto& e : _tables) // 旧表的数据映射到新表
			{
				if (e._state == EXIST)
				{
					newHT.Insert(e._kv);
				}
			}

			_tables.swap(newHT._tables);
		}

		size_t hashi = kv.first % _tables.size(); // 如果是负数会整形提升成无符号再取模，没问题

		while (_tables[hashi]._state == EXIST) // 线性探测
		{
			hashi++;
			hashi %= _tables.size();
		}

		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_size;

		return true;
	}

	HashData<K, V>* Find(const K& key)
	{
		if (_size == 0)
		{
			return nullptr;
		}

		size_t start = key % _tables.size();
		size_t hashi = start;
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
			{
				return &_tables[hashi];
			}

			hashi++;
			hashi %= _tables.size();

			if (start == hashi) // 防止极端情况：状态全是删除，当hashi回到初始时就跳出
			{
				break;
			}
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		HashData<K, V>* ret = Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			--_size;
			return true;
		}
		else
		{
			return false;
		}
	}

	void Print()
	{
		for (size_t i = 0; i < _tables.size(); ++i)
		{
			if (_tables[i]._state == EXIST)
			{
				printf("[%d:%d] ", i, _tables[i]._kv.first);
			}
			else
			{
				printf("[%d:*] ", i); // 星号代表存储的是无效数据
			}
		}
		cout << endl;
	}
protected:
	//vector<pair<K, V>> _tables; 为了弄标志位，弄成下一行
	vector<HashData<K, V>> _tables;
	size_t _size = 0; // 存储有效数据的个数
};

测试一下，Test.cpp：

#include "HashTable.h"

void TestHash1()
{
	int arr[] = { 1, 11, 4, 15, 26, 7, 44 }; // 在加一个数据就会扩容
	HashTable<int, int> ht;
	for (const auto& e : arr)
	{
		ht.Insert(make_pair(e, e));
	}
	ht.Print();

	ht.Erase(4);
	cout << ht.Find(44) << endl; // ht.Find(44)->_kv.first就能取出数据
	cout << ht.Find(100) << endl; // 不过要先判断是否为空，否则会崩
	cout << ht.Find(4) << endl;
	ht.Print();

	ht.Insert(make_pair(-2, -2));
	ht.Print();

	cout << ht.Find(-2) << endl;
}

int main()
{
	TestHash1();

	return 0;
}

现在还有一个问题，如果想测试下面这组测试用例呢？

void TestHash2()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

	HashTable<string, int> countHT;
	for (const auto& str : arr)
	{
		auto ptr = countHT.Find(str);
		if (ptr)
		{
			ptr->_kv.second++;
		}
		else
		{
			countHT.Insert(make_pair(str, 1));
		}
	}
}

上面我们写的插入，都是针对int类型的数据，也只有整形数据才能使用除留余数法，

才能进行取模，从而得到映射关系，如果插入的数据不是整形，

而是string呢？又或者是其他自定义类型呢？此时就使用仿函数的方法，

“将任何类型都转换成整形”，这里的转换只是为了除留余数法能够使用。

负数，浮点数，指针等可以直接强制转，string要怎么转呢？

可以用首字母的ASCII码比较，但是重复的太多，可以把全部字母的ASCII码加起来，

这样重复还是挺多的，比如abcd，bacd，cabd ... ，eat，ate等等，

就有人研究了一种方法：把全部字母的ASCII码乘以一个数再加起来：

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key; // 负数，浮点数，指针等可以直接转，string不行
	}
};

template<>
struct HashFunc<string> // 上面的特化
{
	size_t operator()(const string& key)
	{
		size_t val = 0;
		for (const auto& ch : key)
		{
			val *= 131;
			val += ch;
		}

		return val;
	}
};

上面代码是一个仿函数，用来将string转换成int，去进行除留余数法进行映射。

string中的每个字符的ASCII码乘以131，然后再加起来。

相乘的数字可以是31，131，1313等等，这是专门经过研究的，比随意相乘一个数字好很多。

最后再哈希表加上一个模板，再把对key取模的地方改一下，闭散列线性探测代码就出来了：

闭散列线性探测完整代码

HashTable.h：

#pragma once

#include <iostream>
#include <vector>
using namespace std;

enum State
{
	EMPTY,
	EXIST,
	DELETE
};

template<class K, class V>
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;
};

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key; // 负数，浮点数，指针等可以直接转，string不行
	}
};

template<>
struct HashFunc<string> // 上面的特化
{
	size_t operator()(const string& key)
	{
		size_t val = 0;
		for (const auto& ch : key)
		{
			val *= 131;
			val += ch;
		}

		return val;
	}
};

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (Find(kv.first))
		{
			return false;
		}

		//if (_table.size() == 0 || 10 * _size / _table.size() >= 7) // 负载因子到了就扩容
		//{
		//	size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
		//	vector<HashData<K, V>> newTables; //创建一个vector，很麻烦，所以用下面的方法(复用了)
		//	newTables.resize(newSize);
		//	
		//	for () // 旧表的数据映射到新表
		//	{
		//	}
		//}

		if (_tables.size() == 0 || 10 * _size / _tables.size() >= 7) // 负载因子到了就扩容
		{
			size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			HashTable<K, V> newHT;
			newHT._tables.resize(newSize);

			for (const auto& e : _tables) // 旧表的数据映射到新表
			{
				if (e._state == EXIST)
				{
					newHT.Insert(e._kv);
				}
			}

			_tables.swap(newHT._tables);
		}

		Hash hs;
		size_t hashi = hs(kv.first) % _tables.size(); // 如果是负数会整形提升成无符号再取模，没问题

		while (_tables[hashi]._state == EXIST) // 线性探测
		{
			hashi++;
			hashi %= _tables.size();
		}

		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_size;

		return true;
	}

	HashData<K, V>* Find(const K& key)
	{
		if (_size == 0)
		{
			return nullptr;
		}

		Hash hs;
		size_t start = hs(key) % _tables.size();
		size_t hashi = start;
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hashi]._state != DELETE && _tables[hashi]._kv.first == key)
			{
				return &_tables[hashi];
			}

			hashi++;
			hashi %= _tables.size();

			if (start == hashi) // 防止极端情况：状态全是删除，当hashi回到初始时就跳出
			{
				break;
			}
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		HashData<K, V>* ret = Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			--_size;
			return true;
		}
		else
		{
			return false;
		}
	}

	void Print()
	{
		for (size_t i = 0; i < _tables.size(); ++i)
		{
			if (_tables[i]._state == EXIST)
			{
				printf("[%d:%d] ", i, _tables[i]._kv.first);
			}
			else
			{
				printf("[%d:*] ", i); // 星号代表存储的是无效数据
			}
		}
		cout << endl;
	}
protected:
	//vector<pair<K, V>> _tables; 为了弄标志位，弄成下一行
	vector<HashData<K, V>> _tables;
	size_t _size = 0; // 存储有效数据的个数
};

Test.cpp:

#include "HashTable.h"

void TestHash1()
{
	int arr[] = { 1, 11, 4, 15, 26, 7, 44 }; // 在加一个数据就会扩容
	HashTable<int, int> ht;
	for (const auto& e : arr)
	{
		ht.Insert(make_pair(e, e));
	}
	ht.Print();

	ht.Erase(4);
	cout << ht.Find(44) << endl; // ht.Find(44)->_kv.first就能取出数据
	cout << ht.Find(100) << endl; // 不过要先判断是否为空，否则会崩
	cout << ht.Find(4) << endl;
	ht.Print();

	ht.Insert(make_pair(-2, -2));
	ht.Print();

	cout << ht.Find(-2) << endl;
}

void TestHash2()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

	HashTable<string, int> countHT;
	for (const auto& str : arr)
	{
		auto ptr = countHT.Find(str);
		if (ptr)
		{
			ptr->_kv.second++;
		}
		else
		{
			countHT.Insert(make_pair(str, 1));
		}
	}
}

int main()
{
	TestHash2();

	return 0;
}

平平无奇的仿函数又发挥了关键的作用，监视里看：

2.1.2 闭散列二次探测（了解）

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

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

线性探测：start + i，i = 0，1，2，3…
二次探测：start + i^2，i = 0，1，2，3…

使用二次探测，查找时也是按照二次探测的方式去查找。

研究表明：

当表的长度为质数且表装载因子不超过0.5时，新的表项一定能够插入，

而且任何一个位置都不会被探查两次。

因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子不超过0.5，如果超出必须考虑增容。

无论是线性探测还是二次探测，闭散列方式的最大缺陷就是空间利用率较低。

所以就引出了下面开散列（哈希桶）的概念。

2.2 开散列(哈希桶)概念和代码

开散列：又叫拉链法(链地址法)，首先对key值集合用哈希函数计算映射下标，

具有相同下标的key值归于同一子集合，每一个子集合称为一个桶，

各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

如上图所示，此时的哈希表中存放的是一个单链表的头指针。

不同的数据，根据哈希函数算出的映射位置发生哈希碰撞时，这些碰撞的数据会挂在哈希表对应位置指向的单链表中。这些单链表被形象称为桶。
每个桶中放的都是发生哈希冲突的元素。
当有新数据插入时，进行头插。

如上图中所示，7，27，57，根据哈希函数都映射到哈希表下标为7的位置，这几个数据按照头插的顺序以单链表的形式挂在哈希表下标为7的位置。

新插入的数据如果尾插的话，在找单链表的尾部时，会有效率损失，由于没有排序要求，所以头插是效率最高的。

开散列的方法，通常被称为哈希桶，使用的也最广泛，能够解决闭散列中空间利用率不高的问题。

哈希桶会不会出现时间复杂度为O（N）的情况？极端情况是会的，但是概率极低，像前面十个空间，扩容了还会把数据分散，开了很多空间的时候，几乎不会出现极端情况，有些库还有一些备案，比如Java库：挂的桶大于8的话（这里也表明挂的桶基本是很少的），就改成挂红黑树。

基于以上原因，哈希桶和快排一样，可以不看最坏时间复杂度，而看平均复杂度：O（1）。

数据类型定义和框架（这里用HashBucket命名空间包起来，把前面的用CloseHash包起来）：

namespace HashBucket
{
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode* _next; // 不用存状态栏了，存下一个结点指针
	};

	template<class K>
	struct HashFunc // 可以把闭散列的HashFunc放在外面直接用，但是这就不放出来了
	{
		size_t operator()(const K& key)
		{
			return (size_t)key; // 负数，浮点数，指针等可以直接转，string不行
		}
	};

	template<>
	struct HashFunc<string> // 上面的特化
	{
		size_t operator()(const string& key)
		{
			size_t val = 0;
			for (const auto& ch : key)
			{
				val *= 131;
				val += ch;
			}

			return val;
		}
	};

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		typedef HashData<K, V> Node;

	protected:
		vector<Node*> _tables; // 指针数组
		size_t _size;
	};
}

采用哈希桶的方式来解决哈希碰撞时，哈希表中存放的数据是单链表的头节点，

链表节点中有键值对，还有下一个节点的指针。仍然使用闭散列中转换整形的仿函数。

插入：

插入首先要去重（用查找），然后检查是否要扩容，最后再插入

先写查找：

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

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

根据哈希函数的映射关系，直接找到key值哈希表中的存放位置。
然后在该位置挂的桶中寻找key值。

哈希桶结构，查找的效率高就高在这里，可以直接根据key值定位哈希表，时间复杂度是O(1)。

现在写插入，哈希桶的方式中也会扩容，否则桶就会越挂越长，违背了哈希桶设计的初衷。

一般情况下，当哈希表的负载因子等于1的时候，发生扩容。

当负载因子等于1时，也就是数据个数和哈希表大小相等的时候进行扩容。

扩容和闭散列类似，将旧的哈希表中的数据插入到新哈希表中，

复用Insert函数，然后旧表被释放，新表留下来。

但是这种方式不是很好，有很大的开销，效率有所损失：

在将旧表中的数据插入新表的时候，每插入一个，新表就需要new一个节点，

旧表中的所有节点都会被new一遍。然后将旧表中的所有节点再释放，

这里做了没必要的工作。相同的一个节点，会先在新表中new一个，再释放旧表的。

新表中完全可以不再new新的节点，直接使用旧表中的节点。

旧表中可以直接复用的节点是：改变了哈希表容量以后，映射关系不变的节点。

比如节点27，哈希表的容量从10变成20，但是映射后的下标仍然是7，这样的节点就可以复用。

那些映射关系变了的节点就不可以直接复用了，需要改变所在桶的位置。

如节点18，哈希表的容量从10变成20，映射后的下标从8变成18，此时就需要改变18所在的桶了。

		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}

			Hash hs;
			if (_size == _tables.size()) // 负载因子到1就扩容
			{
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> newTables;
				newTables.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 = hs(cur->_kv.first) % newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

				_tables.swap(newTables);
			}

			size_t hashi = hs(kv.first) % _tables.size(); // 哈希映射
			Node* newnode = new Node(kv); // 头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_size;
		}

写完插入和查找，现在写写删除：

这里的删除就类似链表的删除，哈希表挂的桶是单链表，只指定要删除节点是无法进行删除的，

必须指定前一个节点，否则无法再链接。所以不能直接复用Find删除：

		bool Erase(const K& key)
		{
			if (_tables.size() == 0) // 防止除零错误
			{
				return false;
			}

			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr) // 头插，先把指针数组存的指针指向cur的下一个
					{
						_tables[hashi] = cur->_next;
					}
					else // 中间删
					{
						prev->_next = cur->_next;
					}
					delete cur; // 统一在这delete
					return true;
				}

				prev = cur; // 往后走
				cur = cur->_next;
			}
			return false; // 没找到
		}

根据哈希函数的映射关系，定位到对应哈希表中挂的某个桶上。
如果key是单链表的头节点，直接让它的下一个节点当头节点就可以。
如果key不是头节点，则在删除的时候，需要prev指针的辅助来链接单链表。
由于哈希映射的存在，在寻找key时的时间复杂度同样是O(1)，所以删除的效率也很高。

写到这并且想测试，我们应该意识到写个析构函数了，哈希桶必须有析构函数，闭散列的方式，

默认生成的析构函数就能满足要求，但是哈希桶不可以。如果只使用默认生成的析构函数，

在哈希桶销毁的时候，默认的析构函数会调用vector的析构函数。

vector的析构函数只会释放vector的本身，而不会释放vector上挂着的桶。

所以需要显示定义析构函数，在析构函数中将vector挂的桶进行释放。

在释放的时候，需要将单链表的下一个节点记录下来，再释放当前节点，

否则会找不到下一个节点。

		~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;
			}
		}

测试：

void TestHash3() // 哈希桶测试统计次数的可以用TestHash2改下命名空间
{
	int arr[] = {1, 11, 4, 15, 26, 7, 44, 55, 99, 78};
	HashBucket::HashTable<int, int> ht;
	for (const auto& e : arr)
	{
		ht.Insert(make_pair(e, e));
	}

	ht.Insert(make_pair(22, 22)); // 刚好扩容
}

2.2.1 除留余数法获取素数

有研究表面，哈希表的大小最好是一个素数，这样的话能够提供哈希结构的效率，

那么如何快速获取一个类似两倍关系的素数呢？

		inline size_t __stl_next_prime(size_t n)
		{
			static const size_t __stl_num_primes = 28;
			static const size_t __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 (size_t i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > n)
				{
					return __stl_prime_list[i];
				}
			}

			return -1; // 不会走到这，随便返回一个值
		}

上面代码是STL库中获取素数的方式。

将素数放在一个数组中，两个素数之间的关系接近二倍，但是又要符合是一个素数。
当需要进行扩容时，就从数组中寻找一个比当前素数大的素数作为新的容量。
上面数组中虽然只有28个素数，但是完全够用了，最大的素数意味着哈希表有4GB个数据，每个数据是一个指针(32位)，也就是4B大小，这样来看已经有16GB的数据量了，再考虑上挂的桶中的数据，数据量是非常大，正常情况下根本没有这么大量的数据。

如果不信讲的复杂度为O（1）的那个，因为这取决于最大桶的长度，

这里可以写几个获取桶个数，最大桶个数，数据个数，表长度来验证验证：

		size_t Size() // 存的数据个数
		{
			return _size;
		}

		size_t TablesSize() // 表的长度
		{
			return _tables.size();
		}

		size_t BucketNum() // 桶的个数
		{
			size_t num = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				if (_tables[i]) // 如果不是空就有桶
				{
					++num;
				}
			}
			return num;
		}

		size_t MaxBucketLenth() // 最长桶的长度
		{
			size_t maxLen = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				size_t len = 0;
				Node* cur = _tables[i];
				while (cur)
				{
					++len;
					cur = cur->_next;
				}
				if (len > maxLen)
				{
					maxLen = len;
				}
			}
			return maxLen;
		}

2.2.2 开散列(哈希桶)完整代码

HashTable.h：（把上面写的闭散列CloseHash命名空间的删了）

#pragma once

#include <iostream>
#include <vector>
using namespace std;

namespace HashBucket
{
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode* _next; // 不用存状态栏了，存下一个结点指针

		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			, _next(nullptr)
		{}
	};

	template<class K>
	struct HashFunc // 可以把闭散列的HashFunc放在外面直接用，但是这就不放了
	{
		size_t operator()(const K& key)
		{
			return (size_t)key; // 负数，浮点数，指针等可以直接转，string不行
		}
	};

	template<>
	struct HashFunc<string> // 上面的特化
	{
		size_t operator()(const string& key)
		{
			size_t val = 0;
			for (const auto& ch : key)
			{
				val *= 131;
				val += ch;
			}

			return val;
		}
	};

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		typedef HashNode<K, V> Node;

		~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;
			}
		}

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

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

		inline size_t __stl_next_prime(size_t n)
		{
			static const size_t __stl_num_primes = 28;
			static const size_t __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 (size_t i = 0; i < __stl_num_primes; ++i)
			{
				if (__stl_prime_list[i] > n)
				{
					return __stl_prime_list[i];
				}
			}

			return -1; // 不会走到这，随便返回一个值
		}

		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}

			Hash hs;
			if (_size == _tables.size()) // 负载因子到1就扩容
			{
				//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> newTables;
				//newTables.resize(newSize, 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 = hs(cur->_kv.first) % newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

				_tables.swap(newTables);
			}

			size_t hashi = hs(kv.first) % _tables.size(); // 哈希映射
			Node* newnode = new Node(kv); // 头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_size;
			return true;
		}

		bool Erase(const K& key)
		{
			if (_tables.size() == 0) // 防止除零错误
			{
				return false;
			}

			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr) // 头插，先把指针数组存的指针指向cur的下一个
					{
						_tables[hashi] = cur->_next;
					}
					else // 中间删
					{
						prev->_next = cur->_next;
					}
					delete cur; // 统一在这delete
					return true;
				}

				prev = cur; // 往后走
				cur = cur->_next;
			}
			return false; // 没找到
		}

		size_t Size() // 存的数据个数
		{
			return _size;
		}

		size_t TablesSize() // 表的长度
		{
			return _tables.size();
		}

		size_t BucketNum() // 桶的个数
		{
			size_t num = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				if (_tables[i]) // 如果不是空就有桶
				{
					++num;
				}
			}
			return num;
		}

		size_t MaxBucketLenth() // 最长桶的长度
		{
			size_t maxLen = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				size_t len = 0;
				Node* cur = _tables[i];
				while (cur)
				{
					++len;
					cur = cur->_next;
				}
				if (len > maxLen)
				{
					maxLen = len;
				}
			}
			return maxLen;
		}

	protected:
		vector<Node*> _tables; // 指针数组
		size_t _size;
	};
}

Test.cpp：

#include "HashTable.h"

void TestHash1()
{
	int arr[] = { 1, 11, 4, 15, 26, 7, 44 }; // 在加一个数据就会扩容
	CloseHash::HashTable<int, int> ht;
	for (const auto& e : arr)
	{
		ht.Insert(make_pair(e, e));
	}
	ht.Print();

	ht.Erase(4);
	cout << ht.Find(44) << endl; // ht.Find(44)->_kv.first就能取出数据
	cout << ht.Find(100) << endl; // 不过要先判断是否为空，否则会崩
	cout << ht.Find(4) << endl;
	ht.Print();

	ht.Insert(make_pair(-2, -2));
	ht.Print();

	cout << ht.Find(-2) << endl;
}

void TestHash2()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

	//CloseHash::HashTable<string, int> countHT;
	HashBucket::HashTable<string, int> countHT;
	for (const auto& str : arr)
	{
		auto ptr = countHT.Find(str);
		if (ptr)
		{
			ptr->_kv.second++;
		}
		else
		{
			countHT.Insert(make_pair(str, 1));
		}
	}
}

void TestHash3() // 哈希桶测试统计次数的可以用TestHash2改下命名空间
{
	int arr[] = {1, 11, 4, 15, 26, 7, 44, 55, 99, 78};
	HashBucket::HashTable<int, int> ht;
	for (const auto& e : arr)
	{
		ht.Insert(make_pair(e, e));
	}

	ht.Insert(make_pair(22, 22));
}

void TestHash4()
{
	int n = 10000;
	vector<int> v;
	v.reserve(n);
	srand(time(0));
	for (int i = 0; i < n; ++i)
	{
		//v.push_back(i);
		v.push_back(rand() + i);  // 重复少
		//v.push_back(rand());  // 重复多
	}

	size_t begin1 = clock();
	HashBucket::HashTable<int, int> ht;
	for (auto e : v)
	{
		ht.Insert(make_pair(e, e));
	}
	size_t end1 = clock();

	cout << "数据个数:" << ht.Size() << endl;
	cout << "表的长度:" << ht.TablesSize() << endl;
	cout << "桶的个数:" << ht.BucketNum() << endl;
	cout << "平均每个桶的长度:" << (double)ht.Size() / (double)ht.BucketNum() << endl;
	cout << "最长的桶的长度:" << ht.MaxBucketLenth() << endl;
	cout << "负载因子:" << (double)ht.Size() / (double)ht.TablesSize() << endl;
}

int main()
{
	TestHash2();
	TestHash3();
	TestHash4();

	return 0;
}

没测TestHash4的：

测TestHash4的：

这是测了几次的结果：（随着负载因子的变大，桶最长也就2或3，因为桶的个数太多了）

多测了几个数量级的n，发现最长的桶的长度也就4：

3. 开散列与闭散列比较

开散列也就是哈希桶，看起来每个节点中多了一个指针，比闭散列存放的数据大，但是它空间利用率高，负载因子大于1的时候才会扩容。

闭散列方式中必须有大量的空闲空间来保证搜索的效率，二次探测甚至要求负载因子必须小于等于0.7，并且表项所占的空间比哈希桶大的多。

在空间利用率上，哈希桶比闭散列更有优势。
在搜索上效率上，无论是开散列还是闭散列，都会通过哈希函数的映射关系之间在定位在表项中，然后在查询常数次，所以这两种方式的时间复杂度都是O（1）。

只是闭散列中，负载因子越多，哈希碰撞的概率就越大，查找时耗费的时间就比哈希桶长。

综合考虑，哈希结构的底层大多使用哈希桶结构，也就是开散列方式。
而且当有极端情况：哈希桶的单链表很长时，可以将挂的桶改成红黑树结构来提高效率。

前面我们测试过unordered_set（哈希表）接口的速率，慢的也只是插入，因为插入要扩容，如果提前知道要插入多少数据，提前reserve一下，插入效率能比se（红黑树）t还好一点。

总结：
哈希表中，尤其值得我们学习的地方，一个是闭散列中，使用一个状态标志来标识哈希表中元素的状态，还有就是使用仿函数来将自定义类型转换成整形用于除留余数法。

虽然很大的篇幅在写闭散列，但是哈希桶才是高频使用的结构，而且哈希桶是建立在闭散列的基础上改进的。

4. 哈希笔试选择题

1. 下面关于哈希说法正确的是（）

A .哈希是一种查找的方法，不是数据结构

B .采用哈希方式解决问题时，可以不用哈希函数

C .哈希查找的时间复杂度一定是O(1)

D .哈希是以牺牲空间为代价，提高查询的效率

2. 散列文件使用散列函数将记录的关键字值计算转化为记录的存放地址。由于散列函数不是一对一的关系，所以选择好的（）方法是散列文件的关键。

A .散列函数

B .除余法中的质数

C .冲突处理

D .散列函数和冲突处理

3. 散列函数有一个共同性质，即函数值应按（）取其值域的每一个值。

A .最大概率

B .最小概率

C .同等概率

D .平均概率

4. 解决散列法中出现冲突问题常采用的方法是()

A .数字分析法、除余法、平方取中法

B .数字分析法、除余法、线性探测法

C .数字分析法、线性探测法、多重散列法

D .线性探测法、多重散列法、链地址法

5. 将10个元素散列到100000个单元的哈希表中,则()产生冲突

A .一定会

B .一定不会

C .仍可能会

D .以上都不对

6. 下面关于哈希冲突说法正确的是（）

A .哈希冲突是可以通过设计好的哈希函数来杜绝的

B .哈希冲突是无法避免的

C .哈希冲突是不同的元素，通过不同的哈希函数而产生相同的哈希地址而引起的

D .哈希冲突产生的原因一定是插入了相同的元素

7. 已知有一个关键字序列：（19，14,23,1,68,20,84,27,55,11,10,79）散列存储在一个哈希表中，若散列函数为H（key）=key%7，并采用链地址法来解决冲突，则在等概率情况下查找成功的平均查找长度为()

A .1.5

B .1.7

C .2.0

D .2.3

8. 已知某个哈希表的n个关键字具有相同的哈希值，如果使用二次探测再散列法将这n个关键字存入哈希表，至少要进行（）次探测。

A .n-1

B .n

C .n+1

D .n(n+1)

E .n(n+1)/2

F .1+n(n+1)/2

9. 采用开放定址法处理散列表的冲突时，其平均查找长度？（）

A .高于链接法处理冲突

B .高于二分查找

C .低于链接法处理冲突

D .低于二分查找

10. 采用线性探测法处理散列时的冲突,当从哈希表删除一个记录时,不应将这个记录的所在位置置空,因为这会影响以后的查找()

A .对

B .错

C .不一定

D .以上说法都不对

11. 用哈希（散列）方法处理冲突（碰撞）时可能出现堆积（聚集）现象，下列选项中，会受堆积现象直接影响的是 ()

A .存储效率

B .数列函数

C .装填（装载）因子

D .平均查找长度

答案

1 D

A：错误，哈希是一种用来进行高效查找的数据结构，查找的时间复杂度平均为O(1)

B：错误，哈希之所以高效，是引用使用了哈希函数将元素与其存储位置之间建立了一一对应的关系，因此必须使用哈希函数

C：错误，不一定，因为存在哈希冲突，一般基本都是O(1)

D：正确，采用哈希处理时，一般所需空间都会比元素个数多，否则产生冲突的概率就比较大，影响哈希的性能

2 D

要使哈希高效：选择好的哈希函数非常关键

好的哈希函数可以减少发生冲突的概率

万一发生冲突，好的处理好戏冲突的方法也比较关键，否则冲突处理不当，也会增加后序元素冲突的概率

3 C

哈希函数设计原则：

  1. 哈希函数应该尽可能简单

  2. 哈希函数的值域必须在哈希表格的范围之内

  3. 哈希函数的值域应该尽可能均匀分布，即取每个位置应该是等概率的

4 D

注意要区分清楚：哈希冲突的处理方法和哈希函数

哈希函数作用是：建立元素与其存储位置之前的对应关系的，在存储元素时，先通过哈希函数计算元素在哈希表格中的存储位置，然后存储元素。好的哈希函数可以减少冲突的概率，但是不能够绝对避免，万一发生哈希冲突，得需要借助哈希冲突处理方法来解决。

常见的哈希函数有：直接定址法、除留余数法、平方取中法、随机数法、数字分析法、叠加法等

常见哈希冲突处理：闭散列（线性探测、二次探测）、开散列(链地址法)、多次散列

5 C

只要想哈希表格中存储的元素超过两个，就有可能存在哈希冲突

6 B

A：错误，哈希冲突是不能杜绝的，这个与存储的元素以及哈希函数相关

B：正确

C：错误，哈希冲突是不同的元素，通过相同的哈希函数而产生相同的哈希地址而引起的，注意仔细看选项

D：错误，不同元素在计算出相同的哈希值时就会冲突

7 A 画出来：

  [0]  [1]  [2]   [3] [4] [5] [6]

  14   1   23   10   11   19   20

  84 79         68 27

55

  14、1、23、10、11、19、20: 比较1次就可以找到

  84、79、68、27：需要比较两次才可以找到

  55: 需要比较三次才可以找到

  总的比较次数为：7+4*2+3=18，总共有12个元素

  故：等概率情况下查找成功的平均查找长度为：18/12 = 1.5