【C++ STL】哈希 Hash（闭散列、开散列介绍及其实现）

一、unordered 系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(log₂N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered 系列的关联式容器，这4个容器与红黑树结构的关联式容器底层结构不同，是哈希表（哈希其实就是一种散列，一种映射）

哈希表结构的 unordered 系列的关联式容器与红黑树结构的关联式容器 map/set/multimap/multiset 使用方式上基本类似，它们的主要区别在于：

• unordered 系列关联式容器，遍历出来不是有序的
• unordered 系列关联式容器，迭代器是单向迭代器
• unordered_map 和 unordered_set 不允许数据冗余，支持 [] 操作符
• unordered_multimap 和 unordered_multiset 允许数据冗余，不支持 [] 操作符

---

二、unordered 系列关联式容器底层结构

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

【示例】set 和 unordered_set 插入效率比较：

// release下测试，debug下可能还会受限于编译器的优化程度，release下是最高优化
void test()
{
   
	// 用n个随机值元素来测试set和unordered_set

	// 定义容量为N的向量
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);

	srand(time(0)); // 初始化随机种子

	for (size_t i = 0; i < N; i++)
	{
   
		v.push_back(rand()); // 插入生成的随机值
	}

	// 定义set和unordered_set
	set<int> s;
	unordered_set<int> us;

    /* ----------------------------------------------------------------- */
	// 向set中插入N个随机值，统计时间(ms)
	size_t begin1 = clock();
	for (auto& e : v)
	{
   
		s.insert(e);
	}
	size_t end1 = clock();

	// 向unordered_set插入N个随机值，统计时间(ms)
	size_t begin2 = clock();
	for (auto& e : v)
	{
   
		us.insert(e);
	}
	size_t end2 = clock();

	cout << "set - inset: " << end1 - begin1 << endl;
	cout << "unordered_set - inset: " << end2 - begin2 << endl;
    
    /* ----------------------------------------------------------------- */
	// 依次去set中查找向量中的N个元素，统计时间(ms)
	size_t begin3 = clock();
	for (auto& e : v)
	{
   
		s.find(e);
	}
	size_t end3 = clock();
	
	// 依次去unordered_set中查找向量中的N个元素，统计时间(ms)
	size_t begin4 = clock();
	for (auto& e : v)
	{
   
		us.find(e);
	}
	size_t end4 = clock();

	cout << "set - find(): " << end3 - begin3 << endl;
	cout << "unordered_set - find(): " << end4 - begin4 << endl;
	
    /* ----------------------------------------------------------------- */
	// 依次删除set中的N个元素，统计时间(ms)
	size_t begin5 = clock();
	for (auto& e : v)
	{
   
		s.erase(e);
	}
	size_t end5 = clock();

	// 依次删除unordered_set中的N个元素，统计时间(ms)
	size_t begin6 = clock();
	for (auto& e : v)
	{
   
		us.erase(e);
	}
	size_t end6 = clock();

	cout << "set - erase(): " << end5 - begin5 << endl;
	cout << "unordered_set - erase(): " << end6 - begin6 << endl;
}

用同一批100万个数据来测试 unordered_set 和 set，结果分析如下：

可以看出在数据量大的时候，插入和查找元素 unordered_set 要比 set 快一些，而删除元素 unordered_set 要比 set 慢一些。

所以一般情况下，建议使用 unordered 系列的关联式容器。

---

2.1 哈希概念

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

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数 ( hashFunc ) 使 元素的存储位置与它的关键码之间能够建立一一映射的关系 ，那么在查找时通过该函数可以很快找到该元素。方便我们搜索。

当向该结构中：

• 插入元素

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

• 搜索元素

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

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

哈希表就好比一本的目录，通过目录我们可以知道某章节的页码，通过页码快速定位到那一章节。

---

2.2 哈希函数

其实就是按照某种规则，给元素找一个存储位置（哈希位置、映射位置）

【常见哈希函数】

1、直接定址法（常用）

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

优点：简单、均匀

缺点：需要事先知道关键字的分布情况，如果关键字的分布比较分散，会很浪费空间

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

比如：

• 计数排序
• 一些OJ题中用哈希映射来统计字符出现次数（387. 字符串中的第一个唯一字符）
• 利用字符的ASCII码值来映射字符，利用int型变量的数值来映射该变量

---

2、除留余数法（常用）

开一段固定大小的空间，比如哈希表中允许的地址数为 n，按照哈希函数：Hash(key) = key % n，得到的余数就是该关键码的哈希地址，存放到哈希表对应位置中。

缺陷：

