---

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;
   			++_n;
   
   			return true;
   		}
   
   		HashData<K, V>* Find(const K& key)
   		{
   			Hash hf;
   
   			size_t hashi = hf(key) % _tables.size();
   			while (_tables[hashi]._s != EMPTY)
   			{
   				if (_tables[hashi]._s == EXIST
   					&& _tables[hashi]._kv.first == key)
   				{
   					return &_tables[hashi];
   				}
   
   				hashi++;
   				hashi %= _tables.size();
   			}
   
   			return nullptr;
   		}
   
   		// 伪删除法
   		bool Erase(const K& key)
   		{
   			HashData<K, V>* ret = Find(key);
   			if (ret)
   			{
   				ret->_s = DELETE;
   				--_n;
   				return true;
   			}
   			else
   			{
   				return false;
   			}
   		}
   
           // 打印观察分布
   		void Print()
   		{
   			for (size_t i = 0; i < _tables.size(); i++)
   			{
   				if (_tables[i]._s == EXIST)
   				{
   					cout << "[" << i << "]->" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << endl;
   				}
   				else if (_tables[i]._s == EMPTY)
   				{
   					printf("[%zd]->\n", i);
   				}
   				else
   				{
   					printf("[%zd]->D\n", i);
   				}
   			}
   
   			cout << endl;
   		}
   
   	private:
   		vector<HashData<K, V>> _tables;
   		size_t _n = 0; // 存储的关键字的个数
   	};
   }
   

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

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

2. 二次探测

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

   对于3.1中如果要插入44，产生冲突，使用解决后的情况为：

   

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

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

3.4.2 开散列

1. 开散列概念

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

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

2. 开散列增容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

3. 开散列实现

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 hash_bucket
{
	template<class K, class V>
	struct HashNode
	{
		HashNode* _next;
		pair<K, V> _kv;

		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()
		{
			_tables.resize(10);
		}

		~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 Size() const
		{
			return _n;
		}

		bool Empty() const
		{
			return _n == 0;
		}

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

			Hash hf;

			// 负载因子最大到1
			if (_n == _tables.size())
			{
				vector<Node*> newTables;
				newTables.resize(_tables.size() * 2, 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) % newTables.size();
						cur->_next = newTables[i];
						newTables[i] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

				_tables.swap(newTables);
			}

			size_t hashi = hf(kv.first) % _tables.size();
			Node* newnode = new Node(kv);

			// 头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;

			return true;
		}

		bool Erase(const K& key)
		{
			Hash hf;
			size_t hashi = hf(key) % _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;
		}

		Node* Find(const K& key)
		{
			Hash hf;
			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}

				cur = cur->_next;
			}

			return nullptr;
		}

		size_t Count(const K& key)
		{
			Hash hf;
			KeyOfT kot;

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

				cur = cur->_next;
			}

			return 0;
		}

		// 桶的总个数
		size_t BucketCount()
		{
			size_t bucketCount = 0;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					++bucketCount;
				}
			}
			return bucketCount;
		}

		// key所在桶的大小
		size_t BucketSize(const K& key)
		{
			Hash hf;
			size_t bucketSize = 0;
			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				++bucketSize;
				cur = cur->_next;
			}
			return bucketSize;
		}

        // 打印信息
		void Some()
		{
			size_t bucketSize = 0;
			size_t maxBucketLen = 0;
			size_t sum = 0;
			double averageBucketLen = 0;

			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur)
				{
					++bucketSize;
				}

				size_t bucketLen = 0;
				while (cur)
				{
					++bucketLen;
					cur = cur->_next;
				}

				sum += bucketLen;

				if (bucketLen > maxBucketLen)
				{
					maxBucketLen = bucketLen;
				}
			}

			averageBucketLen = (double)sum / (double)bucketSize;

			printf("all bucketSize:%d\n", _tables.size());
			printf("bucketSize:%d\n", bucketSize);
			printf("maxBucketLen:%d\n", maxBucketLen);
			printf("averageBucketLen:%lf\n\n", averageBucketLen);
		}

	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};
}

开散列与闭散列比较

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.5，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。

4. 模拟实现

4.1 哈希表的改造

1. 模板参数列表的改造

   // K：关键码类型
   // T：不同容器T的类型不同，如果是unordered_map，T代表一个键值对，如果是unordered_set,T为K。
   // KeyOfT：因为T的类型不同，通过value取key的方式就不同，详细见unordered_map/set的实现。
   // Hash：哈希函数仿函数对象类型，哈希函数使用除留余数法，需要将Key转换为整型数字才能取模。
   template<class T>
   struct HashNode
   {
   	HashNode<T>* _next;
   	T _data;
   
   	HashNode(const T& data)
   		:_data(data)
   		, _next(nullptr)
   	{}
   };
   template<class K, class T, class KeyOfT, class Hash>
   class HashTable;
   

