C++ 哈希+unordered_map+unordered_set+位图+布隆过滤器（深度剖析）

---

1. 前言

想象一下，你有一个巨大的图书馆，里面摆满了成千上万本书。如果你想要找到其中一本特定的书，你会怎么做？如果你按照书的编号来有序地排列它们，找到特定的书本可能会很容易。但是，如果书籍是随机地摆放，你可能需要逐本地查找，这个过程会非常耗时。

而哈希函数就像是给每本书分配一个独特的编号，然后将它们放置在合适的位置，使得我们能够快速地找到并访问它们。哈希函数能够将输入数据映射到一个固定大小的哈希表中，每个元素都有一个唯一的位置。当我们需要查找特定的元素时，只需使用哈希函数计算出它的位置，然后直接访问该位置的元素，无需遍历整个数据集。

这种基于哈希的快速查找技术在现代编程中非常常见。在本篇博客中，我们将深入剖析哈希相关的知识点。

本篇文章将着重讲解 unordered 系列关联式容器（unordered_map 和 unordered_set）、底层结构（哈希的概念、哈希函数、哈希冲突）、模拟实现（unordered_map 和 unordered_set 的模拟实现）以及哈希的应用（位图和布隆过滤器）。

2. unordered 系列关联式容器

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

2.1 unordered_map

2.1.1 unordered_map 的概念

英文解释：

也就是说：

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

2. 在 unordered_map 中，键值通常用于唯一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。

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

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

5. unordered_map 实现了直接访问操作符（operator[]），它允许使用 key 作为参数直接访问 value。

6. 它的迭代器至少是单向迭代器。

2.1.2 unordered_map 的使用

1. unordered_map 的模板参数列表

   

   说明：

   • key：键值对中 key 的类型。
   • T：键值对中 value 的类型。
   • Hash：哈希函数用于确定元素在内部数据结构中的位置。
   • Pred：键相等判断函数用于比较两个键是否相等。
   • Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器。

2. unordered_map 的构造函数

   函数声明	功能介绍
   unordered_map	构造不同格式的 unordered_map 对象。

3. unordered_map 的容量操作

   函数名称	函数声明	功能简介
   empty	bool empty () const;	检测 unordered_map 中的元素是否为空，是返回 true，否则返回 false。
   size	size_t size() const;	返回 unordered_map 中有效元素的个数。

4. unordered_map 的元素访问操作

   函数名称	函数声明	功能简介
   operator[]	mapped_type& operator[] (const key_type& k);	返回 k 对应的 value。
   at	mapped_type& at (const key_type& k); const mapped_type& at (const key_type& k) const;	返回 k 对应的 value。

   区分：

   在元素访问时，有一个与 operator[] 类似的操作 at 函数（该函数不常用），都是通过 key 找到与 key 对应的 value 然后返回其引用，不同的是：当 key 不存在时，operator[] 用默认 value 与 key 构造键值对然后插入，返回该默认 value；at 函数直接抛异常。

5. unordered_map 的查找操作

   函数名称	函数声明	功能介绍
   find	iterator find (const key_type& k); const_iterator find (const key_type& k) const;	在 unordered_map 中查找 key 为 k 的元素，找到返回该元素位置的迭代器，否则返回 end。 在 unordered_map 中查找 key 为 k 的元素，找到返回该元素位置的 const 迭代器，否则返回 cend。
   count	size_t count (const key_type& k) const;	返回 unordered_map 中值为 k 的键值在 map 中的个数（这里只会返回0或1）。

6. unordered_map 的修改操作

   函数名称	函数声明	功能介绍
   insert	pair<iterator,bool> insert (const value_type& val);	在 unordered_map 中插入键值对 val。如果插入成功，返回 <val 位置的迭代器，true>；如果插入失败，说明 val 在 unordered_map 中已经存在，返回 <val 位置的迭代器，false>。
   erase	iterator erase (const_iterator position); size_t erase (const key_type& k);	删除 unordered_map 中 position 位置上的元素，并返回一个指向被删除元素之后位置的迭代器。 删除 unordered_map 中键值为 k 的元素，返回删除的元素的个数（这里只会返回0或1）。
   swap	void swap (unordered_map& ump);	与 ump 交换元素。
   clear	void clear();	将 map 的元素清空。

7. unordered_map 的桶操作

   函数名称	函数声明	功能介绍
   bucket_count	size_t bucket_count() const	返回哈希桶中桶的总个数。
   bucket_size	size_t bucket_size(size_t n) const	返回 n 号桶中有效元素的总个数。
   bucket	size_t bucket(const key_type& k)	返回元素 k 所在的桶号。

2.2 unordered_set

2.2.1 unordered_set 的概念

英文解释：

也就是说：

1. unordered_set 是一种容器，它以无特定顺序存储唯一元素，并且允许根据 value 快速检索单个元素。

2. 在 unordered_set 中，元素的 value 同时也是唯一标识它的 key。键是不可变的，因此，在容器中的元素一旦插入就不能修改，尽管可以插入和删除。

3. 在内部，unordered_set 中的元素没有按照任何特定的顺序排序，而是根据它们的哈希值被组织到不同的桶中，以便能够通过值快速直接地访问单个元素（平均情况下具有常数时间复杂度）。

