哈希表的概念+实现

哈希概念

直接定址法

哈希冲突

负载因子

哈希概念

哈希(hash)又称散列，是⼀种组织数据的方式。从译名来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建立⼀个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进行快速查找。

直接定址法

当关键字的范围比较集中时，直接定址法就是非常简单高效的方法，比如一组关键字都在[0,99]之间，那么我们开一个100个数的数组，每个关键字的值直接就是存储位置的下标。再比如一组关键字值都在 [a,z]的小写字母，那么我们开⼀个26个数的数组，每个关键字acsii码-aascii码就是存储位置的下标。也就是说直接定址法本质就是用关键字计算出⼀个绝对位置或者相对位置。这个方法我们在计数排序部分已经用过了。

哈希冲突

直接定址法的缺点十分显著：当关键字的分布范围较为分散时，会造成大量内存浪费，甚至出现内存不足的情况。

假设我们有 N 个取值范围在 [0,9999] 的数据 ，需要将它们映射到一个拥有 M 个存储空间的数组 中（通常要求 M≥N），这时就需要借助哈希函数（hash function）hf 来实现映射。关键字 key 会被放置到数组的 h(key) 位置，这里需要注意的是：哈希函数计算出的 h(key) 值必须落在 [0,M) 区间内。

这一过程存在一个核心问题：两个不同的关键字，有可能被映射到数组的同一个位置 ，这种情况被称为哈希冲突 ，也叫哈希碰撞。

理想状态下，我们希望能设计出一个完美的哈希函数来彻底避免冲突，但在实际应用场景中，哈希冲突是无法完全避免的。因此，我们需要做的是两方面的优化：

设计更优质的哈希函数，尽可能减少冲突发生的次数；
制定完善的冲突解决策略，妥善处理已经发生的哈希冲突。

负载因子

假设哈希表中已经映射存储了 N 个数据元素 ，哈希表的总存储空间大小为 M ，那么负载因子的计算公式为：负载因子=N/M

负载因子也被翻译为载荷因子 或装载因子 ，对应的英文是 load factor。

负载因子的大小与哈希冲突概率、空间利用率之间存在明确的关联：

负载因子越大，哈希冲突发生的概率越高，同时哈希表的空间利用率也越高；
负载因子越小，哈希冲突发生的概率越低，但哈希表的空间利用率也会相应降低。

将关键字转为整数

我们将关键字映射到数组中位置，⼀般是整数好做映射计算，如果不是整数，我们要想办法转换成整数，这个细节我们后面代码实现中再进进行细节展示。下面哈希函数部分我们讨论时，如果关键字不是整数，那么我们讨论的Key是关键字转换成的整数。

哈希函数

⼀个好的哈希函数应该让N个关键字被等概率的均匀的散列分布到哈希表的M个空间中，但是实际中却很难做到，但是我们要尽量往这个方向去考量设计。

除法散列法/除留余数法

除法散列法，也被称为除留余数法 。顾名思义，若哈希表的大小为 M，则该方法会将关键字 key 除以 M 得到的余数，作为其在哈希表中映射位置的下标，对应的哈希函数为：h(key)=key%M

使用除法散列法时，需要尽量避免将 M 设置为某些特殊数值，例如 2 的整数次幂、10 的整数次幂等。

若 M 取 2X，那么 key % M 的计算结果，本质上等价于保留 key 二进制表示的最后 X 位 。这会导致所有二进制后 X 位相同的 key，计算出的哈希值完全一致，从而引发哈希冲突。例如：数值 63 和 31 看似没有关联，但当 M=16（即 24）时，两者计算出的哈希值均为 15 ------ 因为 63 的二进制后 8 位是 00111111，31 的二进制后 8 位是 00011111，二者的最后 4 位均为 1111。
若 M 取 10X，则 key % M 等价于保留 key 十进制表示的最后 X 位，冲突问题会更直观。例如：数值 112 和 12312，当 M=100（即 102）时，两者的哈希值均为 12。

因此，在理论层面，多数数据结构相关书籍会建议：将 M 设置为一个不接近 2 的整数次幂的质数。

不过在工程实践中，开发者会根据实际需求灵活调整策略。以 Java 的 HashMap 为例，它采用除法散列法时，就将哈希表大小 M 设置为 2 的整数次幂。这样做的优势在于，可以用位运算替代取模运算，大幅提升计算效率 ------ 因为位运算的执行速度远快于取模运算。

当然，HashMap 并非直接通过保留 key 的后若干位来计算哈希值，而是做了优化处理：例如当 M=216 时，会先将 key 右移 16 位得到 key'，再将 key 与 key' 进行异或运算，用运算结果作为最终哈希值。这种操作让 key 的所有二进制位都参与了计算，能让哈希值的分布更均匀，以此降低冲突概率。