2. 增加迭代器操作

   template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
   struct __HTIterator
   {
   	typedef HashNode<T> Node;
   	typedef __HTIterator<K, T, Ref, Ptr, KeyOfT, Hash> Self;
   	Node* _node;
   	const HashTable<K, T, KeyOfT, Hash>* _pht;
   	size_t _hashi;
   
   	__HTIterator(Node* node, HashTable<K, T, KeyOfT, Hash>* pht, size_t hashi)
   		:_node(node)
   		, _pht(pht)
   		, _hashi(hashi)
   	{}
   
   	__HTIterator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht, size_t hashi)
   		:_node(node)
   		, _pht(pht)
   		, _hashi(hashi)
   	{}
   
   	Self& operator++()
   	{
   		if (_node->_next)
   		{
   			// 当前桶还有节点，走到下一个节点
   			_node = _node->_next;
   		}
   		else
   		{
   			// 当前桶已经走完了，找下一个桶开始
   			++_hashi;
   			while (_hashi < _pht->_tables.size())
   			{
   				if (_pht->_tables[_hashi])
   				{
   					_node = _pht->_tables[_hashi];
   					break;
   				}
   
   				++_hashi;
   			}
   
   			if (_hashi == _pht->_tables.size())
   			{
   				_node = nullptr;
   			}
   		}
   
   		return *this;
   	}
   
   	Ref operator*()
   	{
   		return _node->_data;
   	}
   
   	Ptr operator->()
   	{
   		return &_node->_data;
   	}
   
   	bool operator!=(const Self& s)
   	{
   		return _node != s._node;
   	}
   };
   

3. 改造后代码实现

   template<class K, class T, class KeyOfT, class Hash>
   class HashTable
   {
   	typedef HashNode<T> Node;
   
   	template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
   	friend struct __HTIterator;
   
   public:
   	typedef __HTIterator<K, T, T&, T*, KeyOfT, Hash> iterator;
   	typedef __HTIterator<K, T, const T&, const T*, KeyOfT, Hash> const_iterator;
   
   	iterator begin()
   	{
   		for (size_t i = 0; i < _tables.size(); i++)
   		{
   			if (_tables[i])
   			{
   				return iterator(_tables[i], this, i);
   			}
   		}
   
   		return end();
   	}
   
   	iterator end()
   	{
   		return iterator(nullptr, this, -1);
   	}
   
   	const_iterator begin() const
   	{
   		for (size_t i = 0; i < _tables.size(); i++)
   		{
   			if (_tables[i])
   			{
   				return const_iterator(_tables[i], this, i);
   			}
   		}
   
   		return end();
   	}
   
   	const_iterator end() const
   	{
   		return const_iterator(nullptr, this, -1);
   	}
   
   	HashTable()
   	{
   		_tables.resize(10);
   	}
   
   	~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 Size() const
   	{
   		return _n;
   	}
   
   	bool Empty() const
   	{
   		return _n == 0;
   	}
   
   	pair<iterator, bool> Insert(const T& data)
   	{
   		Hash hf;
   		KeyOfT kot;
   
   		iterator it = Find(kot(data));
   		if (it != end())
   			return make_pair(it, false);
   
   		// 负载因子最大到1
   		if (_n == _tables.size())
   		{
   			vector<Node*> newTables;
   			newTables.resize(_tables.size() * 2, 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)) % newTables.size();
   					cur->_next = newTables[i];
   					newTables[hashi] = cur;
   
   					cur = next;
   				}
   
   				_tables[i] = nullptr;
   			}
   
   			_tables.swap(newTables);
   		}
   
   		size_t hashi = hf(kot(data)) % _tables.size();
   		Node* newnode = new Node(data);
   
   		// 头插
   		newnode->_next = _tables[hashi];
   		_tables[hashi] = newnode;
   		++_n;
   
   		return make_pair(iterator(newnode, this, hashi), true);
   	}
   
   	bool Erase(const K& key)
   	{
   		Hash hf;
   		KeyOfT kot;
   
   		size_t hashi = hf(key) % _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;
   	}
   
   	iterator Find(const K& key)
   	{
   		Hash hf;
   		KeyOfT kot;
   
   		size_t hashi = hf(key) % _tables.size();
   		Node* cur = _tables[hashi];
   		while (cur)
   		{
   			if (kot(cur->_data) == key)
   			{
   				return iterator(cur, this, hashi);
   			}
   
   			cur = cur->_next;
   		}
   
   		return end();
   	}
   
   
   	size_t Count(const K& key)
   	{
   		Hash hf;
   		KeyOfT kot;
   
   		size_t hashi = hf(key) % _tables.size();
   		Node* cur = _tables[hashi];
   		while (cur)
   		{
   			if (kot(cur->_data) == key)
   			{
   				return 1;
   			}
   
   			cur = cur->_next;
   		}
   
   		return 0;
   	}
   
   	// 桶的总个数
   	size_t BucketCount()
   	{
   		size_t bucketCount = 0;
   		for (size_t i = 0; i < _tables.size(); i++)
   		{
   			if (_tables[i])
   			{
   				++bucketCount;
   			}
   		}
   		return bucketCount;
   	}
   
   	// key所在桶的大小
   	size_t BucketSize(const K& key)
   	{
   		Hash hf;
   		size_t bucketSize = 0;
   		size_t hashi = hf(key) % _tables.size();
   		Node* cur = _tables[hashi];
   		while (cur)
   		{
   			++bucketSize;
   			cur = cur->_next;
   		}
   		return bucketSize;
   	}
   
   	// 打印信息
   	void Some()
   	{
   		size_t bucketSize = 0;
   		size_t maxBucketLen = 0;
   		size_t sum = 0;
   		double averageBucketLen = 0;
   
   		for (size_t i = 0; i < _tables.size(); i++)
   		{
   			Node* cur = _tables[i];
   			if (cur)
   			{
   				++bucketSize;
   			}
   
   			size_t bucketLen = 0;
   			while (cur)
   			{
   				++bucketLen;
   				cur = cur->_next;
   			}
   
   			sum += bucketLen;
   
   			if (bucketLen > maxBucketLen)
   			{
   				maxBucketLen = bucketLen;
   			}
   		}
   
   		averageBucketLen = (double)sum / (double)bucketSize;
   
   		printf("all bucketSize:%zd\n", _tables.size());
   		printf("bucketSize:%zd\n", bucketSize);
   		printf("maxBucketLen:%zd\n", maxBucketLen);
   		printf("averageBucketLen:%lf\n\n", averageBucketLen);
   	}
   
   private:
   	vector<Node*> _tables;
   	size_t _n = 0;
   };
   

