目录
一、unordered系列关联式容器
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到O(log_2 N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好 的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是 其底层结构不同。
二、unordered_map
1. unordered_map的文档介绍
- unordered_map是存储键值对的关联式容器，其允许通过key快速的索引到与其对应的value。
- 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
- 在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
- unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
- unordered_map实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问 value。
- 它的迭代器只有正向迭代器，没有反向迭代器。
2. unordered_map的接口说明
2.1 unordered_map的容量
2.2 unordered_map的迭代器
2.3 unordered_map的元素访问
注意：该函数中实际调用哈希桶的插入操作，用参数key与V()构造一个默认值往底层哈希桶 中插入，如果key不在哈希桶中，插入成功，返回V()，插入失败，说明key已经在哈希桶中， 将key对应的value返回。
2.4 unordered_map的查询
注意：unordered_map中key是不能重复的，因此count函数的返回值最大为1
2.5 unordered_map的修改操作
2.6 unordered_map的桶操作
这里set和unordered_set的接口也都差不多，详细文档可查看：unordered_set - C++ Reference (cplusplus.com)
set - C++ Reference (cplusplus.com)
unordered_map - C++ Reference (cplusplus.com)
map - C++ Reference (cplusplus.com)
三、 底层结构
unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。
1. 哈希概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素 时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即 O(log_2 N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立 一 一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
- 插入元素 ：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
- 搜索元素 ：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
将key%上capacity 得到的就是映射到数组位置的下标，然后将key存到该下标处。
2. 哈希冲突
不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。那么哈希冲突怎么解决呢？
解决哈希冲突两种常见的方法是：闭散列和开散列
3. 哈希函数
哈希函数设计原则：
- 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
- 哈希函数计算出来的地址能均匀分布在整个空间中
- 哈希函数应该比较简单
4.常见哈希函数
1. 直接定址法--(常用)
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况
2. 除留余数法--(常用)
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，
按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址
3. 平方取中法
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；
再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
4. 折叠法
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这
几部分叠加求和，并按散列表表长，取后几位作为散列地址。
5. 随机数法
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中
random为随机数函数。
通常应用于关键字长度不等时采用此法
6. 数学分析法
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定
相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只
有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散
列地址。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的
若干位分布较均匀的情况
注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突
5. 闭散列
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置
呢？
5.1 线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
5.2 结构
enum State// 三种状态
{
EMPTY,//空
EXIST,//存在
DELETE,//删除
};
template<class K, class V>
struct HashData
{
pair<K, V> _data;
State state = EMPTY;
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
typedef HashData<K, V> Data;
public:
HashTable()
:_n(0)
{ //提前开好空间，避免第一次插入的地方计算负载因子时报错
_tables.resize(10);
}
private:
vector<Data> _tables;
int _n;
};5.3 插入
还是以K,V结构为例，先不考虑扩容和存不存在的问题，先求出要映射的下标，那么这个key值它可能是整形，也有可能不是整形，整形的话可以直接取模，不是整形的话怎么办呢？这时候仿函数就派上用场了，把其他类型用仿函数去转化成整形，然后再取模，求出下标。这里我为什么要% size呢？那是因为后面要实现[ ]，而[ ]的判断是下标位置是否小于size，这是如果%的是capacity，那么下标如果不在size里，用[ ]时就会报错。
扩容的话这里用负载因子去判断，负载因子当然越小越好。负载因子过大导致插入时会一直向后寻找位置，导致效率变低，所以这里扩容后重新插入，会更改原来的映射关系，把数据分散开来。
bool insert(const pair<K, V>& data)
{ //如果key存在就不插入
if (Find(data.first))
{
return false;
}
//负载因子大于0.7就扩容，浮点数不好比较就直接乘10，按整形比
if (_n * 10 / _tables.size() > 7)
{
HashTable newHT;
newHT._tables.resize(_tables.size() * 2);
for (auto& e : _tables)//开一个二倍size的哈希表，把旧表数据插入新表，
{
if (e.state == EXIST)
{
newHT.insert(e._data);
}
}
_tables.swap(newHT._tables);
}
Hash hf;//仿函数
//求映射下标，如果是其他类型用仿函数转化为整形取模
size_t hashi = hf(data.first) % _tables.size();
while (_tables[hashi].state == EXIST)
{
++hashi;
hashi %= _tables.size();
}
_tables[hashi]._data = data;
_tables[hashi].state = EXIST;
++_n;
return true;
}5.4 查找
查找这里跟插入很相似，都是找下标，而后找数据存不存在。因为删除的缘故，这里要加一个判断状态是否为存在，只有存在该数据才可以被找到。因为删除这里只是修改状态，如果不设置这个条件，可能会出现数据已经被删除了而又被找到的情况。而返回值是Data* 是因为查找后可以直接进行修改，很方便。
Data* Find(const K& key)
{
Hash hf;
size_t hashi = hf(key) % _tables.size();//求下标
size_t start = hashi;
while (_tables[hashi].state != EMPTY)
{ //下标位置的数据状态要为存在才可以被找到
if (_tables[hashi].state == EXIST && _tables[hashi]._data.first == key)
{
return &_tables[hashi];
}
++hashi;
hashi %= _tables.size();
//极端场景下，表里的状态没有空，全是存在和删除，如果不写这个可能导致死循环
if(start == hashi)
break;
}
return nullptr;
}5.5 删除
删除很简单，就是通过查找，获取该数据的地址，把状态改为删除即可，
bool erase(const K& key)
{
Data* ret = Find(key);
if (ret)
{
ret->state = DELETE;
_n--;
return true;
}
else
{
return false;
}
}5.6 仿函数
template<class K>
struct HashFunc
{ //将key转化为整形
size_t operator()(const K& key)
{
return (size_t)key;
}
};
template<>//模板特化
struct HashFunc<string>
{ //将字符串转化为整形，
//BKDR算法
size_t operator()(const string& key)
{
size_t num = 0;
for (auto& ch : key)
{
num *= 131;//减少冲突概率
num += ch;
}
return num;
}
};线性探测优点：实现非常简单，
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同
关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降
低。
https://gitee.com/auspicious-jing/job-library/blob/master/HashTable/HashTable/HashTable(%E9%97%AD).h二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置的方法有关(逐个往后去找)。
因此二次探测为了避免该问题，找下一个空位置的方法为: H_i = (H_0 + i ^ 2) % m, 或者: H_i = (H_0 - i ^ 2) % m。其中: i = 0,1,2,3……H_0是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。
研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任
何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在
搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出
必须考虑增容。
闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。
6. 开散列(哈希桶)
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地
址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链
接起来，各链表的头结点存储在哈希表中。
6.1结构
开散列结构用一个数组存放映射位置，把每个映射位置看成一个桶，用单链表把映射位置相同的元素“挂起来”。开散列的仿函数和闭散列的一样，我就不写了。
//单链表节点
template<class T>
struct HashBucketNode
{
HashBucketNode(const T& data)
:_data(data)
,_next(nullptr)
{}
T _data;
HashBucketNode<T>* _next;
};
template<class K,class T,class Hash = HashFunc<K>>
class HashBucket
{
typedef HashBucketNode<T> Data;
public:
HashBucket()
:_n(0)
{
_tables.resize(10);
}
private:
vector<Data*> _tables;
size_t _n;//哈希表里存储元素的个数
};6.2 插入
不考虑相同元素和扩容问题，插入十分简单，先将元素通过仿函数转化成整形，求出它的映射位置，用该元素创建一个新的单链表节点，用头插的方式插入这个映射位置(尾插效率低)。
相同元素的处理可以等查找实现了再来处理，本质就是查找该元素是否在表里，如果存在就返回该节点，不存在就继续插入。
扩容这里跟闭散列不一样，闭散列的负载因子不能过大，过大会影响效率，而开散列这里，最好的情况就是每个映射位置下面都只有一个元素，也就是说负载因子等于1就可以扩容了(负载因子过小，浪费空间，过大，效率变差，标准也规定了负载因子要为1)。
创建一个是旧数组二倍大小的新数组，再将旧数组的链表一个一个取过来，重新定义映射位置插入新数组，每把旧数组的一个映射位置的链表取完，就将该映射位置置空。全部取完后，旧数组里就没有链表了，就是一个光秃秃的数组，再将新旧数组一交换(还是找个打工人)，扩容就完成了。
ps：这里取旧数组的链表，一是因为旧数组析构时，链表并不会被析构，会造成内存泄漏；二是旧数组反正也要被析构，他的东西我直接拿过来用，还能减少重新插入的时间消耗，节省效率；需要注意的是取旧数组的链表，不能直接一把把桶里的链表原模原样的放到新数组里，因为扩容后映射关系会变，所以要注意！
Data* Insert(const T& data)
{
Data* node = Find(data);
if (node)
return node;
//扩容
if (_tables.size() == _n)
{
vector<Data*> newHT;
newHT.resize(_tables.size() * 2);
for (size_t i = 0; i < _tables.size(); ++i)
{
Data* cur = _tables[i];
while (cur)
{
Data* next = cur->_next;
size_t hashi = Hash()(cur->_data) % newHT.size();
cur->_next = newHT[hashi];
newHT[hashi] = cur;
cur = next;
}
_tables[i] = nullptr;
}
_tables.swap(newHT);
}
//插入
size_t hashi = Hash()(data) % _tables.size();
Data* newNode = new Data(data);
newNode->_next = _tables[hashi];
_tables[hashi] = newNode;
++_n;
return newNode;
}6.3 删除
删除某个值，就是删除映射位置下单链表的节点，单链表我们也知道，只有一个节点是无法做到删除的，所以要加一个前置指针，指向该链表的前一个节点，此时在遍历单链表找要删除的位置，找到后就让前一个节点的next指针指向当前节点的下一个节点，最后删除掉当前节点，删除完成返回真，如果找不到就返回假。
bool Erase(const K& key)
{
size_t hashi = Hash()(key) % _tables.size();
Data* cur = _tables[hashi];
Data* prev = nullptr;
while (cur)
{
if (cur->_data == key)
{
//删除
if (cur == _tables[hashi])
{
_tables[hashi] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
delete cur;
return true;
}
else
{
prev = cur;
cur = cur->_next;
}
}
return false;
}6.4 查找
查找很简单，就是先找映射位置，再找映射位置里的与要查找的值相同的那个节点，找到后返回当前节点即可，如果找不到就返回空，证明表里没有这个值。
Data* Find(const K& key)
{
size_t hashi = Hash()(key) % _tables.size();
Data* cur = _tables[hashi];
while (cur)
{
if (cur->_data == key)
{
return cur;
}
cur = cur->_next;
}
return nullptr;
}7. 开散列与闭散列比较
应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <=0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。
四、 哈希表的改造
1. 迭代器
这里为了方便，定义了一个哈希表成员，在++的地方会用到。那么构造这里就要将两个成员都初始化。
因为哈希表的结构特殊，是单链表，所以迭代器只有正向没有反向，也就是说没有--。++的实现也不难，迭代器遍历本质就是把表内所有的单链表都走一遍，如果下一个节点不为空，就走向下一个节点；如果下一个节点为空，那么就找下一个不为空的桶，我们只知道节点，不知道映射位置怎么找呀？简单，通过当前节点的值就可以找到当前的映射位置，这样再找下一个不为空的桶就很简单了，需要注意的是，如果所有桶都遍历完了，证明走到end了，和之前红黑树一样，end为空，证明迭代器结束了。
//前置声明
template<class K, class T, class Hash, class KeyOfT>
class HashBucket;
template<class K, class T, class Hash, class KeyOfT>
struct _IteratorHash
{
typedef HashBucketNode<T> Data;
typedef _IteratorHash<K, T, Hash, KeyOfT> Self;
//为了实现简单，在哈希桶的迭代器类中需要用到hashBucket本身
typedef HashBucket<K, T, Hash, KeyOfT> HT;
_IteratorHash(Data* node,HT* ht)
:_node(node)
,_ht(ht)
{}
T& operator*()
{
return _node->_data;
}
T* operator->()
{
return &_node->_data;
}
Self& operator++()
{ //如果桶内还有节点，那就取他的下一个节点
if (_node->_next)
{
_node = _node->_next;
}
else
{
Hash hs;
KeyOfT kot;
size_t hashi = hs(kot(_node->_data)) % _ht->_tables.size();//找当前桶的映射位置
while (++hashi < _ht->_tables.size()) //找到下一个不为空的桶
{
if (_ht->_tables[hashi])
{
_node = _ht->_tables[hashi];
break;
}
}
if (hashi == _ht->_tables.size()) //数组已经走完了，都遍历一遍了
_node = nullptr;
}
return *this;
}
//后置
//Self operator++(int)
//{
// Self ret = *this;
// if (_node->_next)
// {
// _node = _node->_next;
// }
// else
// {
// Hash hs;
// KeyOfT kot;
// size_t hashi = hs(kot(_node->_data)) % _ht->_tables.size();
// while (++hashi < _ht->_tables.size())
// {
// if (_ht->_tables[hashi])
// {
// _node = _ht->_tables[hashi];
// break;
// }
// }
// if (hashi == _ht->_tables.size())
// _node = nullptr;
// }
// return ret;
//}
bool operator!=(const Self& s)const
{
return _node != s._node;
}
bool operator==(const Self& s)const
{
return _node == s._node;
}
HT* _ht;
Data* _node;
};begin：找第一个不为空的桶，桶的最上面就是第一个节点，
end：end为空，走到空，证明遍历节点完毕
template<class K, class T,class Ref,class Ptr, class Hash, class KeyOfT>
friend struct _IteratorHash; //友元
public:
typedef _IteratorHash<K, T, Hash, KeyOfT> iterator;
iterator begin()
{
for (size_t i = 0; i < _tables.size(); ++i)
{ //找第一个不为空的桶
if (_tables[i])
return iterator(_tables[i], this);
}
return iterator(nullptr, this);
}
iterator end()
{
return iterator(nullptr, this);
}2. 封装unordered_map
这里还是封装几个的接口，让我们可以简单的使用。这些接口都是用哈希桶封装之后的。
template<class K,class V ,class Hash = HashFunc<K>>
class unordered_map
{
struct mapKeyOfT
{ //获取key值
const K& operator()(const pair<K,V>& kv)
{
return kv.first;
}
};
public:
typedef HashBucket<K, pair<const K,V>, Hash, mapKeyOfT> HaSh;
typedef typename HashBucket<K, pair<const K, V>, Hash, mapKeyOfT>::iterator iterator;
iterator begin()
{
return _ht.begin();
}
iterator end()
{
return _ht.end();
}
pair<iterator, bool> Insert(const pair<K,V>& kv)
{
return _ht.Insert(kv);
}
iterator Erase(iterator pos)
{
return _ht.Erase(pos->first);
}
//bool Erase(const K& key)
//{
// return _ht.Erase(key);
//}
V& operator[](const K& key)
{
pair<iterator, bool> ret = _ht.Insert(make_pair(key,V()));
return ret.first->second;
}
iterator Find(const K& key)
{
return _ht.Find(key);
}
private:
HaSh _ht;
};unordered_set的接口和unordered_map的接口基本一致，这里const迭代器我就不写了，大家有兴趣的可以看看stl源码或者网上搜搜大佬的看法。
3.改造哈希桶的函数
因为我们要封装，所以要对哈希桶的函数进行一些修改，Find的返回类型改成迭代器，Erase可改可不改，看自己，这里的insert跟红黑树差不过，只不过多了一个参数而已。查找会返回一个迭代器，可以把节点用迭代器构造一个返回，删除这里建议使用原来的那个bool值的erase，更改为迭代器以后删除节点，返回值只能是返回被删除节点的上一个节点。
// 插入
pair<iterator,bool> Insert(const T& data)
{
KeyOfT kot;
Hash hs;
//查找表里有没有该值
iterator node = Find(kot(data));
if (node != end())
return make_pair(node,false);
//扩容
if (_tables.size() == _n)
{
vector<Data*> newHT;
newHT.resize(_tables.size() * 2);
for (size_t i = 0; i < _tables.size(); ++i)
{
Data* cur = _tables[i];
while (cur)
{
Data* next = cur->_next;
size_t hashi = hs(kot(cur->_data)) % newHT.size();
cur->_next = newHT[hashi];
newHT[hashi] = cur;
cur = next;
}
_tables[i] = nullptr;
}
_tables.swap(newHT);
}
//插入
size_t hashi = hs(kot(data)) % _tables.size();
Data* newNode = new Data(data);
newNode->_next = _tables[hashi];
_tables[hashi] = newNode;
++_n;
return make_pair(iterator(newNode, this), true);
}
//删除
iterator Erase(const K& key)
{
size_t hashi = Hash()(key) % _tables.size();
Data* cur = _tables[hashi];
Data* prev = nullptr;
while (cur)
{
if (KeyOfT()(cur->_data) == key)
{
//删除
if (cur == _tables[hashi])
{
_tables[hashi] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
delete cur;
return iterator(prev,this);
}
else
{
prev = cur;
cur = cur->_next;
}
}
return iterator(nullptr,this);
}
//查找
iterator Find(const K& key)
{
size_t hashi = Hash()(key) % _tables.size();
Data* cur = _tables[hashi];
while (cur)
{
if (KeyOfT()(cur->_data) == key)
{
return iterator(cur, this);
}
cur = cur->_next;
}
return iterator(nullptr,this);
}完整代码：