乘法散列法（了解）

乘法散列法的一大优势是对哈希表大小 M 没有特殊要求，其计算流程分为两步：

用关键字 key 乘以一个常数 A（满足 0<A<1），提取出乘积结果的小数部分；
用哈希表大小 M 乘以这个小数部分，最后对计算结果执行下取整操作。

对应的哈希函数公式为：h(key)=floor(M×((A×key)%1.0))其中 floor 代表下取整运算，常数 A 的取值是该方法的核心。学者 Knuth 提出，将 A 设为黄金分割比例的小数部分，即A=25−1=0.6180339887⋯时，哈希值的分布会更均匀，冲突概率更低。

我们可以通过一个实例理解计算过程：假设哈希表大小 M=1024，关键字 key=1234，常数 A=0.6180339887。

计算乘积：A×key=0.6180339887×1234=762.6539420558；
提取小数部分：(A×key)%1.0=0.6539420558；
计算乘积并下取整：floor(1024×0.6539420558)=floor(669.6366651392)=669。最终得到该关键字的哈希值 h(1234)=669。

处理哈希冲突

实践中哈希表⼀般还是选择除法散列法作为哈希函数，当然哈希表无论选择什么哈希函数也避免不了冲突，那么插入数据时，如何解决冲突呢？主要有两种两种方法，开放定址法和链地址法。

开放定址法(闭散列)

在开放定址法中所有的元素都放到哈希表里，当⼀个关键字key用哈希函数计算出的位置冲突了，则按照某种规则找到⼀个没有存储数据的位置进行存储，开放定址法中负载因子⼀定是小于的。这里的规则有三种：线性探测、二次探测、双重探测

线性探测

线性探测法的核心逻辑是：当关键字映射的位置发生冲突时，从冲突位置开始 ，按顺序向后逐个探测哈希表的存储空间，直到找到下一个空闲位置为止；若探测到哈希表的末尾仍未找到空闲位置，则回绕到哈希表的起始位置继续探测。

对应的计算公式如下：

首先通过基础哈希函数计算初始映射位置：h(key)=hash0=key%M
若 hash0 位置发生冲突，则通过线性探测公式依次计算后续候选位置：hc(key,i)=hashi=(hash0+i)%M其中 i={1,2,3,...,M−1}。由于哈希表的负载因子小于 1，哈希表中一定存在空闲位置，因此最多探测 M−1 次，就必然能找到可存储该关键字的位置。

线性探测法的优点是原理简单、易于实现 ，但存在明显的缺陷 ------群集（又称堆积）现象。具体表现为：若 hash0 位置发生连续冲突，且 hash0、hash1、hash2 等位置均已被占用，那么后续映射到 hash0、hash1、hash2、hash3 等位置的关键字，都会争夺 hash3 这个空闲位置，导致冲突概率进一步升高。二次探测法可以在一定程度上改善这一问题。

下面演示将数据集 {19,30,5,36,13,20,21,12} 映射到大小 M=11 的哈希表中的过程。

二次探测

二次探测法的核心逻辑是：当关键字映射的初始位置发生冲突时，从冲突位置 开始，按照平方步长向左右两侧跳跃式探测，直到找到下一个空闲的存储位置。

若向右探测至哈希表末尾仍未找到空闲位置，则回绕到哈希表起始位置继续探测；
若向左探测至哈希表起始位置仍无空闲位置，则回绕到哈希表末尾继续探测。

对应的计算公式如下：

首先通过基础哈希函数计算初始映射位置：h(key)=hash0=key%M
若 hash0 位置发生冲突，则通过二次探测公式计算后续候选位置：hc(key,i)=hashi=(hash0±i2)%M其中 i={1,2,3,...,⌊2M⌋}。
当使用公式 hashi=(hash0−i2)%M 计算时，若得到的 hashi 为负数，需要对其执行 hashi+=M 的操作，确保位置下标落在合法区间内。

二次探测法可以有效缓解线性探测法中出现的群集（堆积）现象，让候选位置的分布更分散，降低连续冲突的概率。

下面演示将数据集 {19,30,52,63,11,22} 映射到大小 M=11 的哈希表中的过程。

开放定址法代码实现

开放定址法的哈希表结构

cpp 复制代码

namespace open_address
{
	enum State
	{
		EXIST,
		EMPTY,
		DELETE
	};

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

	template<class K, class V>
	class HashTable
	{
	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0;  // 表中存储数据个数
	};
}

需要注意的是，哈希表的每个存储位置都需要增设状态标识，否则删除部分数据后，会影响后续存在冲突的数据的查找流程。