4.2 unordered_map 的模拟实现

unordered_map 的底层结构就是哈希表，因此在 unordered_map 中直接封装一个哈希表，然后将其接口包装下即可。

代码实现如下：

#pragma once
#include"HashTable.h"

namespace my_unordered_map
{
	template<class K, class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::iterator iterator;

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

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

		size_t size() const
		{
			return _ht.Size();
		}

		bool empty() const
		{
			return _ht.Empty();
		}

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _ht.Insert(kv);
		}

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

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

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

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

		size_t count(const K& key)
		{
			return _ht.Count(key);
		}

		size_t bucket_count()
		{
			return _ht.BucketCount();
		}
		
		size_t bucket_size(const K& key)
		{
			return _ht.BucketSize(key);
		}

	private:
		hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;
	};
}

4.3 unordered_set 的模拟实现

unordered_set 的底层结构就是哈希表，因此在 unordered_set 中直接封装一个哈希表，然后将其接口包装下即可。

代码实现如下：

#pragma once
#include"HashTable.h"

namespace my_unordered_set
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, K, SetKeyOfT, Hash>::const_iterator iterator;
		typedef typename hash_bucket::HashTable<K, K, SetKeyOfT, Hash>::const_iterator const_iterator;

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

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

		size_t size() const
		{
			return _ht.Size();
		}

		bool empty() const
		{
			return _ht.Empty();
		}

		pair<const_iterator, bool> insert(const K& key)
		{
			auto ret = _ht.Insert(key);
			return pair<const_iterator, bool>(const_iterator(ret.first._node, ret.first._pht, ret.first._hashi), ret.second);
		}

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

		iterator find(const K& key)
		{
			auto ret = _ht.Find(key);
			return const_iterator(ret._node, ret._pht, ret._hashi);
		}

		size_t count(const K& key)
		{
			return _ht.Count(key);
		}

		size_t bucket_count()
		{
			return _ht.BucketCount();
		}

		size_t bucket_size(const K& key)
		{
			return _ht.BucketSize(key);
		}
		
	private:
		hash_bucket::HashTable<K, K, SetKeyOfT, Hash> _ht;
	};
}

5. 哈希的应用

5.1 位图