4. 与集合容器相比，unordered_set 容器更快地通过 key 访问单个元素，尽管对于对子集进行范围迭代，它们通常不太高效。

5. 容器中的迭代器至少是单向迭代器。

2.2.2 unordered_set 的使用

1. unordered_set 的模板参数列表

   

   说明：

   • T：unordered_set 中存放元素的类型。

   • Hash：哈希函数用于确定元素在内部数据结构中的位置。

   • Pred：键相等判断函数用于比较两个键是否相等。

   • Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器。

2. unordered_set 的构造函数

   函数声明	功能介绍
   unordered_set	构造不同格式的 unordered_set 对象。

3. unordered_set 的容量操作

   函数名称	函数声明	功能介绍
   empty	bool empty() const;	检测 unordered_set 是否为空，空返回 true，否则返回 false。
   size	size_t size() const;	返回 unordered_set 中有效元素的个数。

4. unordered_set 的查找操作

   函数名称	函数声明	功能介绍
   find	iterator find (const value_type& val) const;	在 unordered_set 中查找值为 val 的元素，如果找到则返回该元素位置的迭代器，未找到则返回 end 迭代器。
   count	size_t count (const value_type& val) const;	返回 unordered_set 中值为 val 的元素的个数（这里只会返回0或1）。

5. unordered_set 的修改操作

   函数名称	函数声明	功能介绍
   insert	pair<iterator,bool> insert (const value_type& val);	在 unordered_set 中插入元素 val。如果插入成功，返回 <val 位置的迭代器，true>；如果插入失败，说明 val 在 unordered_set 中已经存在，返回 <val 位置的迭代器，false>。
   erase	iterator erase (const_iterator position); size_t erase (const value_type& val);	删除 unordered_set 中 position 位置上的元素，并返回一个指向被删除元素之后位置的迭代器。 删除 unordered_set 中值为 val 的元素，返回删除的元素的个数（这里只会返回0或1）。
   swap	void swap (unordered_set& ust);	与 ust 交换元素。
   clear	void clear();	将 unordered_set 的元素清空。

6. unordered_set 的桶操作

   函数名称	函数声明	功能介绍
   bucket_count	size_t bucket_count() const	返回哈希桶中桶的总个数。
   bucket_size	size_t bucket_size(size_t n) const	返回 n 号桶中有效元素的总个数。
   bucket	size_t bucket(const key_type& k)	返回元素 k 所在的桶号。

3. 底层结构

3.1 哈希的概念

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

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

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

当向该结构中：

• 插入元素

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

• 搜索元素

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

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

例如：

数据集合：{ 1,7,6,4,5,9 };

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

图解：

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

3.2 哈希冲突

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

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

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

3.3 哈希函数

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

哈希函数设计原则：

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

常见哈希函数

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）等方法。

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

拓展：字符串Hash函数链接。

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

3.4 哈希冲突的解决

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

3.4.1 闭散列

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

1. 线性探测

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

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

   • 插入

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

   • 删除

     采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。

     比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

     像这样：

     // 哈希表每个空间给个标记
     // EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
     enum State {
             EMPTY, EXIST, DELETE};
     

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

   

   线性探测的实现

   template<class K>
   struct HashFunc
   {
         
   	size_t operator()(const K& key)
   	{
         
   		return (size_t)key;
   	}
   };
   
   // 字符串哈希函数特化：HashFunc<string>
   template<>
   struct HashFunc<std::string>
   {
         
   	size_t operator()(const string& key)
   	{
         
   		// BKDR
   		size_t hash = 0;
   		for (auto e : key)
   		{
         
   			hash *= 31;
   			hash += e;
   		}
   
   		return hash;
   	}
   };
   
   namespace open_address
   {
         
   	enum Status
   	{
         
   		EMPTY,
   		EXIST,
   		DELETE
   	};
   
   	template<class K, class V>
   	struct HashData
   	{
         
   		pair<K, V> _kv;
   		Status _s;          //状态
   	};
   
   	template<class K, class V, class Hash = HashFunc<K>>
   	class HashTable
   	{
         
   	public:
   		HashTable()
   		{
         
   			_tables.resize(10);
   		}
   
   		bool Insert(const pair<K, V>& kv)
   		{
         
   			if (Find(kv.first))
   				return false;
   
   			// 负载因子0.7就扩容
   			if (_n * 10 / _tables.size() == 7)
   			{
         
   				size_t newSize = _tables.size() * 2;
   				HashTable<K, V, Hash> newHT;
   				newHT._tables.resize(newSize);
   				// 遍历旧表
   				for (size_t i = 0; i < _tables.size(); i++)
   				{
         
   					if (_tables[i]._s == EXIST)
   					{
         
   						newHT.Insert(_tables[i]._kv);
   					}
   				}
   
   				_tables.swap(newHT._tables);
   			}
   
   			Hash hf;
   			// 线性探测
   			size_t hashi = hf(kv.first) % _tables.size();
   			while (_tables[hashi]._s == EXIST)
   			{
         
   				hashi++;
   
   				hashi %= _tables.size();
   			}
   
   			_tables[hashi]._kv = kv;
   			_tables[hashi]._s = EXIST