举个例子：如果直接删除哈希表中的数据 30，可能会导致后续查找数据 20 失败。而如果为每个位置设置三种状态标识：EXIST（数据存在）、EMPTY（位置空闲）、DELETE（数据已删除），那么删除 30 时，无需清空该位置的内容，仅需将其状态修改为 DELETE 即可。这样在查找 20 的过程中，遇到标记为 DELETE 的位置会继续向后探测，直到遇到 EMPTY 状态的位置才停止，以此保证能成功找到 20。

以下是这组数据对应的初始哈希映射位置：

h(19)=8，h(30)=8，h(5)=5，h(36)=3，h(13)=2，h(20)=9，h(21)=10，h(12)=1

哈希表的负载因子阈值通常设定为 0.7，当实际负载因子达到 0.7 时，就需要对哈希表进行扩容操作。

一般扩容策略是将哈希表大小扩大至原来的 2 倍，但这里存在一个问题：如果原哈希表大小是质数，扩大 2 倍后就不再是质数了。针对这个问题，有两种常见的解决方案：

采用 Java HashMap 的设计思路：将哈希表大小设定为 2 的整数次幂，同时对哈希函数做优化改进 ------ 不直接通过取模运算计算映射位置，而是让关键字的所有二进制位参与运算，以此保证哈希值分布均匀，规避 2 的整数次幂作为表大小带来的冲突风险。
采用 SGI 版本哈希表 的设计思路：预先准备一个近似 2 倍递增的质数表，每次扩容时，直接从这个质数表中选取下一个质数作为新的哈希表大小。

cpp 复制代码

inline unsigned long __stl_next_prime(unsigned long n)
{
	// Note: assumes long is at least 32 bits.
	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
	};
	const unsigned long* first = __stl_prime_list;
	const unsigned long* last = __stl_prime_list + __stl_num_primes;
	const unsigned long* pos = lower_bound(first, last, n);
	return pos == last ? *(last - 1) : *pos;
}

key不能取模的问题

当关键字（key）的类型是字符串（string）、日期（Date）等非数值类型时，无法直接对其进行取模运算。针对这种情况，需要为哈希表（HashTable）增设一个仿函数，该仿函数的作用是将这些非数值类型的 key 转换为可以参与取模运算的整数。

具体使用规则如下：

如果 key 本身能够转换为整数，且转换后的整数值不易产生冲突，那么直接使用哈希表默认的仿函数即可；
如果 key 无法直接转换为整数，就需要自定义实现一个仿函数并传入哈希表。实现该仿函数的核心要求是：让 key 的每一个特征值都参与计算，尽可能保证不同的 key 能转换出不同的整数值，以此降低哈希冲突的概率。

由于字符串（string）是哈希表中非常常见的 key 类型，因此可以对字符串类型做专门的特化处理，设计针对性的转换逻辑。

cpp 复制代码

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

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

		return hash;
	}
};

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:
private:
	vector<HashData<K, V>> _tables;
	size_t _n = 0;  // 表中存储数据个数
};

完整代码

cpp 复制代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<string>
using namespace std;

namespace open_address
{
	enum State
	{
		EXIST,
		EMPTY,
		DELETE
	};

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

	template<class K>
	class HashFunc
	{
	public:
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

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

