当前位置：首页 > news >正文

C++数据结构：哈希表的实现

news 来源：原创 2025/5/29 11:33:02

C++数据结构：哈希表的实现

C++数据结构：哈希表的实现
- 引言
- 1. 哈希概念
- - 1.1 直接定址法
  - 1.2 哈希冲突
  - 1.3 负载因子
- 2. 哈希函数
- - 2.1 除法散列法/除留余数法
  - 2.2 乘法散列法（了解）
  - 2.3 全域散列法（了解）
- 3. 处理哈希冲突
- - 3.1 开放定址法
  - - 3.1.1 线性探测
    - 3.1.2 二次探测
    - 3.1.3 双重探测（了解）
    - 3.1.4 开放地址码代码实现
  - 3.2 链地址法（重点）

引言

哈希表（Hash Table）是一种高效的数据结构，它通过哈希函数将键（Key）映射到存储位置，从而实现平均时间复杂度为O(1)的快速查找、插入和删除操作。本文将详细介绍哈希表的核心概念，包括哈希函数的设计、哈希冲突的解决方法（开放定址法和链地址法），并通过C++代码实现一个完整的哈希表。无论你是初学者还是希望深入理解哈希表内部机制的开发者，本文都将为你提供清晰的理论指导和实用的代码示例。

1. 哈希概念

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

1.1 直接定址法

直接定址法在关键字范围较集中时是非常简单高效的方法。例如，若一组关键字都在 [0,99] 之间，可直接开辟一个长度为 100 的数组，关键字的值即为存储位置的下标；若关键字均为 [a,z] 的小写字母，则可开辟长度为 26 的数组，通过 ASCII码 - 'a'的ASCII码 计算存储位置的下标。直接定址法的本质是利用关键字计算出一个绝对位置或相对位置。

代码示例：字符串中的第一个唯一字符

