C++进阶7：深入理解哈希表，从原理到 C++ 实践

.小小陈.2026-03-12 12:55

目录

前言：

一、哈希函数

1.1直接定值法：

1.2哈希冲突

1.3负载因子

二、哈希函数

2.1除法散列法/除留余数法

2.2乘法散列法

2.3全域散列法

三、处理哈希冲突

3.1开放定址法

3.1.1线性探测

3.1.2二次探测

3.1.3双重探测

3.2开放定址法代码实现

3.3链地址法

3.4链地址法代码实现

四、unordered_map/unordered_set

关键特性与注意事项

[1. 无序性](#1. 无序性)

[2. 键的要求](#2. 键的要求)

前言：

哈希表（Hash Table）是一种高效的数据结构，它通过哈希函数将键（Key）映射到数组中的一个位置，从而实现近乎 O (1) 的平均时间复杂度的插入、删除和查找操作。在 C++ 标准库中，unordered_map 和 unordered_set 就是哈希表思想的典型实现。

一、哈希函数

哈希函数的作用是将任意长度的输入（键）转换为固定长度的输出（哈希值），这个值通常作为数组的索引。一个好的哈希函数应满足：

  • 计算快速：保证高效性。
  • 分布均匀：减少哈希冲突的概率。
  • 确定性：相同的输入必须产生相同的输出。

1.1直接定值法：

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

例题：https://leetcode.cn/problems/first-unique-character-in-a-string

cpp 复制代码 
class Solution {
public:
    int firstUniqChar(string s) {
        int arr[26] = {0};

        for(char e : s)
        {
            arr[e - 'a']++;
        }

        for (int i = 0;i < s.size();i++)
        {
            if (arr[s[i] - 'a'] == 1)
            {
                return i;
            }
        }
        return -1;
    }
};

1.2哈希冲突

直接定址法的缺点也非常，当关键字的范围比较分散时，就很浪费内存甚至内存不够用。假设我们只有数据范围是[0,9999]的N个值，我们要映射到一个M个空间的数组中(⼀般情况下M>=N)，那么 就要借助哈希函数，关键字key被放到数组的h(key)位置，这里要注意的是h(key)计 算出的值必须在[0,M)之间。这里存在的⼀个问题就是，两个不同的key可能会映射到同⼀个位置去，这种问题我们叫做哈希冲突， 或者哈希碰撞。理想情况是找出⼀个好的哈希函数避免冲突，但是实际场景中，冲突是不可避免的。

1.3负载因子

假设哈希表中已经映射存储了N个值，哈希表的大小为M，那么负载因子 = N/M，有些地方也翻译为载荷因子/装载因子等，他的英文为load-factor。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低。

注意：

我们将关键字映射到数组中位置，一般是整数好做映射计算，如果不是整数，我们要想办法转换成整数

二、哈希函数

2.1除法散列法/除留余数法

除法散列法也叫做除留余数法，顾名思义，假设哈希表的大小为M，那么通过key除以M的余数作为映射位置的下标，也就是哈希函数为：h(key)=key%M（取模）

当使用除法散列法时，要尽量避免M为某些值，如2的幂，10的幂等。如果是2^x ，那么key%2^x本质相当于保留key的后X位，那么后x位相同的值，计算出的哈希值都是⼀样的，就冲突了。如： {63,31}看起来没有关联的值，如果M是16，也就是2^4 ，那么计算出的哈希值都是15，因为63的二进制后8位是00111111，31的⼆进制后8位是00011111。如果是10^x ，就更明显了，保留的都是 10进值的后x位，如：{112,12312}，如果M是100，也就是10^2，那么计算出的哈希值都是12。所以当使用除法散列法时，建议M取不太接近2的整数次幂的⼀个质数(素数)。

在实践中也是八仙过海，各显神通，Java的HashMap采用除法散列法时就是2的整数次幂做哈希表的大小M，这样玩的话，就不用取模，而可以直接位运算，相对而言位运算比模更高效⼀些。但是他不是单纯的去取模，比如M是2^16次方，本质是取后16位，那么用key'=key>>16，然后把key和key'异或的结果作为哈希值。也就是说我们映射出的值还是在[0,M)范围 内，但是尽量让key所有的位都参与计算。

有意思的是，我们在实现哈希表是需要进行扩容的，如果按照我们之前的想法每次都乘2很难满足取到不太接近2的整数次幂的⼀个质数(素数)，在源码中选择了一种很简单粗暴的方法，直接给了一个前后相差大概是2倍又不太接近2的整数次幂的⼀个质数(素数)

2.2乘法散列法

乘法散列法的核心思想是：

  1. 将键值 k 与一个常数因子 A（0<A<1）相乘；
  2. 取乘积的小数部分（即乘积减去整数部分）；
  3. 将小数部分乘以哈希表的桶数 m，取整数部分作为哈希值。

数学表达式为：h(k)=⌊m×(k×Amod1)⌋

这种方法的优势在于：

  • 不依赖 m 是质数（区别于除留余数法），m 可以是任意值（工程中常取 2 的幂，方便位移运算）；
  • 只要常数 A 选择得当，能让哈希值分布非常均匀；
  • 乘法和位移运算在计算机中执行效率极高。

2.3全域散列法

常规的哈希函数是固定的（比如 hash(key) = key % 10），如果攻击者知道这个函数，就可以构造一批都映射到同一个哈希值的键，让哈希表退化成链表，时间复杂度降到 O (n)。

最常用的全域散列函数构造方式基于数论，步骤如下：

  1. 选择一个大质数 p，满足 p \> 所有可能的键值；
  2. 从集合 {1,2,...,p−1} 中随机选择 a，从 {0,1,...,p−1} 中随机选择 b；
  3. 定义哈希函数：ha,b(k)=((a⋅k+b)mod p)mod m。

三、处理哈希冲突

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

3.1开放定址法

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

3.1.1线性探测

  1. 核心规则

探测增量为线性递增：d(i)=i（或固定步长，如 d(i)=c∗i，c 为常数）。公式简化为：h(k,i)=(h′(k)+i) mod m

  1. 工作过程

  2. 计算初始位置 h0=h′(k)；

  3. 若 h0 为空，直接插入；

  4. 若 h0 被占用，检查 h1=(h0+1)modm；

  5. 依次类推，直到找到空桶 hi。

3.1.2二次探测

  1. 核心规则

探测增量为二次函数：d(i)=i^2

h(k,i)=(h′(k)+i^2) mod m

  1. 工作过程

  2. 初始位置 h0=h′(k)；

  3. 若占用，检查 h1=(h0+1) mod m；

  4. 再占用，检查 h2=(h0+4) mod m；

  5. 依次检查,直到找到空桶。

3.1.3双重探测

  1. 核心规则

使用两个独立的哈希函数生成探测增量：h(k,i)=(h1​(k)+i⋅h2​(k)) mod m

  • h1(k)：主哈希函数（确定初始位置）；
  • h2(k)：次哈希函数（确定探测步长，要求 h2(k) 与 m 互质）。

常用次哈希函数：h2​(k)=1+(k mod (m−1))（保证步长与 m 互质）。

  1. 工作过程

  2. 初始位置 h0=h1(k)；

  3. 若占用，步长 s=h2(k)，检查 h1=(h0+s)modm；

  4. 再占用，检查 h2=(h0+2s)modm；

  5. 依次类推，直到找到空桶。

3.2开放定址法代码实现

开放定址法在实践中，不如链地址法，我们简单选择线性探测实现。

哈希表结构：

cpp 复制代码 
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
{
public:
private:
	vector<HashData<K, V>> _tables;
	size_t _n;  // 记录数据个数
};

注意：

这里需要给每个存储值的位置加⼀个状态标识，否则删除⼀些值以后，会影响后面冲突的值的查找。如下图，我们删除30，会导致查找20失败，当我们给每个位置加⼀个状态标志{EXIST,EMPTY,DELETE} ，删除30就可以不用删除值，⽽是把状态改为 DELETE ，那么查找20 时是遇到 EMPTY 才能，就可以找到20。

扩容：

这里我们哈希表负载因子控制在0.7，当负载因子到0.7以后我们就需要扩容了，我们还是按照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等类型时，key不能取模，那么我们需要给HashTable增加一个仿函数，这个仿函数支持把key转换成⼀个可以取模的整形，如果key可以转换为整形并且不容易冲突，那么这个仿函数就用默认参数即可，如果这个Key不能转换为整形，我们就需要自己实现⼀个仿函数传给这个参数，实现这个仿函数的要求就是尽量key的每值都参与到计算中，让不同的key转换出的整形值不同。我们这里把string类转化成整型特化一下。

cpp 复制代码 
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		// BKDR
		size_t hash = 0;
		for (auto ch : s)
		{
			hash += ch;
			hash *= 131;
		}

		return hash;
	}
};

