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

引言

哈希表（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)
              {
                  // 线性探测：每次加1
                  hashi = (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];
                  }
                  
                  // 线性探测：每次加1
                  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
              {
                  // 标记为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;        // 表中存储的元素个数(用于计算负载因子)
      };
  }