class Solution {
public:int firstUniqChar(string s) {// 每个字⺟的ascii码-'a'的ascii码作为下标映射到count数组，数组中存储出现的次数int count[26] = {0};// 统计次数for(auto ch : s){count[ch-'a']++;}for(size_t i = 0; i < s.size(); ++i){if(count[s[i]-'a'] == 1)return i;}return -1;}
};

1.2 哈希冲突

直接定址法的缺点非常明显，当关键字的范围比较分散时，会非常浪费内存甚至导致内存不够用。假设我们只有数据范围是[0, 9999]的N个值，要映射到一个M个空间的数组中（一般情况下M ≥ N），就需要借助哈希函数（hash function）hf，将关键字key放到数组的h(key)位置。需要注意的是，h(key)计算出的值必须在[0, M)之间。
这里存在的一个问题是，两个不同的key可能会映射到同一个位置，这种情况称为哈希冲突或哈希碰撞。理想情况下，我们希望找到一个优秀的哈希函数来避免冲突，但在实际应用中，冲突是不可避免的。因此，我们应尽量设计高效的哈希函数以减少冲突次数，同时也要制定合理的冲突解决方案。

1.3 负载因子

负载因子（有些地方也翻译为载荷因子/装载因子等，英文为 load factor）是指哈希表中已存储的N个值与哈希表大小M的比值。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低。

2. 哈希函数

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

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

除法散列法（除留余数法）通过哈希表大小 ( M ) 计算键 ( key ) 的映射位置，哈希函数为 ( h(key) = key % M )。使用时应避免 ( M ) 为 2 或 10 的幂次，否则会导致仅保留 ( key ) 的低位，引发冲突。例如：若 ( M=16 )，则 ( 63 )（二进制 00111111）和 ( 31 )（二进制 00011111）的哈希值均为 15；若 ( M=100 )，则 ( 112 ) 和 ( 12312 ) 的哈希值均为 12。
实践中建议 ( M ) 取远离 2 的整数次幂的质数，以减少冲突。但 Java 的 HashMap 采用 ( M ) 为 2 的幂次（如 ( 2^{16} )），通过位运算（右移+异或）优化效率，使所有位参与计算，确保哈希值分布均匀。尽管与经典理论不同，这种方法通过调整计算方式仍能达到较好的效果。

2.2 乘法散列法（了解）

乘法散列法对哈希表大小M没有要求，其核心思路分为两步：第一步是用关键字K乘上常数A（0 < A < 1），并提取出k*A的小数部分；第二步是用M乘以该小数部分，再向下取整。
具体公式为：h(key) = floor(M × ((A × key)%1.0))，其中，floor表示向下取整，A∈(0,1)。A的取值至关重要，Knuth建议采用黄金分割点（5−12≈0.618033988725−1≈0.6180339887）效果较好。
示例：乘法散列法对哈希表大小M是没有要求的，假设M为1024，key为1234，A = 0.6180339887, A*key= 762.6539420558，取小数部分为0.6539420558, M×((A×key)%1.0) = 0.6539420558*1024 =669.6366651392，那么h(1234) = 669。

2.3 全域散列法（了解）

如果存在一个恶意的对手，他针对我们提供的散列函数，特意构造出一个发生严重冲突的数据集，比如让所有关键字全部落入同一个位置中，这种情况是可以存在的，只要散列函数是公开且确定的，就可以实现此攻击。解决方法自然是见招拆招，给散列函数增加随机性，攻击者就无法找出确定可以导致最坏情况的数据，这种方法叫做全域散列。
全域散列的实现需要选一个足够大的质数P，a可以随机选[1,P-1]之间的任意整数，b可以随机选[0,P-1]之间的任意整数，这些函数构成了一个P*(P-1)组全域散列函数组。例如，假设P=17，M=6，a=3，b=4，则散列函数计算方式为：h_ab(key) = ((a × key + b) % P) % M，具体示例h₃₄(8) = ((3 × 8 + 4) % 17) % 6 = 5。
需要注意的是，每次初始化哈希表时，随机选取全域散列函数组中的一个散列函数使用，后续增删查改都固定使用这个散列函数，否则如果每次操作都随机选择散列函数，会导致插入和查找使用不同的函数，从而无法正确找到已插入的key。

3. 处理哈希冲突

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

3.1 开放定址法

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

3.1.1 线性探测

从发生冲突的位置开始，依次线性向后探测，直到寻找到下一个没有存储数据的位置为止，如果走到哈希表尾，则回绕到哈希表头的位置。
若 hash0 位置冲突，则线性探测公式为 h(key) = hash0 = key % M，hc(key,i) = hashi = (hash0 + i) % M（其中 i = {1, 2, 3, ..., M − 1}），因为负载因子小于1，则最多探测 M-1 次，一定能找到一个存储 key 的位置。
线性探测比较简单且容易实现，但假设 hash0 位置连续冲突，hash0、hash1、hash2 位置已存储数据，后续映射到 hash0、hash1、hash2、hash3 的值都会争夺 hash3 位置，这种现象称为群集/堆积。二次探测可以一定程度改善这个问题。
下面演示 {19, 30, 5, 36, 13, 20, 21, 12} 这一组值映射到 M=11 的表中。

在这里插入图片描述

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

在这里插入图片描述

3.1.2 二次探测

二次探测冲突解决方法：从发生冲突的位置开始，依次左右按二次方跳跃式探测，直到寻找到下一个没有存储数据的位置为止；如果往右走到哈希表尾，则回绕到哈希表头的位置；如果往左走到哈希表头，则回绕到哈希表尾的位置。
哈希函数计算方式为：h(key) = hash0 = key % M，若hash0位置冲突，则二次探测公式为：hc(key,i) = hashi = (hash0 ± i²) % M，其中i = {1, 2, 3, ..., M/2}。
需要注意的是，当hashi = (hash0 − i²) % M且hashi < 0时，需执行hashi += M使其回到合法位置。
下面演示{19, 30, 52, 63, 11, 22}这一组值映射到M=11的哈希表中的过程。

在这里插入图片描述

h(19) = 8, h(30) = 8, h(52) = 8, h(63) = 8, h(11) = 0, h(22) = 0

在这里插入图片描述

3.1.3 双重探测（了解）

哈希冲突的双重探测法：当第一个哈希函数计算出的值发生冲突时，使用第二个哈希函数计算出一个跟key相关的偏移量值，并不断往后探测，直到寻找到下一个空位为止。
具体实现为：h1(key)=hash0=key%M，若hash0位置冲突，则探测公式为hc(key,i)=(hash0+i*h2(key))%M（i=1,2,3,…,M）。
要求h2(key)与M互质，两种简单取值方法为：①当M为2的整数幂时，从[0,M-1]任选一个奇数；②当M为质数时，h2(key)=key%(M-1)+1。保持互质是为了确保探测能覆盖整个散列表，否则最大公约数p>1时，可寻址位置将减少为M/p个。例如初始位置1、偏移量3、表大小12时，只能访问{1,4,7,10}四个位置。
示例：将{19,30,52,74}插入M=11的表，设h2(key)=key%10+1。

在这里插入图片描述

3.1.4 开放地址码代码实现

开放定址法的哈希表结构
```
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; // 表中存储数据个数
};
```
需要注意的是，这里需要给每个存储值的位置加一个状态标识（如 {EXIST, EMPTY, DELETE}），否则删除某些值后会影响后续冲突值的查找。例如，删除 30 可能导致查找 20 失败；但如果为每个位置添加状态标识，删除 30 时只需将其状态改为 DELETE 而非直接删除值，这样在查找 20 时遇到 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

扩容

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作为哈希表key的情况非常常见，可以考虑对string类型进行特化处理。
template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};// 特化
template<>
struct HashFunc<string>
{
// 字符串转换成整形，可以把字符ascii码相加即可
// 但是直接相加的话，类似"abcd"和"bcad"这样的字符串计算出是相同的
// 这⾥我们使⽤BKDR哈希的思路，⽤上次的计算结果去乘以⼀个质数，这个质数⼀般去31, 131等效果会⽐较好size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash *= 131;hash += e;}return hash;}
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:
private:vector<HashData<K, V>> _tables;size_t _n = 0; // 表中存储数据个数
};    

