小叶-duck个人主页❄️个人专栏《Data-Structure-Learning》《C入门到进阶自我学习过程记录》《算法题讲解指南》--优选算法《算法题讲解指南》--递归、搜索与回溯算法《算法题讲解指南》--动态规划算法✨未择之路不须回头已择之路纵是荆棘遍野亦作花海遨游目录前言一. 哈希表核心概念1、哈希的本质2、哈希冲突3、负载因子4、将关键字转为整数二. 哈希函数设计1、直接定址法示例字符串中的第一个唯一字符2、除法散列法(除留余数法)重点3、乘法散列法了解即可4、全域散列法了解即可5、其他方法了解即可三. 哈希冲突解决策略1、开放定址法1.1 线性探测 含堆积问题1.2 二次探测1.3 双重探测2、详解开放定址法代码2.1 哈希表结构2.2 扩容问题2.2.1 扩容处理(二倍扩容版本)2.2.2 扩容处理(质数扩容版本)2.3 key不能取模的问题开放定址法完整代码实现测试代码3、详解链地址法代码3.1 对比开放定址法和链地址法3.2 哈希桶概念及其示例3.3 扩容链地址法完整代码实现测试代码开放定址法 VS 链地址法 两种实现对比结束语前言哈希表是数据结构中的 “效率王者”通过哈希函数建立key 与存储位置的映射实现增删查改平均O (1)的时间复杂度广泛应用于 unordered_set/unordered_map、缓存、字典等场景。但很多朋友只知道怎么使用哈希表却不知道哈希表到底是怎么实现的 —— 哈希冲突如何解决不同哈希函数有何差异开放定址法和链地址法该怎么实现本文从哈希表的基本概念入手详解哈希函数设计、哈希冲突解决策略最终完整实现开放定址法线性探测 和链地址法哈希桶 两种哈希表帮你吃透哈希表的底层实现逻辑。一. 哈希表核心概念1、哈希的本质哈希(hash)又称散列故哈希表又称散列表是一种组织数据的方式。哈希是音译名从译名来看有散乱排列散列的意思。哈希的本质就是通过哈希函数把关键字Key跟存储位置建立一个映射关系查找时通过这个哈希函数计算出Key存储的位置进行快速查找。哈希函数将 key 映射到哈希表的存储位置下标公式为h(key) 存储位置核心目标让 key均匀分布减少冲突保证 O (1) 平均效率。2、哈希冲突两个不同的 key通过哈希函数计算出相同的存储位置称为哈希冲突哈希碰撞。冲突无法避免只能通过优化哈希函数和冲突解决策略减少影响。3、负载因子衡量哈希表拥挤程度的指标公式为负载因子(λ) 存储的元素个数(N) / 哈希表大小(M)。λ 越大冲突概率越高空间利用率越高λ 越小冲突概率越低空间利用率越低实践中开放定址法 λ 通常控制在 0.7 以内链地址法 λ 控制在 1 以内。分析假如哈希表中已经映射存储了N个值哈希表的大小为M那么通过负载因子 N/M负载因子有些地方也翻译为载荷因子/装载因子等他的英文为 load factor。负载因子越大哈希冲突的概率越高空间利用率越高负载因子越小哈希冲突的概率越低空间利用率越低。4、将关键字转为整数我们将关键字映射到数组中位置一般是整数好做映射计算(通过哈希函数)如果不是整数我们要想办法转换成整数这个细节我们后面代码实现中再进行细节展示。下面哈希函数部分我们讨论时如果关键字不是整数那么讨论的Key是关键字转换成的整数。二. 哈希函数设计好的哈希函数能让 key 均匀分布减少冲突但是实际中却很难做到但是我们要尽量往这个方向去考量设计常用设计方法如下1、直接定址法直接用 key 或 key 的线性变换作为存储位置公式h(key) a*key b。适用场景key范围集中如 0-99、a-z、A-Z等优点无冲突效率高缺点key 范围分散时浪费内存如 key 为 1、10000需开 10001 大小的数组。分析在关键字的范围比较集中时直接定值法就是非常高效的方法比如一组关键字都在[099]之间那么我们开一个100个数的数组每个关键字1的值直接就算存储位置的下标。再比如一组关键字值都在[az]的小写字母那么我们开一个26个数的数组每个关键字ascill码 - a的ascii码就是存储位置的下标。也就是说直接定址法本质就是用关键字计算出一个绝对位置或者相对位置。这个方法我们在计数排序部分已经用过了其次在 string 的学习中一道OJ也用过了示例字符串中的第一个唯一字符387. 字符串中的第一个唯一字符 - 力扣LeetCode题目描述C算法代码class Solution { public: int firstUniqChar(string s) { int arr[26]; //存放相对于26个字母对应下标的数组 for(auto ch : s) { arr[ch - a]; } //计数排序的逻辑 for(int i 0; i s.size(); i) { if(arr[s[i] - a] 1) { return i; } } return -1; } };2、除法散列法(除留余数法)重点1、除法散列法也叫做除留余数法顾名思义假设哈希表的大小为M那么通过key除以M的余数作为映射位置的下标也就是哈希函数为h(key) key % M。2、当使用除法散列法时要尽量避免M为某些值如2的幂10的幂等。如果是2^Xkey % 2^X 本质相当于保留 key 二进制位的后X位后X位相同的值计算出的哈希值都是一样的——就冲突了。比如{6331}看起来没有关联的值如果M是16也就是2^4那么计算出的哈希值都是15因为63的二进制后8位是0011111131的二进制后8位是00011111。如果是10^x就更明显了保留的都是10进值的后X位如[112,12312}如果M是100(10^2)计算出的哈希值都是12。3、当使用除法散列法时建议M取不太接近2的整数次幂的一个质数素数那具体怎么取质数在下面的哈希表扩容操作会进行讲解而且我也会把二倍扩容的代码展示出来虽然是要避免哈希表大小2的幂但是为便于大家理解质数的扩容我也进行展示。3、乘法散列法了解即可乘法散列法对哈希表大小M没有要求这里介绍一下大思路第一步用关键字K乘上常数A0 A 1)并抽取出k*A的小数部分第二步后再用M乘以k * A的小数部分再向下取整。h(key) floor(M * ((A * key) % 1.0))其中floor表示对表达式进行下取整A(0 , 1)%1.0是为了取小数这里最重要的是A的值应该如何设定Knuth——这又是一位大佬——他认为A (5 - 1) / 2 0.6180339887...黄金分割点)比较好。乘法散列法对哈希表大小M是没有要求的假设M为1024key为1234A 0.6180339887A * key 762.6539420558取小数部分为0.6539420558,M * ((A * key) % 1.0) 0.6539420558*1024 669.6366651392那么h(1234) 669。4、全域散列法了解即可如果存在这样一个恶意的对手他针对我们提供的散列函数特意构造出一个发生严重冲突的数据集比如让所有关键字全部落入同一个位置中——这种情况是可以存在的只要散列函数是公开且确定的就可以实现此攻击。解决方法自然是见招拆招给散列函数增加随机性攻击者就无法找出确定可以导致最坏情况的数据。这种方法叫做全域散列。hab(key) ((a * key 6) % P) % MP需要选一个足够大的质数a可以随机选[1 , P - 1]之间的任意整数b可以随机选[0 , P - 1]之间的任意整数这些函数构成了一个P * (P - 1)组全域散列函数组。假设P 17M 6a 3b 4,则h34(8) ((3 * 8 4) % 17) % 6 5。需要注意的是每次初始化哈希表时随机选取全域散列函数组中的一个散列函数使用后续增删查改都固定使用这个散列函数否则每次哈希都是随机选一个散列函数那么插入是一个散列函数查找又是另一个散列函数就会导致找不到插入的key了。5、其他方法了解即可上面的几种方法是在《算法导论》这本书籍中讲解的方法。《殷人昆数据结构用面向对象方法与C语言描述 (第二版)》和《[数据结构 (C语言版).严蔚敏吴伟民》等教材型书籍上面还给出了平方取中法、折叠法、随机数法、数学分析法等这些方法相对更适用于一些局限的特定场景大家如果有兴趣可以去看看这些书籍。三. 哈希冲突解决策略实践中哈希表一般还是选择除法散列法作为哈希函数当然哈希表无论选择什么哈希函数也避免不了冲突因为冲突是避免不了的我们只能减少冲突。冲突解决是哈希表实现的核心主流分为开放定址法和链地址法其中链地址法更加重要一点下面分别详解实现。1、开放定址法在开放定址法中所有的元素都放到哈希表里当一个关键字key用哈希函数计算出的位置冲突了则按照某种规则找到一个没有存储数据的位置进行存储开放定址法中负载因子一定是小于1的。这里的规则有三种线性探测、二次探测、双重探测。1.1 线性探测 含堆积问题我们先简单谈谈“堆积 / 群积问题”如下图所示1.2 二次探测1.3 双重探测2、详解开放定址法代码开放定址法在实践中是不如下面会介绍的链地址法的因为开放定址法解决冲突不管使用哪种方法占用的都是哈希表中的空间始终存在互相影响的问题——正因如此开放定址法我们简单选择线性探测实现即可。2.1哈希表结构// 状态标识 enum State { EMPTY, // 空位置 EXIST, // 已存储元素 DELETE // 已删除元素 }; // 哈希表结点结构 templateclass K, class V struct HashDate { pairK, V _kv; // 存储key-value对 State _state EMPTY; //初始状态为空 }; // 哈希函数仿函数 templateclass K struct HashFunc { size_t operator()(const K key) { return (size_t)key; // 默认可支持直接转换 } }; // 开放定址法实现哈希表(线性探测) templateclass K, class V, class Hash HashFuncK class HashTable { public: private: vectorHashDateK, V _tables; // 哈希表数组 size_t _n 0; // 已存储的数据个数(作用用于负载因子的计算当负载因子不满足要求需要对_tables进行扩容) };要注意的是这里需要给每个存储值的位置加一个状态标识否则删除一些值以后会影响后面冲突的值的查找。如下图所示我们删除30会导致查找20失败当我们给每个位置加一个状态标识{EXISTEMPTYDELETE}删除30就可以不用删除值而是把状态改为DELETE那么查找20时是遇到EMPTY才能就可以找到20。h(19) 8h(30) 8h(5) 5h(36) 3h(13) 2h(20) 9h(21) 10h(12) 1。2.2 扩容问题这里我们哈希表负载因子控制在0.7当负载因子到0.7以后我们就需要扩容了我们还是按照2倍的方式扩容但是同时我们要保持哈希表大小是一个质数第一个是质数2倍后就不是质数了。如何解决方案是SGI版本的哈希表使用的方法给了一个近似2倍的质数表每次去质数表获取扩容后的大小2.2.1 扩容处理(二倍扩容版本)// 开放定址法实现哈希表(线性探测) templateclass K, class V, class Hash HashFuncK class HashTable { public: // 构造函数(二倍扩容版本) HashTable() :_tables(4) { } // 插入 key-value对(去重) bool insert(const pairK, V kv) { // 1.先查找避免重复插入(如果存在则返回false) if (Find(kv.first)) { return false; } // 2.负载因子 0.7扩容 if ((double)_n / (double)_tables.size() 0.7) { //创建一个HashTable对象而不是HashTable的vector对象原因是 //当扩容转移数据的时候vector对象也需要执行下面的插入操作(代码冗余) //如果是HashTable对象我们就可以巧妙的调用自己的insert函数 HashTableK, V, Hash newht; //二倍扩容版本不推荐(冲突的情况更加频繁) newht._tables.resize(2 * _tables.size()); // 3.迁移旧表元素到新表 //这里是重点哈希表的扩容转移数据和前面学习的vector等容器不一样 //vector的扩容转移数据只需要扩容后直接拷贝即可 //但是哈希表扩容后_tables.size()发生了改变 //相应的负载因子分母也就变大了即所有数据的映射关系全部发生了改变所以需要重新映射 for (int i 0; i _tables.size(); i) { if (_tables[i]._state EXIST) { newht.insert(_tables[i]._kv); //这里有人看到函数自己调用自己就觉得是不是递归有没有问题 //其实这里并不会一直递归下去很显然newht的负载因子一定是小于0.7 //所以每次for循环只会进行插入数据给newht } } // 4.交换新旧表 _tables.swap(newht._tables); } // 5.线性探测找空闲位置插入数据 //kv.first为整型 size_t hash0 kv.first % _tables.size(); // 线性探测 size_t i 1; size_t hashi hash0; while (_tables[hashi]._state EXIST) { // 冲突线性探测下一个位置 hashi (hash0 i) % _tables.size(); i; } // 6.插入元素 _tables[hashi]._kv kv; _tables[hashi]._state EXIST; _n; //插入数据后哈希表数组存储数据个数加1 return true; } private: vectorHashDateK, V _tables; size_t _n 0; };2.2.2 扩容处理(质数扩容版本)// 开放定址法实现哈希表(线性探测) templateclass K, class V, class Hash HashFuncK class HashTable { public: // 构造函数 HashTable() :_tables(__stl_next_prime(0)) { } // 插入 key-value对(去重) bool insert(const pairK, V kv) { // 1.先查找避免重复插入(如果存在则返回false) if (Find(kv.first)) { return false; } // 2.负载因子 0.7扩容 if ((double)_n / (double)_tables.size() 0.7) { HashTableK, V, Hash newht; //质数扩容版本推荐 newht._tables.resize(__stl_next_prime(_tables.size() 1)); // 3.迁移旧表元素到新表 for (int i 0; i _tables.size(); i) { if (_tables[i]._state EXIST) { newht.insert(_tables[i]._kv); } } // 4.交换新旧表 _tables.swap(newht._tables); } // 5.线性探测找空闲位置插入数据 //kv.first为整型 size_t hash0 kv.first % _tables.size(); // 线性探测 size_t i 1; size_t hashi hash0; while (_tables[hashi]._state EXIST) { // 冲突线性探测下一个位置 hashi (hash0 i) % _tables.size(); i; } // 6.插入元素 _tables[hashi]._kv kv; _tables[hashi]._state EXIST; _n; return true; } private: vectorHashDateK, V _tables; size_t _n 0; };2.3 key不能取模的问题当key是string / Date等类型时key不能取模我们需要给HashTable增加一个仿函数这个仿函数支持把key转换成一个可以取模的整型如果key可以直接转换为整型并且不容易冲突那么这个仿函数就用默认参数即可如果这个Key不能转换为整型我们就需要自己实现一个仿函数传给这个参数实现这个仿函数的要求就是尽量key的每值都参与到计算中让不同的key转换出的整型值以此避免冲突频繁。// 哈希函数仿函数 templateclass K struct HashFunc { size_t operator()(const K key) { return (size_t)key; // 默认可支持直接转换 } }; // 特化string类型的哈希函数 template struct HashFuncstring { // BKDR字符串哈希算法 size_t operator()(const string key) { size_t hash 0; for (auto ch : key) { // 字符串转换成整形可以把字符ascii码相加即可 // 但是直接相加的话类似abcd和bcad这样的字符串计算出是相同的,冲突就会比较频繁 // 这里我们使用BKDR哈希的思路用上次的计算结果去乘以一个质数131 hash ch;// 累加字符ASCII码 hash * 131;// 乘质数131减少冲突 } return hash; } };开放定址法完整代码实现#includeiostream #includevector #includestring using namespace std; // 状态标识 enum State { EMPTY, // 空位置 EXIST, // 已存储元素 DELETE // 已删除元素 }; // 哈希表结点结构 templateclass K, class V struct HashDate { pairK, V _kv; // 存储key-value对 State _state EMPTY; //初始状态为空 }; // 质数表(SGI 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 }; inline unsigned long __stl_next_prime(unsigned long n) { const unsigned long* first __stl_prime_list; const unsigned long* last __stl_prime_list __stl_num_primes; // n const unsigned long* pos lower_bound(first, last, n); return pos last ? *(last - 1) : *pos; } // 哈希函数仿函数 templateclass K struct HashFunc { size_t operator()(const K key) { return (size_t)key; // 默认可支持直接转换 } }; // 特化string类型的哈希函数 template struct HashFuncstring { // BKDR字符串哈希算法 size_t operator()(const string key) { size_t hash 0; for (auto ch : key) { hash ch; hash * 131; } return hash; } }; // 开放定址法实现哈希表(线性探测) templateclass K, class V, class Hash HashFuncK class HashTable { public: //// 构造函数(二倍扩容版本) //HashTable() // :_tables(4) //{ } // 构造函数 HashTable() :_tables(__stl_next_prime(0)) { } // 插入 key-value对(去重) bool insert(const pairK, V kv) { // 1.先查找避免重复插入(如果存在则返回false) if (Find(kv.first)) { return false; } // 2.负载因子 0.7扩容 if ((double)_n / (double)_tables.size() 0.7) { HashTableK, V, Hash newht; ////二倍扩容版本不推荐(冲突的情况更加频繁) //newht._tables.resize(2 * _tables.size()); //质数扩容版本推荐 newht._tables.resize(__stl_next_prime(_tables.size() 1)); // 3.迁移旧表元素到新表 for (int i 0; i _tables.size(); i) { if (_tables[i]._state EXIST) { newht.insert(_tables[i]._kv); } } // 4.交换新旧表 _tables.swap(newht._tables); } // 5.线性探测找空闲位置插入数据 ////kv.first为整型 //size_t hash0 kv.first % _tables.size(); //kv.first为非整型类型(使用仿函数) 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; } // 6.插入元素 _tables[hashi]._kv kv; _tables[hashi]._state EXIST; _n; return true; } // 查找key返回节点指针(nullptr表示未找到) HashDateK, V* Find(const K key) { ////key为整型 //size_t hash0 key % _tables.size(); //kv.first为非整型类型(使用仿函数) 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; } // 删除key(仅修改状态为DELETE,不实际删除元素后续插入操作遇到DELETE状态直接覆盖即可) bool Erase(const K key) { HashDateK, V* ret Find(key); if (ret) { ret-_state DELETE; _n--; } return false; } private: vectorHashDateK, V _tables; size_t _n 0; };测试代码#includeHashTable.h void test_hashtable1() { HashTableint, int ht1; int arr[] { 19, 30, 5, 36, 13, 20, 21, 12 }; for (auto e : arr) { ht1.insert({ e, e }); } cout ht1.Find(5) endl; cout ht1.Find(20) endl; ht1.Erase(5); cout ht1.Find(5) endl; cout ht1.Find(20) endl; } void test_hashtable2() { HashTablestring, string dict; dict.insert({ string,字符串 }); // string正常无法直接取模需要通过哈希函数转换成整型(需要手动实现仿函数) dict.insert({ string,字符串1 }); dict.insert({ left,左边 }); dict.insert({ right,右边 }); cout dict.Find(string) endl; cout dict.Find(left) endl; cout dict.Find(insert) endl; } int main() { cout 测试一:删除5后再查找 endl; test_hashtable1(); cout endl; cout 测试二:测试string类型 endl; test_hashtable2(); return 0; }3、详解链地址法代码3.1 对比开放定址法和链地址法开放定址法链地址法3.2 哈希桶概念及其示例开放定址法中所有的元素都放到哈希表里链地址法中所有的数据不再直接存储在哈希表中哈希表中存储一个指针没有数据映射这个位置时这个指针为空有多个数据映射到这个位置时把这些冲突的数据链接成一个链表挂在哈希表这个位置下面像是一个个挂在晾衣杆的水桶链地址法也叫做拉链法或者哈希桶。以 { 1930536132021122496 } 这一组值为例映射到M 11的表中h(19) 8h(30) 8h(5) 5h(36) 3h(13) 2h(20) 9h(21) 10h(12) 1, h(24) 2h(96) 883.3 扩容开放定址法负载因子必须小于1链地址法的负载因子就没有限制了可以大于1。负载因子越大哈希冲突的概率越高空间利用率越高负载因子越小哈希冲突的概率越低空间利用率越低。stl中unordered_xxx的最大负载因子基本控制在1负载因子平均是1但是这是理想的情况当然没有那么平均有的哈希桶不挂有的挂2~3个大于1就扩容。我们就以负载因子 1为条件进行扩容。需要注意的是链地址法的扩容和开放地址法的扩容实现有所区别。链地址法完整代码实现#includeiostream #includevector #includestring using namespace std; // 质数表(SGI 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 }; inline unsigned long __stl_next_prime(unsigned long n) { const unsigned long* first __stl_prime_list; const unsigned long* last __stl_prime_list __stl_num_primes; // n const unsigned long* pos lower_bound(first, last, n); return pos last ? *(last - 1) : *pos; } // 哈希函数仿函数 templateclass K struct HashFunc { size_t operator()(const K key) { return (size_t)key; // 默认可支持直接转换 } }; // 特化string类型的哈希函数 template struct HashFuncstring { // BKDR字符串哈希算法 size_t operator()(const string key) { size_t hash 0; for (auto ch : key) { // 字符串转换成整形可以把字符ascii码相加即可 // 但是直接相加的话类似abcd和bcad这样的字符串计算出是相同的,冲突就会比较频繁 // 这里我们使用BKDR哈希的思路用上次的计算结果去乘以一个质数131 hash ch;// 累加字符ASCII码 hash * 131;// 乘质数131减少冲突 } return hash; } }; // 链地址法哈希表哈希桶 namespace hash_bucket { // 哈希桶节点结构链表节点 templateclass K, class V struct HashNode { pairK, V _kv; HashNode* _next; HashNode(const pairK, V kv) :_kv(kv) , _next(nullptr) { } }; templateclass K, class V, class Hash HashFuncK class HashTable { typedef HashNodeK, V Node; public: //构造函数 HashTable() :_tables(__stl_next_prime(0)) ,_n(0) { } //析构函数 ~HashTable() { for (size_t i 0; i _tables.size(); i) { Node* cur _tables[i]; while (cur) { Node* next cur-_next; _tables[i] next; delete cur; cur next; } } _n 0; } //拷贝构造(深拷贝) HashTable(const HashTableK, V ht) { this-_tables.resize(ht._tables.size()); for (size_t i 0; i ht._tables.size(); i) { Node* cur ht._tables[i]; while (cur) { insert(cur-_kv); cur cur-_next; } } } void Swap(HashTableK, V ht) { std::swap(_tables, ht._tables); std::swap(_n, ht._n); } //赋值重载operator(现代写法) HashTableK, V operator(HashTableK, V ht) { if (this ! ht) { Swap(ht); } return *this; } // 插入key-value对头插法去重需先查找 bool insert(const pairK, V kv) { if (Find(kv.first)) { return false; } Hash hs; if (_n _tables.size()) { /*HashTableK, V newht; newht._tables.resize(2 * _tables.size()); for (int i 0; i _tables.size(); i) { Node* cur _tables[i]; while (cur) { newht.insert(cur); cur cur-_next; } } _tables.swap(newht._tables);*/ //迁移旧表节点到新表直接移动节点不新建效率更高 vectorNode* newtables(__stl_next_prime(_tables.size() 1); for (int i 0; i _tables.size(); i) { // 遍历旧表旧表节点重新映射挪动到新表 Node* cur _tables[i]; while (cur) { //重新计算节点在新表的位置 size_t hashi hs(cur-_kv.first) % newtables.size(); //头插入新表 Node* next cur-_next; cur-_next newtables[hashi]; newtables[hashi] cur; cur next; }//while循环结束说明第i位置的链表结点已经全部挪走了需要置空 _tables[i] nullptr; } _tables.swap(newtables); } //头插入当前节点 size_t hashi hs(kv.first) % _tables.size(); Node* newnode new Node(kv); newnode-_next _tables[hashi];//newnode的下一个位置指向hashi位置的头节点 _tables[hashi] newnode; //让newnode变为头节点 _n; return true; } // 查找key返回节点指针nullptr表示未找到 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链表节点删除 bool Erase(const K key) { Hash hs; size_t hashi hs(key) % _tables.size(); Node* cur _tables[hashi]; Node* prev nullptr; //提前获取链表当前结点的上一个结点 //用于判断删除的是头节点还是中间结点 while (cur) { if (cur-_kv.first key) { if (prev nullptr) { //prev为空说明删除链表头节点 _tables[hashi] cur-_next; } else { //prev不为空说明删除中间结点 prev-_next cur-_next; } delete cur; _n--; return true; } else { prev cur; cur cur-_next; } } return false; } private: vectorNode* _tables;// 指针数组存储每个链表头指针 size_t _n 0; }; }测试代码void test_hashbucket1() { int arr2[] { 19, 30, 5, 36, 13, 20, 21, 12, 24, 96 }; hash_bucket::HashTableint, int ht2; for(auto e : arr2) { ht2.insert({ e, e }); } //拷贝构造 hash_bucket::HashTableint, int ht3 ht2; //赋值重载 hash_bucket::HashTableint, int ht4; ht4 ht3; cout ht2.Find(96) endl; cout ht2.Find(30) endl; cout ht2.Find(19) endl; ht2.Erase(96); ht2.Erase(30); ht2.Erase(19); cout ht2.Find(96) endl; cout ht2.Find(30) endl; cout ht2.Find(19) endl; } void test_hashbucket2() { hash_bucket::HashTablestring, string dict; dict.insert({ string, 字符串 }); dict.insert({ string, 字符串1 }); dict.insert({ left, 左边 }); dict.insert({ right, 右边 }); cout dict.Find(string) endl; cout dict.Find(left) endl; cout dict.Find(insert) endl; } int main() { cout 哈希桶测试一:插入、查找、拷贝、赋值 删除 endl; test_hashbucket1(); cout endl; cout 哈希桶测试二:测试string类型 endl; test_hashbucket2(); return 0; }关键细节节点迁移扩容时直接移动旧表节点到新表不新建节点减少内存开销链表操作插入用头插法效率高删除需记录前驱节点开放定址法 VS 链地址法 两种实现对比对比维度开放定址法线性探测链地址法哈希桶空间利用率较低需预留空闲位置装载因子 λ 通常 ≤ 0.7较高冲突元素链成链表装载因子 λ 可以 ≥ 1冲突处理线性探测易产生一次群集现象链表存储冲突元素被归入同一桶中无群集问题实现复杂度较高需处理状态标识、扩容迁移逻辑复杂较低主要是链表操作逻辑相对简单查找效率平均O(1)最坏O(N)群集严重时退化平均O(1)最坏O(k)k为单个桶的链表长度适用场景空间充足、数据量固定或可预测的场景高频插入删除、数据量动态变化的场景如C unordered_map/unordered_set)缓存性能更好数据连续存储 locality 高较差链表节点在内存中不连续访问可能跳跃扩容操作成本高所有元素需要重新哈希并迁移到新表成本相对较低只需重新哈希节点可重新挂载结束语到此哈希表的实现就讲解完了。哈希表的核心是 “哈希函数 冲突解决”好的哈希函数保证 key 均匀分布合理的冲突策略保证效率稳定。开放定址法适合空间充足的场景链地址法因实现简单、无群集问题成为工业级实现的首选如 C 的 unordered_map / unordered_set。本文实现的两种哈希表覆盖了哈希表的核心细节质数扩容、字符串哈希、元素迁移、状态标识等。掌握这些细节后不仅能理解 STL 容器的底层实现更能根据实际场景选择合适的哈希表设计。希望对大家学习C能有所收获C参考文档https://legacy.cplusplus.com/reference/https://zh.cppreference.com/w/cpphttps://en.cppreference.com/w/