完整实现：

cpp 复制代码 
#include <string>
using namespace std;

enum State
{
	EXIST,
	EMPTY,
	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;
	}
};

template<>
struct HashFunc<string>
{
	size_t operator()(const string& s)
	{
		// BKDR
		size_t hash = 0;
		for (auto ch : s)
		{
			hash += ch;
			hash *= 131;
		}

		return hash;
	}
};


namespace open_address
{
	template<class K, class V,class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		HashTable()
			:_tables(__stl_next_prime(0))
			, _n(0)
		{}

		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;

			// 负载因子 >= 0.7扩容
			if (_n * 10 / _tables.size() >= 7)
			{
				HashTable<K, V> newht;
				//newht._tables.resize(_tables.size() * 2);
				newht._tables.resize(__stl_next_prime(_tables.size() + 1));

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

				_tables.swap(newht._tables);
			}

			size_t hash0 = kv.first % _tables.size();
			size_t hashi = hash0;
			size_t i = 1;
			int flag = 1;
			while (_tables[hashi]._state == EXIST)
			{
				// 线性探测
				hashi = (hash0 + i) % _tables.size();
				++i;
				//二次探测
				/*hashi = (hash0 + (i*i*flag)) % _tables.size();
				if (hashi < _tables.size())
					hashi += _tables.size();

				if (flag == 1)
				{
					flag = -1;
				}
				else
				{
					++i;
					flag = 1;
				}*/
			}

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