完整代码实现

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 Hash = HashFunc<K>>class HashTable{public:// 获取下一个质数（用于哈希表扩容）inline unsigned long __stl_next_prime(unsigned long n){// 注意：假设long至少32位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;  // 结束位置// 使用lower_bound找到第一个不小于n的质数const unsigned long* pos = lower_bound(first, last, n);return pos == last ? *(last - 1) : *pos;  // 如果n大于所有质数，返回最大的}// 构造函数HashTable(){// 初始化为第一个质数大小的表_tables.resize(__stl_next_prime(0));}// 插入键值对bool Insert(const pair<K, V>& kv){// 如果键已存在，插入失败if (Find(kv.first))return false;// 负载因子大于0.7就扩容（_n*10/_tables.size() >=7 相当于 _n/_tables.size() >=0.7）if (_n * 10 / _tables.size() >= 7){// 创建新的哈希表HashTable<K, V, Hash> newHT;// 扩容到下一个质数大小newHT._tables.resize(__stl_next_prime(_tables.size()+1));// 将旧表中的有效数据重新插入到新表中for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._state == EXIST){newHT.Insert(_tables[i]._kv);}}// 交换新旧表（现代写法，利用RAII）_tables.swap(newHT._tables);}Hash hash;  // 哈希函数对象size_t hash0 = hash(kv.first) % _tables.size();  // 计算初始哈希位置size_t hashi = hash0;size_t i = 1;  // 探测步长// 线性探测寻找空位置while (_tables[hashi]._state == EXIST){// 线性探测：每次加1hashi = (hash0 + i) % _tables.size();// 如果是二次探测，可以改为 +- i^2++i;}// 找到空位置，插入数据_tables[hashi]._kv = kv;_tables[hashi]._state = EXIST;++_n;  // 增加元素计数return true;}// 查找键HashData<K, V>* Find(const K& key){Hash hash;  // 哈希函数对象size_t hash0 = hash(key) % _tables.size();  // 计算初始哈希位置size_t hashi = hash0;size_t i = 1;  // 探测步长// 线性探测查找while (_tables[hashi]._state != EMPTY){// 如果位置状态为EXIST且键匹配，返回该位置if (_tables[hashi]._state == EXIST&& _tables[hashi]._kv.first == key){return &_tables[hashi];}// 线性探测：每次加1hashi = (hash0 + i) % _tables.size();++i;}return nullptr;  // 未找到}// 删除键bool Erase(const K& key){// 先查找键是否存在HashData<K, V>* ret = Find(key);if (ret == nullptr){return false;  // 键不存在，删除失败}else{// 标记为DELETE状态（伪删除）ret->_state = DELETE;--_n;  // 减少元素计数return true;}}private:vector<HashData<K, V>> _tables;  // 哈希表存储数组size_t _n = 0;  // 表中存储的有效数据个数};
}

3.2 链地址法（重点）