			return hash;
		}
	};

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		inline unsigned long __stl_next_prime(unsigned long n)
		{
			// Note: assumes long is at least 32 bits.
			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
			};
			const unsigned long* first = __stl_prime_list;
			const unsigned long* last = __stl_prime_list + __stl_num_primes;
			const unsigned long* pos = lower_bound(first, last, n);
			return pos == last ? *(last - 1) : *pos;
		}

		HashTable()
		{
			_tables.resize(__stl_next_prime(1));
		}

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

			// 扩容
			// if (_n*10 / _tables.size >= 7)
			if ((double)_n / (double)_tables.size() >= 0.7)
			{
				// 获取素数表里面比当前表大的下一个素数
				//size_t newSize = __stl_next_prime(_tables.size() + 1);
				//vetcor<HashData<K, V>> newTables(newSize);
				//// 遍历旧表，将数据都映射到新表
				//for (size_t i = 0; i < _tables.size(); i++)
				//{
				//	if (_tables[i]._state == EXIST)
				//	{
				//		// ...
				//	}
				//}
				//_tables.swap(newTables);

				size_t newSize = __stl_next_prime(_tables.size() + 1);
				HashTable<K, V, Hash> newHT;
				newHT._tables.resize(newSize);

				// 遍历旧表，将数据都映射到新表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._state == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}

				_tables.swap(newHT._tables);
			}

			Hash hs;
			size_t hash0 = hs(kv.first) % _tables.size();
			size_t i = 1;
			size_t hashi = hash0;
			while (_tables[hashi]._state == EXIST)
			{
				// 线性探测
				hashi = (hash0 + i) % _tables.size();
				++i;
			}

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

			return true;
		}

		HashData<K, V>* Find(const K& key)
		{
			Hash hs;
			size_t hash0 = hs(key) % _tables.size();
			size_t hashi = hash0;
			size_t i = 1;
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state == EXIST
					&& _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				// 线性探测
				hashi = (hash0 + i) % _tables.size();
				++i;
			}
			return nullptr;
		}

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

	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0; // 表中存储数据个数
	};

	class stringHashFunc
	{
	public:
		size_t operator()(const string& s)
		{
			size_t hash = 0;
			for (auto ch : s)
			{
				hash += ch;
				hash *= 131;
			}

			return hash;
		}
	};

	void TestHT1()
	{
		HashTable<int, int> ht1;
		ht1.Insert({ 54, 1 });
		ht1.Insert({ 1, 1 });

		cout << ht1.Find(1) << endl;
		cout << ht1.Erase(54) << endl;
		cout << ht1.Find(1) << endl;
		cout << ht1.Find(54) << endl;

		/*for (int i = 0; i < 53; i++)
		{
			ht1.Insert({rand(), i});
		}*/
	}

	// 2024 2 10
	// 2024 10 2
	struct Date
	{
		int _year;
		int _month;
		int _day;
	};

	//void TestHT2()
	//{
	//	//HashTable<string, string, stringHashFunc> ht2;
	//	HashTable<string, string> ht2;
	//	ht2.Insert({ "sort", "排序" });
	//	ht2.Insert({ "string", "字符串" });

	//	cout << stringHashFunc()("abcd") << endl;
	//	cout << stringHashFunc()("bcad") << endl;
	//	cout << stringHashFunc()("abbe") << endl;

	//	unordered_map<string, string> dictMap;
	//	dictMap.insert({ "sort", "排序" });
	//	dictMap.insert({ "string", "字符串" });
	//	cout << dictMap.load_factor() << endl;
	//	cout << dictMap.max_load_factor() << endl;
	//}
}

链地址法(开散列)

解决冲突的思路

开放定址法中所有的元素都放到哈希表里，链地址法中所有的数据不再直接存储在哈希表中，哈希表中存储⼀个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成⼀个链表，挂在哈希表这个位置下面，链地址法也叫做拉链法或者哈希桶。

下面演示将数据集 {19,30,5,36,13,20,21,12,24,96} 映射到大小 M=11 的哈希表中的过程。

扩容

开放定址法负载因子必须小于 1，链地址法的负载因子没有限制，可以大于 1。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低。STL 中 unordered_xxx 的最大负载因子基本控制在 1，大于 1 就扩容，我们下面实现也使用这个方式。

极端场景

如果极端场景下，某个桶特别长怎么办？其实我们可以考虑使用全域散列法，这样就不容易被针对了。但是假设不是被针对了，用了全域散列法，但是偶然情况下，某个桶很长，查找效率很低怎么办？这里在 Java 8 的 HashMap 中当桶的长度超过一定阈值（8）时就把链表转换成红黑树。一般情况下，不断扩容，单个桶很长的场景还是比较少的，下面我们实现就不搞这么复杂了，这个解决极端场景的思路，大家了解一下。

链地址法代码实现

cpp 复制代码

namespace hash_bucket
{
	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 HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		HashTable()
		{
			_tables.resize(__stl_next_prime(1), nullptr);
		}

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

		inline unsigned long __stl_next_prime(unsigned long n)
		{
			// Note: assumes long is at least 32 bits.
			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
			};
			const unsigned long* first = __stl_prime_list;
			const unsigned long* last = __stl_prime_list + __stl_num_primes;
			const unsigned long* pos = lower_bound(first, last, n);
			return pos == last ? *(last - 1) : *pos;
		}

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

			// 负载因子到1就扩容
			if (_n == _tables.size())
			{
				size_t newSize = __stl_next_prime(_tables.size() + 1);
				vector<Node*> newtables(newSize, nullptr);
				// 遍历旧表，把旧表的节点挪动到新表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;

						// cur头插到新表
						size_t hashi = cur->_kv.first % newSize;
						cur->_next = newtables[hashi];
						newtables[hashi] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}


				_tables.swap(newtables);
			}

			size_t hashi = 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 = key % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}

				cur = cur->_next;
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			size_t hashi = 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;
		}
	private:
		//vector<list<pair<K, V>>> _tables;
		vector<Node*> _tables;  // 指针数组
		size_t _n = 0;			// 表中存储数据个数
	};

	void TestHT1()
	{
		HashTable<int, int> ht1;
		ht1.Insert({ 54, 1 });
		ht1.Insert({ 1, 1 });

		for (int i = 0; i < 53; i++)
		{
			ht1.Insert({rand(), i});
		}

		ht1.Erase(19895);
		ht1.Erase(15724);
	}
}