5.1.1 位图的概念

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

来看一个问题：

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

1. 遍历$O(N)$

2. 排序$O(Nlo{g}_{2}N)$ + 二分查找$O(lo{g}_{2}N)$

3. 位图解决

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

比如：

5.1.2 位图的实现

namespace my_bitset
{
	// N是需要多少比特位
	template<size_t N>
	class bitset
	{
	public:
		bitset()
		{
			_bits.resize((N >> 5) + 1, 0);
		}

		void set(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;
			_bits[i] |= (1 << j);
		}

		void reset(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;
			_bits[i] &= ~(1 << j);
		}

		bool test(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;

			return _bits[i] & (1 << j);
		}
	private:
		vector<int> _bits;
	};
}

5.1.3 位图的应用

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

2. 排序 + 去重。

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

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

以下面三个题为例：

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

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

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

思路解答：

1. 创建两个位图，遍历给定的100亿个整数。对于每个整数，如果出现一次，则将两个位图中对应位置分别置成01；如果出现零次、二次及以上，则将两个位图中对应位置分别置成00、10或11，最后，再次遍历位图，找到位图位置对应的值为01的整数。
2. 将两个文件中的整数分别映射到两个位图中。然后，遍历其中一个位图，对于每个整数，查询另一个位图，如果对应位置的值为1，则表示该整数存在于两个文件中，即为所求交集。
3. 创建两个位图，初始化所有位为0。然后，遍历给定的100亿个整数，对于每个整数，将其对应的位图位置的值加1（这里加1指的是调整两个位图对应位置组合成的数加1）。最后，再次遍历位图，找到位图位置对应的值不超过2的整数。

5.2 布隆过滤器

5.2.1 布隆过滤器的提出

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

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

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

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

5.2.2 布隆过滤器的概念

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

5.2.3 布隆过滤器的实现

1. 布隆过滤器的插入

   往布隆过滤器增加元素，添加的 key 需要根据 k 个无偏 hash 函数计算得到多个 hash 值，然后对数组长度进行取模得到数组下标的位置，然后将对应数组下标的位置的值置为1。

2. 布隆过滤器的查找

   布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特位一定为1。所以可以按照以下方式进行查找：

   分别计算每个哈希值对应的比特位置存储的是否为零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。

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

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

3. 布隆过滤器的删除

   

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

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

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

4. 具体实现代码

   #pragma once
   #include"bitset.h"
   
   struct BKDRHash
   {
   	size_t operator()(const string& key)
   	{
   		// BKDR
   		size_t hash = 0;
   		for (auto e : key)
   		{
   			hash *= 31;
   			hash += e;
   		}
   
   		return hash;
   	}
   };
   
   struct APHash
   {
   	size_t operator()(const string& key)
   	{
   		size_t hash = 0;
   		for (size_t i = 0; i < key.size(); i++)
   		{
   			char ch = key[i];
   			if ((i & 1) == 0)
   			{
   				hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
   			}
   			else
   			{
   				hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
   			}
   		}
   		return hash;
   	}
   };
   
   struct DJBHash
   {
   	size_t operator()(const string& key)
   	{
   		size_t hash = 5381;
   		for (auto ch : key)
   		{
   			hash += (hash << 5) + ch;
   		}
   		return hash;
   	}
   };
   
   template<size_t N,
   	class K = string,
   	class HashFunc1 = BKDRHash,
   	class HashFunc2 = APHash,
   	class HashFunc3 = DJBHash>
   class BloomFilter
   {
   public:
   	void Set(const K& key)
   	{
   		size_t hash1 = HashFunc1()(key) % N;
   		size_t hash2 = HashFunc2()(key) % N;
   		size_t hash3 = HashFunc3()(key) % N;
   
   		_bs.set(hash1);
   		_bs.set(hash2);
   		_bs.set(hash3);
   	}
   
   	bool Test(const K& key)
   	{
   		// 判断不存在是准确的
   		size_t hash1 = HashFunc1()(key) % N;
   		if (_bs.test(hash1) == false)
   			return false;
   
   		size_t hash2 = HashFunc2()(key) % N;
   		if (_bs.test(hash2) == false)
   			return false;
   
   		size_t hash3 = HashFunc3()(key) % N;
   		if (_bs.test(hash3) == false)
   			return false;
   
   		// 存在误判的
   		return true;
   	}
   
   private:
   	my_bitset::bitset<N> _bs;
   };
   

5.2.4 布隆过滤器的优点

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

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

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

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

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

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

5.2.5 布隆过滤器的缺陷

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

2. 不能获取元素本身。

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

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