1. unordered系列关联式容器

        在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好 的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是 其底层结构不同，本文中只对unordered_map和unordered_set进行介绍， unordered_multimap和unordered_multiset学生可查看文档介绍

⭐小结：之前学的 map 和 set 底层是 红黑树，查找效率 O(logN)， 下面即将学的 unordered_map和unordered_set 底层是 哈希，查找效率 O(1)

1.1 unordered_map

1.1.1 unordered_map的文档介绍

unordered_map在线文档说明

1. unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与 其对应的value。

2. 在unordered_map中，键值通常用于唯一地标识元素，而映射值是一个对象，其内容与此 键关联。键和映射值的类型可能不同。

3. 在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内 找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。

4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。

5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问 value。

6. 它的迭代器至少是前向迭代器

⭐小结：unordered_map 没有排序，查询元素效率 O(1)，遍历元素效率较低

1.2 unordered_set

这个没有什么特别的地方，如有需要自行查询文档，进一步了解

参见 unordered_set在线文档说明

---

2. 底层结构

unordered 系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。

2.1 哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素 时，必须要经过关键码的多次比较。顺序查找时间复杂度为 O(N)，平衡树中为树的高度，即 O(logN)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立 一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

• 插入元素

根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

• 搜索元素

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置 取元素比较，若关键码相等，则搜索成功

⭐小结：通过 哈希函数 将数据的 key 值计算成某一数值，作为存储在哈希表中的位置，以确定插入位置；同理，通过哈希函数，计算出目标元素所在位置，以搜索元素

⭐该方式即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表（Hash Table）（或者称散列表）

