一、unordered 系列关联式容器
在 C++98 中，STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 O(logN)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到。
因此在 C++11 中，STL 又提供了 4 个 unordered 系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，下面只对 unordered_map 和 unordered_set 进行介绍，unordered_multimap 和 unordered_multiset 的具体内容可查看文档介绍。
- unordered 系列关联式容器，遍历出来不是有序的，迭代器是单向迭代器。
- unordered_map 和 unordered_set 不允许数据冗余，支持 [ ] 操作符。
- unordered_multimap 和 unordered_multiset 允许数据冗余，不支持 [ ] 操作符。
unordered 系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。 在一般情况下，建议使用 unordered 系列的关联式容器。
1、unordered_map
（1）unordered_map 的介绍
unordered_map - C++ Reference (cplusplus.com)
【翻译】
- unordered_map 是存储 键值对的关联式容器，其允许通过 key 快速的索引到与其对应的 value。
- 在 unordered_map 中，键值通常用于唯一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
- 在内部，unordered_map 没有对 按照任何特定的顺序排序, 为了能在 O(1) 内找到 key 所对应的 value，unordered_map 将相同哈希值的键值对放在相同的桶中。
- unordered_map 容器通过 key 访问单个元素要比 map 快，但它通常在遍历元素子集的范围迭代方面效率较低。
- unordered_map 实现了直接访问操作符（operator[ ]），它允许使用 key 作为参数直接访问 value。
- 它的迭代器至少是前向（单向）迭代器。
（2）unordered_map 的接口说明
a. 构造函数
cplusplus.com/reference/unordered_map/unordered_map/unordered_map/
b. 容量函数
c. 迭代器
d. 元素访问
cplusplus.com/reference/unordered_map/unordered_map/operator[]/
注意：该函数中实际调用哈希桶的插入操作，用参数 key 与 V() 构造一个默认值往底层哈希桶中插入，如果 key 不在哈希桶中，则插入成功，返回 V()；如果 key 在哈希桶中，那么插入失败，返回 key 对应的 value。
e. 查询操作
cplusplus.com/reference/unordered_map/unordered_map/find/
cplusplus.com/reference/unordered_map/unordered_map/count/
注意 ：unordered_map 中 key 是不能重复的，因此 count 函数的返回值最大为 1。
f. 修改操作
cplusplus.com/reference/unordered_map/unordered_map/insert/
cplusplus.com/reference/unordered_map/unordered_map/erase/
cplusplus.com/reference/unordered_map/unordered_map/clear/
cplusplus.com/reference/unordered_map/unordered_map/swap/
g. 桶操作
2、unordered_set
（1）unordered_set 的介绍
unordered_set - C++ Reference (cplusplus.com)
【翻译】
- unordered_set 是一种不按特定顺序存储唯一元素的容器，允许基于它们的 key 快速检索单个元素
- 在 unordered_set 中，元素的值与唯一标识它的 key 同时存在，key 是不可变的。unordered_set 中的元素不能在容器中修改（元素总是 const），但是可以从容器中插入或删除它们。
- 在内部，unordered_set 中的元素并不按照任何特定的顺序排序，而是根据它们的哈希值插入到相应的桶中，允许根据它们的值在 O(1) 范围内访问单个元素。
- unordered_set 容器通过 set 访问单个元素要比 map 快，但它通常在遍历元素子集的范围迭代方面效率较低。
- 它的迭代器至少是前向（单向）迭代器。
（2）unordered_set 的接口说明
a. 构造函数
cplusplus.com/reference/unordered_set/unordered_set/unordered_set/
b. 容量函数
c. 迭代器
d. 查询操作
cplusplus.com/reference/unordered_set/unordered_set/find/
cplusplus.com/reference/unordered_set/unordered_set/count/
注意 ：unordered_set 中 key 是不能重复的，因此 count 函数的返回值最大为 1。
e. 修改操作
cplusplus.com/reference/unordered_set/unordered_set/insert/
cplusplus.com/reference/unordered_set/unordered_set/erase/
cplusplus.com/reference/unordered_set/unordered_set/clear/
cplusplus.com/reference/unordered_set/unordered_set/swap/
f. 桶操作
二、底层结构
unordered 系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。
1、哈希概念
顺序结构以及二叉平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为 O(N)， 二叉平衡树中查找时间复杂度为树的高度 O(log₂ N) ，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数（hashFunc）使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。方便我们搜索。
【插入元素】
- 根据待插入元素的关键码，用哈希函数计算出该元素的存储位置并按此位置进行存放。
【搜索元素】
- 对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。
该方式即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称 为哈希表（Hash Table / 散列表）。
例如：数据集合 {1，7，6，4，5，9}。
哈希函数设置为：hash(key) = key % capacity; capacity 为存储元素底层空间总的大小。
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。
2、哈希冲突
对于两个数据元素的关键字 ki 和 kj (i != j)，有 ki != kj，但有：Hash(ki) == Hash(kj)
即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为 哈希冲突 或 哈希碰撞 。把具有不同关键码而具有相同哈希地址的数据元素称为 “同义词”。
3、哈希函数
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。
哈希函数设计原则：
- 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有 n 个地址时，其值域必须在 0 到 n-1 之间。
- 哈希函数计算出来的地址能均匀分布在整个空间中。
- 哈希函数应该比较简单。
【常见哈希函数】
1、直接定址法（常用）
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
- 优点：简单、均匀。
- 缺点：需要事先知道关键字的分布情况。
- 使用场景：适合查找比较小且连续的情况。
比如：
- 计数排序。
- 一些 OJ 题中用哈希映射来统计字符出现次数。
- 利用字符的 ASCII 码值来映射字符，利用 int 型变量的数值来映射该变量。
2、除留余数法（常用）
开一段固定大小的空间，比如哈希表中允许的地址数为 n，按照 哈希函数： Hash(key) = key % n，得到的余数就是该关键码的哈希地址，存放到哈希表对应位置中。
缺陷：
- 适用于整数的存储（字符串、浮点数不能直接存储，因为不能直接取模）。
- 余数相同时，会出现哈希冲突。
3、平方取中法（了解）
假设关键字为 1234，对它平方就是 1522756，抽取中间的 3 位 227 作为哈希地址；
再比如关键字为 4321，对它平方就是 18671041，抽取中间的 3 位 671（或 710）作为哈希地址。
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况。
4、折叠法（了解）
折叠法是将关键字从左到右分割成位数相等的几部分（最后一部分位数可以短些），然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
- 折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况。
5、随机数法（了解）
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即 H(key) = random(key)，其中 random 为随机数函数。
- 通常应用于关键字长度不等时采用此法。
6、数学分析法（了解）
设有 n 个 d 位数，每一位可能有 r 种不同的符号，这 r 种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：
假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前 7 位都是相同 的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转（如 1234 改成 4321）、右环位移（如 1234 改成 4123）、左环移位、前两数与后两数叠加（如 1234 改成 12+34=46）等方法。
- 数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。
注意 ：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。
4、哈希冲突解决
解决哈希冲突两种常见的方法是：闭散列和开散列。
三、解决哈希冲突两种常见方法的介绍
1、闭散列
闭散列 ：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把 key 存放到冲突位置中的 “下一个” 空位置中去。
【核心思想】
通过哈希函数计算出这个数据对应的哈希位置，如果该位置出现了哈希冲突，我们就重新探测一个空闲位置，将其插入。
那如何重新探测新的位置呢？
当我们往散列表中插入数据时，如果某个数据经过散列函数散列之后，存储位置已经被占用了，我们就从当前位置开始，依次往后查找，看是否有空闲位置，直到找到为止。如果数组整个都没有空位置，这个时候就需要对数组进行扩容操作。
而我们要获取数据的时候就需要先 Hash 运算，然后得到下标后再去拿值，拿到值后要比对是不是要拿的数据，因为有可能 Hash 冲突了，此时的值并不是你想要的，如果是就直接取出，不是的话就需要重新遍历数组，直到找到对应的数。
（1）找下一个空位置
当前哈希位置已经存放了数据，下一个元素也是映射的这个位置，发生哈希冲突了，该怎么办呢？
- 如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把该元素存放到冲突位置的 “下一个空位置” 中去。
- 如果整个数组都没有空位置了，这个时候就需要对数组进行扩容操作。
找下一个空位置有两种方法：线性探测和二次线性探测。
① 线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
【插入】
通过哈希函数获取待插入元素在哈希表中的位置。
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。
hash(44) = 44%10 = 4
出现哈希冲突：哈希地址 4 已经存放了数据，从冲突位置开始往后找空位置。
【删除】
采用 闭散列处理哈希冲突 时，不能随便物理删除哈希表中已有的元素，若直接删除元素 会影响其他元素的搜索。
比如删除元素 4，如果直接删除掉，44 查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
// 哈希表每个空间给个标记 // EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除 enum State{EMPTY, EXIST, DELETE};
【线性探测的实现】
// 注意：假如实现的哈希表中元素唯一，即key相同的元素不再进行插入 // 为了实现简单，此哈希表中我们将比较直接与元素绑定在一起 template<class K, class V> class HashTable { struct Elem { pair<K, V> _val; State _state; }; public: HashTable(size_t capacity = 3) : _ht(capacity), _size(0) { for(size_t i = 0; i < capacity; ++i) _ht[i]._state = EMPTY; } bool Insert(const pair<K, V>& val) { // 检测哈希表底层空间是否充足 // _CheckCapacity(); size_t hashAddr = HashFunc(key); // size_t startAddr = hashAddr; while(_ht[hashAddr]._state != EMPTY) { if(_ht[hashAddr]._state == EXIST && _ht[hashAddr]._val.first == key) return false; hashAddr++; if(hashAddr == _ht.capacity()) hashAddr = 0; /* // 转一圈也没有找到，注意：动态哈希表，该种情况可以不用考虑，哈希表中元素个数到达一定的数量，哈希冲突概率会增大，需要扩容来降低哈希冲突，因此哈希表中元素是不会存满的 if(hashAddr == startAddr) return false; */ } // 插入元素 _ht[hashAddr]._state = EXIST; _ht[hashAddr]._val = val; _size++; return true; } int Find(const K& key) { size_t hashAddr = HashFunc(key); while(_ht[hashAddr]._state != EMPTY) { if(_ht[hashAddr]._state == EXIST && _ht[hashAddr]._val.first == key) return hashAddr; hashAddr++; } return hashAddr; } bool Erase(const K& key) { int index = Find(key); if(-1 != index) { _ht[index]._state = DELETE; _size++; return true; } return false; } size_t Size()const; bool Empty() const; void Swap(HashTable<K, V, HF>& ht); private: size_t HashFunc(const K& key) { return key % _ht.capacity(); } private: vector<Elem> _ht; size_t _size; };
- 线性探测优点：实现非常简单。
- 线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。
如何缓解呢？
插入和查找的效率都会降低很多，插入元素时，从冲突位置开始不断往后找到下一个空位置；查找元素时，从冲突位置开始不断往后找，需要比较许多次，导致搜索效率降低。最坏情况下要直到找到空位置时，才能说明没有该元素。
② 二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hash(key) = key % n + i² ( i = 1,2,3… )。
通过哈希函数 Hash(key) 计算出元素的关键码 key 对应的位置再加上 i 的平方，n 是表的大小。
二次探测相比线性探测的好处：
如果一个位置有很多数据冲突，那么二次探测会让这些数据存储位置会比较分散，不会集中在一起，导致一片一片的冲突。
如果上面要插入 44，产生冲突，使用解决后的情况为：
研究表明：当表的长度为质数且表装载因子 a 不超过 0.5 时，新的表项一定能够插入，而且任 何一个位置都不会被探查两次。
因此只要表中有一半的空位置，就不会存在表满的问题。在 搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子 a 不超过 0.5，如果超出必须考虑增容。
因此：比散列最大的缺陷就是 空间利用率比较低 ，这也是哈希的缺陷。
【二次探测相比线性探测的好处】
如果一个位置有很多数据冲突，那么二次探测会让这些数据存储位置会比较分散，不会集中在一起，导致一片一片的冲突。
【插入】
如果要插入 333 和 33，产生冲突，分别使用线性探测和二次探测，解决后的情况为： 
【闭散列的实现】
哈希表就是数组，只不过是按照某种映射关系把元素存放进去的数组。
1、如何向哈希表中插入元素？
先检查哈希表是否需要扩容（表为空或表的负载因子超过某个值，则进行扩容）。
再通过哈希函数计算出待插入元素在哈希表中的位置：
- 如果该位置有元素（即存储状态为：EXIST），说明发生了哈希冲突，使用线性探测（或二次探测）找到下一个空位置，然后插入新元素；
- 如果该位置中没有元素（即存储状态为: EMPTY / DELETE），则直接插入新元素。
2、如何在哈希表中查找元素？
先检查哈希表是否为空：
- 若为空，查找失败，直接返回 nullptr，再通过哈希函数计算出要查找元素在哈希表中对应的位置。
- 如果该位置不为空（即存储状态为：EXIST / DELETE），开始往后查找，直到遇到空位置才停止（如果遇到空位置都还没查找到，说明哈希表中没有该元素），查找过程中，如果当前位置存储状态为存在，则判断是不是要查找的元素：
- 如果是，查找成功，返回该元素的地址；
- 如果不是，继续往后找。
如果该位置为空（即存储状态为：EMPTY），返回 nullptr。
3、如何表示哈希表中某个位置是否存放的有元素？
肯定不能用 0 / -1 来表示，万一需要存放的数据就有 0 / -1 呢？
哈希表中每个位置存储数据的同时，再存储一个状态标记，表示该位置的存储状态（空、存在、删除）
4、如何删除哈希表中某个位置的元素？
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。
如上图：直接删除掉了元素 333，那么元素 44 查找起来就会受影响（因为哈希位置 4 此时为空），导致查找不到，所以用线性探测采用标记的伪删除法来删除一个元素。哈希表中每个位置存储数据的同时，再存储一个状态标记，表示该位置的存储状态（空、存在、删除）
【思考1】因为哈希函数采用的是除留余数法，被模的 key 必须要为整型才可以处理，导致闭散列只能存储 key 为整型的元素，其他类型怎么解决？
如果 key 是 string 类型或其它自定义类型，不能直接取模来计算出它的位置，我们就传一个对应的仿函数，来将其转换成整型。
// 定义一个默认仿函数类（针对size_t类型和能够隐式类型转换成size_t的类型） template<class K> struct HashFunc { // key: 元素关键码 // 如果key是整数，转换成size_t，然后返回key // 如果key是浮点数，隐式类型转换成size_t，然后返回key size_t operator()(const K& key) { return key; } }; // 定义仿函数类（专门针对元素关键码是string类型的，将其转换成可以取模的size_t类型） struct HashFuncString { size_t operator()(const string& key) { // 方法一：每个字符的ASCII码值加起来 // 缺陷：不同字符串可能加出同样的结果，无法保证key的唯一性 size_t hash_key = 0; for (size_t i = 0; i < key.size(); i++) { hash_key += key[i]; } return hash_key; } };
【思考2】unordered 系列容器底层就是哈希表，但我们用的时候也并没有传仿函数。因为 string 类型作为元素关键码 key 很常见，我们也不可能每次都去写一个仿函数。那是如何做到的呢？
写一个针对 string 类型取模的特化版本仿函数。
// 默认仿函数类（针对size_t类型和能够隐式类型转换成size_t的类型） template<class K> struct HashFunc { size_t operator()(const K& key) { return key; } }; // 特化仿函数（把string类型转换成可以取模的size_t类型） template<> struct HashFunc<string> { size_t operator()(const string& key) { size_t hash_key = 0; for (size_t i = 0; i < key.size(); i++) { hash_key *= 131; hash_key += key[i]; } return hash_key; } };
【闭散列的结构（KV模型）】
// 闭散列 namespace close_hash { // 标记哈希表中某个位置的存储状态 enum Status { EMPTY, // 此位置空 EXIST, // 此位置已有元素 DELETE // 此位置元素已被删除 }; // 定义哈希表中元素的结构 template<class K, class V> struct HashData { pair<K, V> _kv; // 键值对 Status _status = EMPTY; // 存储状态标记，默认为空 }; // 仿函数（解决哈希函数采用除留余数法时，将不能取模的类型转换成可以取模的size_t类型） // 默认仿函数类 template<class K> struct HashFunc { // 针对size_t类型和能够隐式类型转换成size_t的类型 size_t operator()(const K& key) { return key; } }; // 特化仿函数 template<> struct HashFunc<string> { // 把string类型转换成可以取模的size_t类型 size_t operator()(const string& key) { size_t hash_key = 0; for (size_t i = 0; i < key.size(); i++) { hash_key *= 131; hash_key += key[i]; } return hash_key; } }; // 定义哈希表（KV模型） // Hash = HashFunc<K>：仿函数，给一个默认的仿函数 template<class K, class V, class Hash = HashFunc<K>> class HashTable { public: // 构造、拷贝构造、赋值重载、析构都不需要写，调用vector的就行了 HashData<K, V>* Find(const K& key); // 查找元素 bool Insert(const pair<K, V>& kv); // 插入元素 bool Erase(const K& key); // 删除元素 private: vector<HashData<K, V>> _tables; // 哈希表 size_t _n = 0; // 存储的有效元素个数，默认为0 // 注意：因为元素不是挨着挨着存的，所以需要一个变量去表示有效元素个数 }; }
【C++】哈希 Hash（闭散列、开散列介绍及其实现）（下）https://developer.aliyun.com/article/1515253?spm=a2c6h.13148508.setting.23.11104f0e63xoTy