• 适用于整数的存储（字符串、浮点数不能直接存储，因为不能直接取模，后面会讲如何解决）
• 余数相同时，会出现哈希冲突

举例说明：

---

2.3 哈希冲突

不同关键字通过相同哈希哈数计算出相同的哈希地址，映射到了相同位置，该种现象称为哈希冲突或哈希碰撞。

【思考】发生哈希冲突该如何处理呢？

---

2.4 哈希冲突的解决

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

---

三、闭散列

闭散列也叫开放定址法：

开放寻址法的核心思想是，通过哈希函数计算出这个数据对应的哈希位置，如果该位置出现了哈希冲突，我们就重新探测一个空闲位置，将其插入。那如何重新探测新的位置呢？当我们往散列表中插入数据时，如果某个数据经过散列函数散列之后，存储位置已经被占用了，我们就从当前位置开始，依次往后查找，看是否有空闲位置，直到找到为止。如果数组整个都没有空位置，这个时候就需要对数组进行扩容操作。

而我们要获取数据的时候就需要先Hash运算，然后得到下标后再去拿值，拿到值后要比对是不是要拿的数据，因为有可能Hash冲突了，此时的值并不是你想要的，如果是就直接取出，不是的话就需要重新遍历数组，直到找到对应的数。

从上面可以明显的看出来开发寻址法并不是一种好的方案，当最好的情况时查询数据时间复杂度为O(1),而最坏的情况时就需要遍历整个数组从而退化为O(n)，平均时间复杂度为O(1)。

---

3.1 找下一个空位置

当前哈希位置已经存放的有数据了，下一个元素也是映射的这个位置，发生哈希冲突了，那怎么办呢？

• 如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把该元素存放到冲突位置的 “ 下一个空位置 ” 中去。
• 如果整个数组都没有空位置了，这个时候就需要对数组进行扩容操作。

找下一个空位置有两种方法：线性探测和二次线性探测。

① 线性探测

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

---

举例说明，插入最后一个数据 333 时，产生了哈希冲突：

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

线性探测的缺陷：

如果某个位置冲突的多，会导致一片冲突很多，数据堆积在一起。

插入和查找的效率都会降低很多，插入元素时，从冲突位置开始不断往后找到下一个空位置；查找元素时，从冲突位置开始不断往后找，需要比较许多次，导致搜索效率降低。最坏情况下要直到找到空位置时，才能说明没有该元素。

举例说明：

【思考】

观察发现，冲突的那一块区域，数据很集中，但是其它位置又是空着的，那有没有什么办法，让这些数据稍微分散一点点呢？不要那么集中，于是有人提出了二次探测方法。

---

② 二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hash(key) = key % n + i² ( i = 1,2,3… )，通过哈希函数 Hash(key) 计算出元素的关键码 key 对应的位置再加上 i 的平方，n 是表的大小。

二次探测相比线性探测的好处：

如果一个位置有很多数据冲突，那么二次探测会让这些数据存储位置会比较分散，不会集中在一起，导致一片一片的冲突。

---

举例说明：如果要插入 333 和 33，产生冲突，分别使用线性探测和二次探测，解决后的情况为：

---

3.2 闭散列的实现

哈希表就是数组，只不过是按照某种映射关系把元素存放进去的数组。

问题一：如何向哈希表中插入元素？

• 先检查哈希表是否需要扩容（表为空或表的负载因子超过某个值，则进行扩容）。
• 再通过哈希函数计算出待插入元素在哈希表中的位置：
  • 如果该位置有元素（即存储状态为: EXIST），说明发生了哈希冲突，使用线性探测（或二次探测）找到下一个空位置，然后插入新元素；
  • 如果该位置中没有元素（即存储状态为: EMPTY / DELETE），则直接插入新元素。

问题二：如何在哈希表中查找元素？

先检查哈希表是否为空，若为空，查找失败，直接返回nullptr

再通过哈希函数计算出要查找元素在哈希表中对应的位置：

• 如果该位置不为空（即存储状态为: EXIST / DELETE），开始往后查找，直到遇到空位置才停止（如果遇到空位置都还没查找到，说明哈希表中没有该元素），查找过程中，如果当前位置存储状态为存在，则判断是不是要查找的元素：
  • 如果是，查找成功，返回该元素的地址；
  • 如果不是，继续往后找
• 如果该位置为空（即存储状态为: EMPTY），返回nullptr

问题三：如何表示哈希表中某个位置是否存放的有元素？

肯定不能用 0 / -1 来表示，万一需要存放的数据就有 0 / -1 呢？

问题四：如何删除哈希表中某个位置的元素？

采用闭散列处理哈希