例如：数据集合{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % capacity; capacity 为存储元素底层空间总的大小。

通过哈希函数，将数据变成另一个值，该值即为存储位置下标

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快（因为搜索元素也是直接通过哈希函数计算 数据的存储位置下标直接可以取到 数据）

问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

会产生 哈希冲突

2.2 哈希冲突

概念：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突 或哈希碰撞

⭐即：数据 23，33 通过哈希函数 hash(key) = key % capacity（capacity==10）算出来的下标都是 3，因此两个数据会抢同一个位置

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

发生哈希冲突该如何处理呢？

2.3 哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。

2.3.1 哈希函数设计原则：

1、哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值 域必须在0到m-1之间

2、哈希函数计算出来的地址能均匀分布在整个空间中

3、哈希函数应该比较简单

2.3.2 常见哈希函数

⭐1. 直接定址法--(常用)

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B

优点：简单、均匀

缺点：需要事先知道关键字的分布情况

使用场景：适合查找比较小且连续的情况

⭐2. 除留余数法--(常用)

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数， 按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

意思是：数据的 key 值 除于 哈希表的 size，得出来的即为 下标

3. 平方取中法--(了解)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址

平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

4. 折叠法--(了解)

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这 几部分叠加求和，并按散列表表长，取后几位作为散列地址。 折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

5. 随机数法--(了解)

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中 random为随机数函数。

通常应用于关键字长度不等时采用此法

⭐注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

2.4 除留余数法的缺陷解决

哈希函数采用 除留余数法，被模的 key 必须要为整形才可以进行，非整形数据必须想方法转换成整型或创造一个整型数据

都写成仿函数

（1）非 size_t 的内置类型

如果是非 size_t 的内置类型，可以直接强制类型转换

template<class K>
class HashFunc
{
public:size_t operator()(const K& key) {return (size_t)key;   // 强转后返回}
};

（2）string 类型

如果是 string 字符串类型，无法强转类型

将字符串的每个字符的 ASCLII 码值相加起来，但这样还是不可完全避免冲突

如 abc 和 cba 的 ASCII码值总和是相等的，则 n 相等，取模之后也就冲突

缓解冲突的一个方法：每一个字符都相乘一个 31（使最后的总数不同）

因为 string 的类型特殊，我们直接 特化模板

// 针对 string 特化一个 哈希函数：特化模板也算作 HashFunc模板，则使用string时，不用显式传仿函数参数，因为默认 HashFunc<K>template<>
class HashFunc<string>
{
public:size_t operator()(const string& s) {size_t n = 0;for (auto& ch : s) {n += ch;  // 将字符串的每个字符的ASCLII码值相加起来n *= 31;    // 每一个字符都相乘一个 31}return n;}
};

（3）自定义的类型

如果是自定义的类型，也无法强转

如果 key 是一个自定义类型，就需要你自己写一个仿函数，且使自定义类型具有唯一标识性，如key == 一个人名，可以转换成：人名+岁数+生日日期+... 使该数值唯一性提高
 

2.5 哈希冲突解决

解决哈希冲突两种常见的方法是：闭散列和开散列

闭散列：开放定址法（位置被占了，寻找下一个位置）

        寻找方法：线性探测  /  二次探测

开散列：哈希桶 / 拉链法

2.5.1 闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有 空位置，那么可以把 key 存放到冲突位置中的 “ 下一个” 空位置中去。

那如何寻找下一个空位置 呢？

（1） 线性探测：插入元素

比如 现在需要插入元素 44，先通过哈希函数计算哈希地址，下标地址 为 4， 因此  44 理论上应该插在该位置，但是该位置已经放了值为 4 的元素，即发生哈希冲突。

线性探测：从发生冲突的位置开始，依次向后 + 1 探测，直到寻找到下一个空位置为止

---

（2）线性探测：删除 或 查找数据

        采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素 会影响其他元素的搜索。比如删除元素 5，如果直接删除掉，会使 44 查找起来可能会受影响。因为查找逻辑是：先通过哈希函数得出下标位置 4，该位置上为 元素 4，则继续向后寻找 44，遇到 空 停止（位置 5 为空），导致在此停下，而不会继续往后搜索；

因此线性探测采用标记的伪删除法来删除一个元素：将删除位置标记成 DELETE、空位置标记成 EMPTY

// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};

（3） 闭散列方法下，哈希表的 扩容时机

定义 负载因子！（也叫载荷因子）

考虑扩容：当 负载因子 大于等于 70% 时，哈希冲突会增加（科学研究），因此选择此时扩容

 

if (_n / _table.size() >= 0.7) _n 是填入表中的元素个数，_table.size() 是表的长度，相除得 载荷因子因为两个 size_t 相除的结果不会是浮点数，因此可以强转成 double，或者巧妙解决if (_n*10 / _tables.size() >= 7)

伪代码：具体代码在后面 【线性探测法具体代码】的 insert 函数中

// if (_n / _table.size() >= 0.7) 
if (_n * 10 / _tables.size() >= 7) {定义两倍空间大小的新哈希表：直接定义新对象循环遍历旧表，将旧表的每个元素重新映射到新表：newTable.Insert(旧表元素)直接将旧表和新表 swap 互换
}

线性探测优点：实现非常简单

线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同 关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。

如何缓解呢？

（4） 二次探测

线性探测是每次 +1、+2、+3.....， 二次探测是每次 +1^2 、+2^2 、+3^2 、..... i ^ 2

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法：大跨步往后走

2.5.2 开散列

（1）开散列概念

        开散列法又叫链地址法(拉链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

⭐小结：拉链法顾名思义，每一个数组元素位置都链接一个 单链表，每一个经过哈希函数转化后位置相同的数据，可以直接链接在 单链表上，这样就避免了像 闭散列 那样数据拥堵往后挤的现象

如元素 4 和 元素44 本来会 “抢”一个位置，导致冲突，而拉链法是两者得以 “共享” 同一位置

---

（2）拉链法：扩容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希 表进行增容，那该条件怎么确认呢？

开散列最好的情况是：每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容， 即载荷因子 == 1。

⭐伪代码：

// 考虑扩容：当负载比率为 1 时，扩容（即 n == size）
// 甚至可以大于 1，即理想情况下，就是平均每个桶有 1个以上 
if (_n == _table.size()) {创建两倍旧表 size 的新表对象遍历旧表，将每个有效的链表节点，重新映射到 新表（直接将旧表节点 移接到新表，而不是 Insert新值）交换旧表和新表
}

（注意：这里要直接将旧表节点直接摘下来，移位到新表，而不是将节点数据直接 Insert 进新表，直接 Insert进新表需要重新 new 和 delete 新节点，多少影响效率）

2.5.3  开散列与闭散列比较

闭散列应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。

事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。

3. 【实现哈希结构】开放定址法：线性探测法+除留余数法

namespace open_address
{enum State {EXIST,EMPTY,DELETE};// 定义数据信息：数值+状态template<class K, class V>struct HashData{pair<K, V>_data;State _state = EMPTY; // 一个节点默认为空状态};// 哈希函数：为了将 key 值转换为整型，适配除留余数法template<class K>class HashFunc{public:size_t operator()(const K& key){return (size_t)key;}};// 哈希函数特化：针对 string 特化一个 哈希函数template<>class HashFunc<string>{public:size_t operator()(const string& s) {size_t n = 0;for (auto& ch : s) {n += ch;  // 将字符串的每个字符的ASCLII码值相加起来，但这样还是不可完全避免冲突，如 abc 和 cba 的 ASCII码值总和是相等的，则 n 相等，取模之后也就冲突// 缓解冲突的一个方法：每一个字符都相乘一个 31n *= 31;}return n;}};// 哈希表：接收数据类型和哈希函数 Hashtemplate<class K, class V, class Hash = HashFunc<K>>class HashTable{public:// 先开 10 个元素空间HashTable() {_tables.resize(10);  // 使用 resize 是为了尽量将 size 和 capacity 保持一致}bool Insert(const pair<K, V>& data) {// 考虑冗余if (Find(data.first)) {cout << "该节点已存在" << '\n';return false;}// 考虑扩容：当负载因子个数在表中占比大于等于 70% 时，哈希冲突会增加，因此选择此时扩容// if (_n / _table.size() >= 0.7) if (_n*10 / _tables.size() >= 7) {// 扩容：因为将旧数据重新映射，就是重新执行插入操作，需要再次写一遍 插入操作逻辑，比较重复，因此我们下面直接使用 复用思想：直接定义新对象（编译器底层重开新模板）// 思路：//vector<HashData> newTable(_table.size() * 2);将旧表数据重新映射到新表：因为 size 变了，映射关系也变了//_table.swap(newTable);HashTable<K, V> newTable;newTable._tables.resize(_tables.size() * 2);for (size_t i = 0; i < _tables.size(); ++i) {if (_tables[i]._state == EXIST) {newTable.Insert(_tables[i]._data);    // 将旧表数据 insert 插入新表}}_tables.swap(newTable._tables);}// 找一个空位置size_t hashi = hash(data.first) % _tables.size();   //  除留余数法计数数据存储位置while (_tables[hashi]._state == EXIST) {hashi++;  // 线性探测：找下一个位置hashi %= _tables.size();  // 限制在一个范围内}// 插入_tables[hashi]._data = data;_tables[hashi]._state = EXIST;_n++;return true;}HashData<K, V>* Find(const K& key) {// 看有没有元素的 _data.first == keysize_t hashi = hash(key) % _tables.size();   // 除留余数法while (_tables[hashi]._state != EMPTY) {if (_tables[hashi]._state != DELETE && _tables[hashi]._data.first == key) {return &(_tables[hashi]);}hashi++;hashi %= _tables.size();}return nullptr;}bool Erase(const K& key) {HashData<K, V>* p = Find(key);if (p == nullptr) {cout << "该节点不存在" << '\n';return false;}else {p->_state = DELETE;   // 删除一个元素：直接将该元素的状态设置成 DELETE，不用抹除数值都可以return true;}}private:vector<HashData<K, V>>_tables;size_t _n = 0; // 负载因子中的：元素个数// 先创建一个哈希函数类对象：可以通用Hash hash;};// 测试整体void Test_open1() {HashTable<int, int> ht;int a[] = { 11,21,4,14,24,15,9 };for (auto e : a){ht.Insert({ e,e });}ht.Insert({ 19,19 });/*	ht.Insert({ 19,190 });ht.Insert({ 19,1900 });*/ht.Insert({ 39,1900 });cout << ht.Find(24) << endl;ht.Erase(4);cout << ht.Find(24) << endl;cout << ht.Find(4) << endl;}// 测试 string void Test_open2(){HashTable<string, string> ht;ht.Insert({ "sort", "排序" });ht.Insert({ "tros", "排序 的字母相反" });ht.Insert({ "left", "左边" });//string s1("sort");//string s2("sort");cout << HashFunc<string>()("bacd") << endl;cout << HashFunc<string>()("abcd") << endl;cout << HashFunc<string>()("aadd") << endl;}
}

4. 【实现哈希结构】开散列：拉链法

节点类 + 哈希函数类 + 哈希表类 + 两个测试函数

namespace hash_bucket
{template<class K, class V>struct HashNode {typedef HashNode<K, V> Node;pair<K, V> _kv;Node* _next;HashNode(const pair<K, V>& kv):_kv(kv), _next(nullptr){}};template<class K>class HashFunc{public:size_t operator()(const K& key) {return (size_t)key;}};template<>class HashFunc<string>{public:size_t operator()(const string& s) {size_t n = 0;for (auto& ch : s) {n += ch;  // 将字符串的每个字符的ASCLII码值相加起来，但这样还是不可完全避免冲突，如 abc 和 cba 的 ASCII码值总和是相等的，则 n 相等，取模之后也就冲突// 缓解冲突的一个方法：每一个字符都相乘一个 31n *= 31;}return n;}};template<class K, class V, class Hash = HashFunc<K>>class HashTable{typedef HashNode<K, V> Node;public:HashTable() {// 一开始vector里面是随机值，不是 nullptr!! 要自己初始化成 nullptr_table.resize(10, nullptr);}// 本哈希桶需要显式写析构：因为 Node* 是内置类型，只会默认析构成 nullptr，链表节点不会被处理~HashTable() {Node* cur = nullptr;Node* next = nullptr;for (size_t i = 0; i < _table.size(); ++i) {cur = _table[i];while (cur) {next = cur->_next;delete cur;cur = next;}}}Node* find(const K& key) {size_t hashi = hash(key) % _table.size(); // 除留余数法 定位// 定位哈希桶后，遍历这个桶中单链表Node* cur = _table[hashi];while (cur) {if (cur->_kv.first == key) return cur;cur = cur->_next;}return nullptr;}bool insert(const pair<K, V>& kv) {// 考虑冗余if (find(kv.first)) {cout << "该数据已存在" << '\n';return false;}// 考虑扩容：当负载比率为 1 时，扩容if (_n == _table.size()) {HashTable<K, V> newTable;newTable._table.resize(2 * _table.size());// 若直接遍历每个节点，取数值 kv insert 插入新表，会导致频繁的 new 节点，造成一定消耗// 我们可以直接将旧表的节点 直接转接到 新表，省去new节点的消耗for (size_t i = 0; i < _table.size(); ++i) {Node* cur = _table[i];// /*while (cur) {newTable.insert(cur->_kv);cur = cur->_next;}*/while (cur) {Node* Next = cur->_next; size_t hashi = hash(cur->_kv.first) % newTable._table.size();  // 除留余数法 重新定位桶的位置// 将节点转接到新哈希表cur->_next = newTable._table[hashi];    newTable._table[hashi] = cur;cur = Next;}_table[i] = nullptr;}_table.swap(newTable._table);}size_t hashi = hash(kv.first) % _table.size();// 链表头插和尾插都行：头插最方便，尾插还要找尾Node* newNode = new Node(kv);newNode->_next = _table[hashi];_table[hashi] = newNode;_n++;return true;}bool erase(const K& key) {if (find(key) == nullptr) {cout << "该节点不存在" << '\n';return false;}// 删除函数需要自己找目标节点，因为底层是单链表，没有prev，删除不好搞// 先除留余数法定位桶位置，再遍历链表，删除节点即可size_t hashi = hash(key) % _table.size();Node* cur = _table[hashi];Node* prev = nullptr;while (cur) {if (cur->_kv.first == key) {if (prev == nullptr) _table[hashi] = cur->_next;else prev->_next = cur->_next;delete cur;cur = nullptr;--_n;return true;}prev = cur;cur = cur->_next;}return false;}private://也可以使用 list：双向带头循环链表//vector<list<pair<K, V>>> _table;  vector<Node*> _table;size_t _n = 0; // 负载因子Hash hash;};void Test_hash_bucket1() {HashTable<int, int> ht;int a[] = { 11,21,4,14,24,15,9, 19, 22, 23, 25 };for (auto e : a){if (e == 23)int i = 0;ht.insert({ e,e });}// 删除全部for (auto& e : a) {if (e == 15)int i = 0;ht.erase(e);}}// 测试 stringvoid Test_hash_bucket2(){HashTable<string, string> ht;ht.insert({ "sort", "排序" });ht.insert({ "tros", "排序 的字母相反" });ht.insert({ "left", "左边" });//string s1("sort");//string s2("sort");cout << HashFunc<string>()("bacd") << endl;cout << HashFunc<string>()("abcd") << endl;cout << HashFunc<string>()("aadd") << endl;}
}