解决冲突的思路
- 开放定址法中所有的元素都放到哈希表里，链地址法中所有的数据不再直接存储在哈希表中，哈希表中存储一个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成一个链表，挂在哈希表这个位置下面，链地址法也叫做拉链法或者哈希桶。
- 下面演示 {19,30,5,36,13,20,21,12,24,96} 等这一组值映射到M=11的表中。
- h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) = 10，h(12) = 1,h(24) = 2,h(96) = 88
扩容
- 开放定址法的负载因子必须小于1，而链地址法的负载因子没有限制，可以大于1。负载因子越大，哈希冲突的概率越高，但空间利用率也越高；负载因子越小，哈希冲突的概率越低，但空间利用率也越低。STL中 unordered_xxx 的最大负载因子基本控制在1，超过1时就会触发扩容，我们在后续实现中也采用这种方式。
- 对于极端场景，如果某个桶的链长度过长，可以考虑使用全域散列法来避免被针对性攻击。但即使采用全域散列法，若偶然出现某个桶长度过长导致查找效率下降，Java8的 HashMap 会在桶长度超过阈值（如8）时将链表转换为红黑树以提升性能。不过在实际应用中，通过合理扩容可以大幅降低单个桶过长的概率，因此在后续实现中我们暂不引入这种复杂机制，但了解这种极端场景的解决思路仍很有价值。

链地址法代码实现

namespace hash_bucket 
{/* 哈希节点模板类* 模板参数：*   K - 键(key)类型*   V - 值(value)类型* 实现原理：*   每个节点存储一个键值对，并通过_next指针形成链表*   这是解决哈希冲突的链式存储结构基础*/template<class K, class V>struct HashNode{pair<K, V> _kv;        // 存储实际的键值对数据HashNode<K, V>* _next; // 指向下一个节点的指针(用于解决哈希冲突的链表结构)/* 构造函数* 参数：kv - 要存储的键值对* 功能：初始化节点的键值对和next指针*/HashNode(const pair<K, V>& kv):_kv(kv)          // 使用初始化列表设置键值对,_next(nullptr)   // 新节点的next指针默认为nullptr{}};/* 哈希表模板类* 模板参数：*   K - 键类型*   V - 值类型  *   Hash - 哈希函数类型(默认为HashFunc<K>)* 实现特点：*   1. 使用vector存储桶(buckets)*   2. 链地址法解决冲突*   3. 自动扩容机制*/template<class K, class V, class Hash = HashFunc<K>>class HashTable{private:typedef HashNode<K, V> Node; // 节点类型别名，简化代码/* 获取下一个合适大小的素数(用于哈希表扩容)* 参数：n - 当前大小* 返回值：不小于n的最小素数，如果n超过最大值则返回最大素数* 设计原理：*   1. 使用素数作为表大小可以减少哈希冲突*   2. 预定义一组素数，扩容时选择合适的大小*/inline unsigned long __stl_next_prime(unsigned long n){// 预定义的素数列表(来自STL的实现)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};// 使用二分查找找到第一个不小于n的素数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:/* 构造函数* 功能：初始化哈希表，使用第一个素数(53)作为初始大小* 设计考虑：*   1. 初始大小不宜过小，避免频繁扩容*   2. 使用素数有利于哈希分布*/HashTable(){_tables.resize(__stl_next_prime(0), nullptr); // 0会返回第一个素数53}/* 析构函数* 功能：释放哈希表中所有节点* 实现细节：*   1. 遍历每个桶*   2. 遍历每个桶中的链表*   3. 逐个删除节点*/~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; // 将桶指针置空}}/* 插入键值对* 参数：kv - 要插入的键值对* 返回值：插入是否成功* 实现步骤：*   1. 检查是否需要扩容*   2. 计算哈希值确定桶位置*   3. 头插法插入新节点* 扩容策略：*   负载因子(元素数/桶数)达到1时扩容*/bool Insert(const pair<K, V>& kv){Hash hs; // 哈希函数对象size_t hashi = hs(kv.first) % _tables.size(); // 计算哈希值// 检查是否需要扩容(负载因子=1)if (_n == _tables.size()){// 创建新表，大小为下一个素数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 newHashi = hs(cur->_kv.first) % newtables.size();// 头插法将节点插入新表cur->_next = newtables[newHashi];newtables[newHashi] = cur;cur = next; // 处理下一个节点}_tables[i] = nullptr; // 清空旧桶}_tables.swap(newtables); // 交换新旧表}// 创建新节点并头插到对应桶中Node* newnode = new Node(kv);newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n; // 更新元素计数return true;}/* 查找键值对* 参数：key - 要查找的键* 返回值：找到的节点指针，未找到返回nullptr* 实现步骤：*   1. 计算哈希值确定桶位置*   2. 遍历链表查找键*/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; // 未找到}/* 删除键值对  * 参数：key - 要删除的键* 返回值：是否删除成功* 实现步骤：*   1. 计算哈希值确定桶位置*   2. 遍历链表查找键*   3. 维护链表结构并删除节点*/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;        // 表中存储的元素个数(用于计算负载因子)};
}