C++：哈希表的实现
详细介绍哈希表
一、哈希概念
哈希(hash)又称散列，是一种组织数据的方式。从译名来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key和存储位置建立一个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进行快速查找。
二、直接定址法
当关键字的范围比较集中时，直接定址法就是非常简单高效的方法，比如一组关键字都在[0,99]之间， 那么我们开一个100个数的数组，每个关键字的值直接就是存储位置的下标。再比如一组关键字值都在 [a,z]的小写字母，那么我们开一个26个数的数组，每个关键字 ASCII码-a，ASCII码就是存储位置的下标。 也就是说直接定址法本质就是用关键字计算出一个绝对位置或者相对位置。
387. 字符串中的第一个唯一字符 - 力扣（LeetCode）
class Solution {
public:int firstUniqChar(string s) {int size = s.size();int count[256];for(int i = 0; i < size; i++){count[s[i]]++;}for(int i = 0; i < size; i++){if(count[s[i]] == 1)return i;}return -1;}
};这里直接开了个256空间，就不需要减a字符了。
三、哈希冲突
直接定址法的缺点也非常明显，当关键字的范围比较分散时，就很浪费内存甚至内存不够用。假设我们只有数据范围是[0,9999]的N个值，我们要映射到一个M个空间的数组中(一般情况下M>=N)，那么就要借助哈希函数(hashfunction)hf，关键字key被放到数组的h(key)位置，这里要注意的是h(key)计算出的值必须在[0,M)之间。 这里存在的一个问题就是，两个不同的key可能会映射到同一个位置去，这种问题我们叫做哈希冲突， 或者哈希碰撞。理想情况是找出一个好的哈希函数避免冲突，但是实际场景中，冲突是不可避免的， 所以我们尽可能设计出优秀的哈希函数，减少冲突的次数，同时也要去设计出解决冲突的方案。
四、负载因子
假设哈希表中已经映射存储了N个值，哈希表的大小为M，那么负载因子 = N / M ，负载因子有些地方也翻译为载荷因子/装载因子等，他的英文为loadfactor。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低；
五、哈希函数
一个好的哈希函数应该让N个关键字被等概率的均匀的散列分布到哈希表的M个空间中，但是实际中却很难做到，但是我们要尽量往这个方向去考量设计。
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所有的位都参与计算，这样映射出的哈希值更均匀一些即可。所以上面建议M取不太接近2的整数次幂的一个质数的理论是大多数数据结构书籍中写的理论，但是实践中， 灵活运用，抓住本质，而不能死读书。（了解）
2.乘法散列法（了解）
乘法散列法对哈希表大小M没有要求，他的大思路第⼀步：用关键字K乘上常数A(0<A<1)，并抽取出k*A的小数部分。第二步：用M乘以k*A的小数部分，再向下取整。
h(key) = floor(M ×((A ×key)%1.0)) ，其中floor表示对表达式进行下取整，A∈(0,1)，这里最重要的是A的值应该如何设定，Knuth认为A =( 根号5 - 1)/2 = 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。
3.全域散列法（了解）
如果存在一个恶意的对手，他针对我们提供的散列函数，特意构造出一个发生严重冲突的数据集，比如，让所有关键字全部落入同一个位置中。这种情况是可以存在的，只要散列函数是公开且确定的，就可以实现此攻击。解决方法自然是见招拆招，给散列函数增加随机性，攻击者就无法找出确定可以导致最坏情况的数据。这种方法叫做全域散列。
h (key) = ((a ×key +b)%P)%M ，P需要选一个足够大的质数，a可以随机选[1,P-1]之间的任意整数，b可以随机选[0,P-1]之间的任意整数，这些函数构成了一个P*(P-1)组全域散列函数组。
假设P=17，M=6，a=3，b=4,则 h (8) = ((3 ×8+4)%17)%6 = 5。
需要注意的是每次初始化哈希表时，随机选取全域散列函数组中的一个散列函数使用，后续增删查改都固定使用这个散列函数，否则每次哈希都是随机选一个散列函数，那么插入是一个散列函数，查找又是另一个散列函数，就会导致找不到插入的key了。
4.其他方法
上面的几种方法是《算法导论》书籍中讲解的方法。《殷人昆 数据结构：用面向对象方法与C++语言描述（第⼆版）》和《[数据结构(C语言版)].严蔚敏_吴伟民》等教材型书籍上面还给出了平方取中法、折叠法、随机数法、数学分析法等，这些方法相对更适用于一些局限的特定场景，有兴趣可以去看看这些书籍。
六、处理哈希冲突
实践中哈希表一般还是选择除法散列法作为哈希函数，当然哈希表无论选择什么哈希函数也避免不了冲突，那么插入数据时，如何解决冲突呢？主要有两种方法，开放定址法和链地址法。
1.开放定址法
在开放定址法中所有的元素都放到哈希表里，当一个关键字key用哈希函数计算出的位置冲突了，则按照某种规则找到一个没有存储数据的位置进行存储，开放定址法中负载因子一定是小于的。这里的规则有三种：线性探测、⼆次探测、双重探测。
1.1线性探测
从发生冲突的位置开始，依次线性向后探测，直到寻找到下一个没有存储数据的位置为止，如果走到哈希表尾，则回绕到哈希表头的位置。
h(key) = hash0 = key % M，hash0位置冲突了，则线性探测公式为：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的表中
1.2二次探测
从发生冲突的位置开始，依次左右按二次方跳跃式探测，直到寻找到下一个没有存储数据的位置为止，如果往右走到哈希表尾，则回绕到哈希表头的位置；如果往左走到哈希表头，则回绕到哈希表尾的位置；
h(key) = hash0 = key % M , hash0位置冲突了，则⼆次探测公式为：
hc(key,i) = hashi = (hash0 ± i^2) % M ， i = {1,2,3,..., M / 2}
二次探测当时，当hashi = (hash0 − i^2 )%M 时，当hashi < 0 需要hashi+=M
下面演示 {19,30,52,63,11,22} 等这一组值映射到M=11的表中
1.3双重散列(了解)
第一个哈希函数计算出的值发生冲突，使用第二个哈希函数计算出一个跟key相关的偏移量值，不断往后探测，直到寻找到下一个没有存储数据的位置为止。
h(key) = hash0 = key % M , hash0位置冲突了，则双重探测公式为：
hc(key,i) = hashi = (hash0+ i∗h2(key)) % M ， i = {1,2,3,..., M}
要求h2(key) < M 且 h2(key) 和M互为质数，有两种简单的取值方法：1、当M为2整数幂时，h2(key) 从[0，M-1]任选一个奇数；2、当M为质数时，h2(key) = key % (M −1) + 1
保证 h2(key) 与 M 互质是因为根据固定的偏移量所寻址的所有位置将形成一个群，若最大公约数p= gcd(M, h1(key)) > 1，那么所能寻址的位置的个数为 M / P < M 使得对于一个关键字来说无法充分利用整个散列表。举例来说，若初始探查位置为1，偏移量为3，整个散列表大小为12， 那么所能寻址的位置为{1,4,7,10}，寻址个数为 12/gcd(12,3) = 4
下面演示 {19,30,52,74} 等这一组值映射到M=11的表中，设 h2(key) = key%10+1
2.链地址法
开放定址法中所有的元素都放到哈希表里，链地址法中所有的数据不再直接存储在哈希表中，哈希表中存储一个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成一个链表，挂在哈希表这个位置下面，链地址法也叫做拉链法或者哈希桶。
下面演示 { 19, 30, 5, 36, 13, 20, 21, 12, 24, 96} 等这一组值映射到M=11的表中。
七、开放定址法代码实现
1.框架
要注意的是这里需要给每个存储值的位置加一个状态标识，否则删除⼀些值以后，会影响后面冲突的值的查找。
#pragma once#include<vector>enum status
{EXIST,EMPTY,DELETE
};template<class K, class V>
struct HashData
{pair<K, V> _kv;status _status = EMPTY;
};template<class K, class V>
class HashTable
{
public:HashTable():_tables(11),_n(0){};bool Insert(const pair<K, V>& kv){//......}
private:std::vector<HashData<K, V>> _tables;size_t _n = 0;
};2.实现插入和扩容
2.1插入
bool Insert(const pair<K, V>& kv){// 负载因子 >= 0.7 就扩容//......size_t hash0 = kv.first % _tables.size();size_t hashi = hash0;size_t i = 1;//线性探测while (_tables[hashi]._status == EXIST){hashi = (hash0 + i) % _tables.size();i++;}_tables[hashi]._kv = kv;_tables[hashi]._status = EXIST;++_n;return true;}2.2扩容
// 负载因子 >= 0.7 就扩容if ((double)_n / _tables.size() >= 0.7){// 方法一：//std::vector<HashData<K, V>> newtables(_tables.size()*2);//// 遍历旧表将所有值映射到新表//for (auto& data : _tables)//{// if (data._status == EXIST)// {// //...// }//}//_tables.swap(newtables);// 方法二：HashTable<K, V> newHT;newHT._tables.resize(2 * _tables.size());// 遍历旧表将所有值映射到新表for (auto& data : _tables){if (data._status == EXIST){newHT.Insert(data._kv);}}_tables.swap(newHT._tables);}sgi版本的哈希表使用的方法，给了一个近似2倍的质数表，每次去质数表获取扩容后的大小。
// 从源码中拷贝下来的 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; }函数功能
给定一个无符号整数
n，返回大于或等于n的最小质数。若n大于预设的最大质数，则返回预设的最大质数。实现细节
预设质数列表代码中定义了一个静态数组
__stl_prime_list，包含 28 个预先计算好的质数，从小到大排列。这些质数是经过选择的 “合适” 质数（相邻质数约为前一个的 2 倍），覆盖了从 53 到 4294967291（接近 32 位无符号整数的最大值 4294967295）的范围。查找逻辑使用标准库算法
lower_bound在质数列表中查找第一个大于或等于n的质数：
lower_bound(first, last, n)返回指向列表中首个不小于n的元素的指针。- 若找到（
pos未指向列表末尾），则返回该元素（*pos）。- 若未找到（
pos指向列表末尾，即n大于列表中所有质数），则返回列表中最大的质数（*(last - 1)）。适用范围注释提到 “assumes long is at least 32 bits”，即假设
long类型至少为 32 位，以确保能容纳最大质数 4294967291（32 位无符号整数的最大值为 4294967295，刚好能容纳）。
3.查找和删除
//查找 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]._status != EMPTY){if (_tables[hashi]._status == EXIST&& _tables[hashi]._kv.first == key)return &_tables[hashi];hashi = (hash0 + i) % _tables.size();++i;}return nullptr;} // 删除bool Erase(const K& key){auto* ptr = Find(key);if (ptr){ptr->_status = DELETE;--_n;return true;}else{return false;}}4.key不是整数如何处理呢？
1.通过仿函数
template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:HashTable():_tables(__stl_next_prime(1)),_n(0){};//......
};2.对于像string这样是不能直接强转为整形的，可以自己实现一个仿函数，也可以实现一个函数模板的特化
// 仿函数
struct StringHashFunc
{// BKDRsize_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash += ch;hash *= 131;}return hash;}
};// 函数特化
template<>
struct HashFunc<string>
{// BKDRsize_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash += ch;hash *= 131;}return hash;}
};
5.所有代码
#pragma once#include<vector>enum status
{EXIST,EMPTY,DELETE
};template<class K, class V>
struct HashData
{pair<K, V> _kv;status _status = EMPTY;
};template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:HashTable():_tables(__stl_next_prime(1)),_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;}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]._status != EMPTY){if (_tables[hashi]._status == EXIST&& _tables[hashi]._kv.first == key)return &_tables[hashi];hashi = (hash0 + i) % _tables.size();++i;}return nullptr;}bool Erase(const K& key){auto* ptr = Find(key);if (ptr){ptr->_status = DELETE;--_n;return true;}else{return false;}}bool Insert(const pair<K, V>& kv){if (Find(kv.first))return false;// 负载因子 >= 0.7 就扩容if ((double)_n / _tables.size() >= 0.7){// 方法一：//std::vector<HashData<K, V>> newtables(_tables.size()*2);//// 遍历旧表将所有值映射到新表//for (auto& data : _tables)//{// if (data._status == EXIST)// {// //...// }//}//_tables.swap(newtables);// 方法二：HashTable<K, V> newHT;newHT._tables.resize(__stl_next_prime(_tables.size() + 1));// 遍历旧表将所有值映射到新表for (auto& data : _tables){if (data._status == EXIST){newHT.Insert(data._kv);}}_tables.swap(newHT._tables);}Hash hs;size_t hash0 = hs(kv.first) % _tables.size();size_t hashi = hash0;size_t i = 1;//线性探测while (_tables[hashi]._status == EXIST){hashi = (hash0 + i) % _tables.size();i++;}_tables[hashi]._kv = kv;_tables[hashi]._status = EXIST;++_n;return true;}
private:std::vector<HashData<K, V>> _tables;size_t _n = 0;
};八、链地址法代码实现
1.框架
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(11, nullptr), _n(0);{ }
//......private://vector<list<pair<K, V>>> _tables;vector<Node*> _tables;size_t _n = 0; // 实际存储的数据个数
};2.插入
开放定址法负载因子必须小于1，链地址法的负载因子就没有限制了，可以大于1。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低；
stl中 unordered_xxx的最大负载因子基本控制在1，大于1就扩容，下面实现也使用这个方式。 极端场景：如果极端场景下，某个桶特别长怎么办？其实我们可以考虑使用全域散列法，这样就不容易被针对了。
但是假设不是被针对了，用了全域散列法，但是偶然情况下，某个桶很长，查找效率很低怎么办？这里在Java8的HashMap中当桶的长度超过一定阀值(8)时就把链表转换成红黑树。一般情况下， 不断扩容，单个桶很长的场景还是比较少的，下面实现就不搞这么复杂了，这个解决极端场景的思路。
这里插入实现的是头插：
bool Insert(const pair<K, V>& kv){if (Find(kv.first))return false;Hash hs;// 负载因子==1扩容size_t hashi = hs(kv.first) % _tables.size();// 头插Node* newNode = new Node(kv);newNode->_next = _tables[hashi];_tables[hashi] = newNode;++_n;return true;}带上扩容：
遍历旧表将所有值映射到新表，可以创建一个newHS，但是需要重新创建节点，稀释节点，这样搞的话消耗太大了。所以，这里创建一个新的tables，（链地址法的插入比较快）可以重新插入表中，最后交换tables即可。
bool Insert(const pair<K, V>& kv){// 负载因子==1扩容if (_n == _tables.size()){//HashTable<K, V> newHT;//newHT._tables.resize(_tables.size()*2);//// 遍历旧表将所有值映射到新表//for (auto cur : _tables)//{// while (cur)// {// newHT.Insert(cur->_kv);// cur = cur->_next;// }//}//_tables.swap(newHT._tables);vector<Node*> newtables(_tables.size() * 2);for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];// 当前桶的节点重新映射挂到新表while (cur){Node* next = cur->_next;// 插入到新表size_t hashi = cur->_kv.first % newtables.size();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;}3.查找
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;}4.删除
和单链表删除节点的逻辑一样，注意vector里面是第一个节点的地址，单独处理一下即可。
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;return true;}prev = cur;cur = cur->_next;}return false;
}5.key不是整数如何处理
和上面开放定值法一样，看最后的所有代码
6.所有代码
#pragma once
#include<vector>
#include <string>template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};
template<>
struct HashFunc<string>
{// BKDRsize_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash += ch;hash *= 131;}return hash;}
};
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;
}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;
public:HashTable():_tables(__stl_next_prime(1), nullptr), _n(0){ }bool Insert(const pair<K, V>& kv){if (Find(kv.first))return false;Hash hs;// 负载因子==1扩容if (_n == _tables.size()){//HashTable<K, V> newHT;//newHT._tables.resize(_tables.size()*2);//// 遍历旧表将所有值映射到新表//for (auto cur : _tables)//{// while (cur)// {// newHT.Insert(cur->_kv);// cur = cur->_next;// }//}//_tables.swap(newHT._tables);vector<Node*> newtables(__stl_next_prime(_tables.size() + 1));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);}size_t hashi = hs(kv.first) % _tables.size();// 头插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;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> ht;int a[] = { 19,30,5,36,13,20,21,12,24,96 };for (auto e : a){ht.Insert({ e, e });}ht.Erase(30);ht.Erase(19);ht.Erase(96);for (size_t i = 100; i < 200; i++){ht.Insert({ i, i });}
}void TestHT2()
{HashTable<string, string> dict;dict.Insert({ "insert", "插入" });auto ptr = dict.Find("insert");if (ptr){cout << ptr->_kv.second << endl;}
}九、附：set和unordered_set对比
int test()
{const size_t N = 1000000;unordered_set<int> us;set<int> s;vector<int> v;v.reserve(N);srand(time(0));for (size_t i = 0; i < N; ++i){//v.push_back(rand()); // N比较大时，重复值比较多v.push_back(rand() + i); // 重复值相对少//v.push_back(i); // 没有重复，有序}size_t begin1 = clock();for (auto e : v){s.insert(e);}size_t end1 = clock();cout << "set insert:" << end1 - begin1 << endl;size_t begin2 = clock();us.reserve(N);for (auto e : v){us.insert(e);}size_t end2 = clock();cout << "unordered_set insert:" << end2 - begin2 << endl;int m1 = 0;size_t begin3 = clock();for (auto e : v){auto ret = s.find(e);if (ret != s.end()){++m1;}}size_t end3 = clock();cout << "set find:" << end3 - begin3 << "->" << m1 << endl;int m2 = 0;size_t begin4 = clock();for (auto e : v){auto ret = us.find(e);if (ret != us.end()){++m2;}}size_t end4 = clock();cout << "unorered_set find:" << end4 - begin4 << "->" << m2 << endl;cout << "插入数据个数：" << s.size() << endl;cout << "插入数据个数：" << us.size() << endl << endl;size_t begin5 = clock();for (auto e : v){s.erase(e);}size_t end5 = clock();cout << "set erase:" << end5 - begin5 << endl;size_t begin6 = clock();for (auto e : v){us.erase(e);}size_t end6 = clock();cout << "unordered_set erase:" << end6 - begin6 << endl << endl;return 0;
}