			return true;
		}

		HashData<K, V>* Find(const K& key)
		{
			size_t hash0 = 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)
			{
				ret->_state = DELETE;
				return true;
			}
			else
			{
				return false;
			}
		}

	private:
		vector<HashData<K, V>> _tables;
		size_t _n;  // 记录数据个数
	};
}

3.3链地址法

哈希表的每个 "桶 (Bucket)" 不再只存储单个元素，而是指向一个链表（或其他动态容器，如红黑树） 的头节点；当多个键哈希到同一个桶时，直接将这些元素依次插入该桶对应的链表中；查找 / 删除元素时，先通过哈希函数定位到桶，再遍历该桶的链表找到目标元素。

扩容：

开放定址法负载因子必须小于1，链地址法的负载因子就没有限制了，可以大于1。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低；stl中unordered_map的最大负载因子基本控制在1，大于1就扩容。

极端场景：

如果极端场景下，某个桶特别长怎么办？其实我们可以考虑使用全域散列法，这样就不容易被针对 了。但是假设不是被针对了，用了全域散列法，但是偶然情况下，某个桶很长，查找效率很低怎么 办？这⾥在Java8的HashMap中当桶的长度超过一定阀值(8)时就把链表转换成红黑树。但这种极端场景一般不会出现。

3.4链地址法代码实现

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 Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;

		inline unsigned long __stl_next_prime(unsigned long n)
		{
			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;
		}
	public:
		HashTable()
		{
			_tables.resize(__stl_next_prime(0), 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;
			}
		}
		bool Insert(const pair<K, V>& kv)
		{
			Hash hs;
			size_t hashi = hs(kv.first) % _tables.size();
			// 负载因子==1扩容 
			if (_n == _tables.size())
			{
				/*HashTable<K, V> newHT;

			   newHT._tables.resize(__stl_next_prime(_tables.size()+1);
				for (size_t i = 0; i < _tables.size(); i++)
				{
				Node* cur = _tables[i];
				while(cur)
				{
					newHT.Insert(cur->_kv);
					 cur = cur->_next;
                }
			 }
			 _tables.swap(newHT._tables);*/


				vector<Node*> newtables(__stl_next_prime(_tables.size() + 1), 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);
			}
			// 头插 
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}
		Node* Find(const K& key)
		{
			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;
		}
		bool Erase(const K& key)
		{
			Hash hs;
			size_t hashi = hs(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;
					--_n;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	private:
		vector<Node*> _tables; // 指针数组 
		size_t _n = 0; // 表中存储数据个数 
 };
}

四、unordered_map/unordered_set

关键特性与注意事项

1. 无序性

这是和 map/set 最核心的区别：

  • unordered_map/unordered_set 的元素顺序由哈希函数和桶分布决定，遍历顺序与插入顺序无关；
  • map/set 基于红黑树，元素始终按 key 升序排列。
2. 键的要求
  • 必须可哈希 ：默认需要 std::hash<Key> 有特化实现（内置类型、string 等已支持）；
  • 必须可判等 ：需要 operator== 或自定义相等判断规则。
相关推荐
码云数智-大飞2 小时前
排序算法的终极博弈：从复杂度推导到工程选型实战
开发语言
科技林总2 小时前
【系统分析师】11.1 软件需求
学习
怪侠_岭南一只猿2 小时前
爬虫学习阶段三：动态网页爬取（完整学习文档）
爬虫·python·学习
南 阳2 小时前
Python从入门到精通day48
开发语言·python
keep intensify2 小时前
康复训练 2
c++
晨晖22 小时前
java容器类的博客
java·开发语言
失败才是人生常态2 小时前
大数据基础学习
大数据·学习
leo__5202 小时前
MHT多假设跟踪算法（Multiple Hypothesis Tracking）MATLAB实现
开发语言·算法·matlab
燃于AC之乐2 小时前
深入解剖STL RB-tree(红黑树)：用图解带入相关复杂操作实现
开发语言·c++·stl·红黑树·大厂面试·图解·插入操作
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03本地部署 OpenClaw + DeepSeek-R1 完全指南04得物前端部门，没了05OpenClaw 连接飞书完整指南：插件安装、配置与踩坑记录06OpenClaw 飞书机器人不回复消息？3 小时踩坑总结07Window 10部署openclaw报错node.exe : npm error code 12808OpenClaw macOS 完整安装与本地模型配置教程（实战版）09npm-error code 128问题解决方法10OpenClaw 接入 QQ Bot 完整实践指南