哈希
1 unordered 系列关联式容器
unordered_map/unordered_multimap unordered_set/unordered_multiset 这4个容器的用法基本和前面文章介绍的map/multimap set/multiset一样,所以不赘述。
2 底层结构
和 map/set 不同的是,set/map 底层实现是红黑树查询增删的效率是 O(logN),而 unordered_set/map 的底层实现是哈希表,查询和增删的效率更高为 O(1)
利用红黑树实现map/set可以参考:https://github.com/CZH214926/C_repo/commit/f66d497b151025735653c48bcd904374e194c3e5
那么详细谈谈哈希表
2.1 哈希概念
顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应关系,因此在查找一个元素时,必须要经过关键码的多次比较。
顺序查找的时间复杂度为 O(N)
,平衡树中为树的高度,即O(logN)
,搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法是:可以不经过任何比较,一次直接从表中得到要搜索的元素,如果构造一种存储结构,通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一的映射关系,那么在查找时通过该函数可以很快找到该元素。
- 当向结构中插入(insert)元素时====> 根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放
- 当在结构中搜索(find)元素时====> 对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若关键码相等,则搜索成功。(至于为什么会比较看后面的哈希冲突自会明白)
这方式即为哈希(散列)法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(Hash Table)或者称散列表。
用该方法进行搜索不必进行多次关键码的比较,因此搜索的速度比较快,那么插入44呢?会出现什么问题呢?就此我们引入哈希冲突/碰撞的概念。
2.2 哈希冲突/碰撞
对于两个数据比如上面的 4 和 44 ,二者不等但是哈希函数值相等即:不同的关键字通过相同的哈希函数计算出相同的哈希地址,这种现象称为哈希冲突或者哈希碰撞。把具有不同的关键码但具有相同的哈希地址的数据元素称为"同义词"。
2.3 哈希函数
引起哈希冲突的一个原因可能是:哈希函数设计的不够合理。哈希函数设计的原则如下
- 哈希函数的定义域必须包括需要存储的全部关键码,而如果哈希表有 m 个地址时,其值域必须在0 到 m - 1之间
- 哈希函数计算出来的地址能均匀分布在整个空间中
- 哈希函数要设计的较简单
2.3.1 常见的哈希函数
1 直接定址法(常用)
- 取关键字的某个线性函数为散列地址:Hash(Key) = A * Key + B 优点:简单、均匀 缺点:需要事先知道关键字的分布情况 使用场景:适合查找比较小且连续的情况。
2 除留余数法(用的最多)
- 设散列允许的地址数为m ,取一个不大于m,但最接近或者等于m 的质数 p 作为除数,按照哈希函数:Hash(key) = key % p(p <= m),将关键码转换为哈希地址
3 除此以外还有 平方取中法 折叠法 随机数法、数学分析法,这些方法都不常用。
注意:哈希函数设计的越巧妙,产生冲突的可能性就越低,但是无法避免哈希冲突。
2.4 解决哈希冲突的方式
解决哈希冲突两种常见的方法是:闭散列和开散列
2.4.1 闭散列
闭散列也叫开放定址法,当发生哈希冲突时,如果哈希表未被填满,说明哈希表中必然还有空位置,那么可以把、key存放到冲突位置的 "下一个"空位置中去。那么如何寻找下一个空位置呢?线性探测 二次探测
1)线性探测
- 比如上面的场景,现在需要插入元素44,先通过哈希函数计算哈希地址,hashAddr为4,因此44理论上应该插在该位置,但是该位置已经放了值为4的元素,即发生哈希冲突。
- 线性探测:从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位置为止。
插入
1 通过哈希函数获取待插入元素在哈希表中的位置
2 如果该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突,使用线性探测找到下一个空位置,插入新元素
删除
采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素会影响其他元素的搜索。比如删除元素4,如果直接删除掉,44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素
。
线性探测的代码如下
#pragma once
// 仿函数(类)
template<class K>
struct Hash
{
size_t operator()(const K& key)
{
return key;
}
};
// string 哈希映射常用,所以用模板特化
template<>
struct Hash<string>
{
size_t operator()(const string& str)
{
size_t hash = 0;
for (auto & ch : str)
{
hash = hash * 131 + ch;
}
return hash;
}
};
static size_t GetNextPrime(size_t prime) {
static const int PRIMECOUNT = 28;
static const size_t primeList[PRIMECOUNT] = {
53ul, 97ul, 193ul, 389ul, 769ul,
1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
1610612741ul, 3221225473ul, 4294967291ul
};
size_t i = 0;
for (; i < PRIMECOUNT; ++i)
{
if (primeList[i] > prime)
return primeList[i];
}
return primeList[i];
}
// 闭散列,线性探测法
namespace close
{
enum State
{
EMPTY,
EXIST,
DELETE,
};
template<class T>
struct HashNode
{
State _state = EMPTY;
T _t;
};
// 前置声明
template<class K, class T, class KeyOfT, class hash>
class HashTable;
//迭代器
template<class K, class T, class KeyOfT, class hash>
struct
template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
class HashTable
{
private:
vector<HashNode<T>> _table;
size_t _size = 0; // 有效元素的个数
public:
bool Insert(const T& t)
{
//扩容(负载因子大于0.7)
if (_table.size() == 0 || _size * 10 / _table.size() == 7)
{
//size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
size_t newsize = GetNextPrime(_table.size());
//_table.resize(newsize); 这里解决不了,扩容后哈希表的长度就变了,那么原来的
// 数据分布就变了,所以单纯的扩容是不对的
HashTable<K, T,HashFunc> newht; // 定义这个就是为了能调用Insert,可以复用探测的逻辑
newht._table.resize(newsize);
for (auto& e : _table)
{
if (e._state == EXIST)
{
newht.Insert(e._t);
}
}
_table.swap(newht._table);
}
HashNode<T>* ret = Find(t);
if (ret)
return false;
HashFunc hf;
size_t start = hf(t) % _table.size();
// 线性探测找一个空位置
size_t index = start;
size_t i = 1; // 线性探测的步长
while (_table[index]._state == EXIST)
{
index = start + i;
index %= _table.size();
i++;
}
_table[index]._t = t;
_table[index]._state = EXIST;
_size++;
return true;
}
HashNode<T>* Find(const K& key)
{
HashFunc hf;
size_t start = hf(key) % _table.size();
size_t index = start;
size_t i = 1; // 线性探测的步长
while (_table[index]._state != EMPTY) //只要不是空都继续找
{
if (_table[index]._t == key && _table[index]._state == EXIST)
return &_table[index];
index = start + i;
index %= _table.size();
++i;
}
return nullptr;
}
bool Erase(const K& key)
{
HashNode<T>* ret = Find(key);
if (ret == nullptr)
return false;
else
ret->_state = DELETE;// 伪删除
}
};
void TestHashTable()
{
HashTable<int, int> ht;
ht.Insert(5);
ht.Insert(15);
ht.Insert(25);
// 自己写一个仿函数把string 搞成int
HashTable<string, string> strht;
strht.Insert("string");
strht.Insert("list");
Hash<string> h;
cout << h("abcd") << endl;
cout << h("acbd") << endl;
}
}
关于线性探测的几点讨论和总结
线性探测的优点:实现简单
线性探测的缺点:一旦发生哈希冲突,所有的冲突连在一起,容易产生数据的"堆积",即:不同的关键码占据了可利用的空位置,使得寻找某个关键码的位置需要进行多次比较,导致搜索的效率降低。
哈希表什么情况下进行扩容?如何扩容?
- 哈希表的载荷因子定义为:α = 填入表的元素个数 / 散列表的长度 α 是散列表装满程度的标志因子,由于表长是定值,α 与"填入表中的元素越少,产生冲突的可能性就越小。
- 对于开放定址法,载荷因子是特别重要的因素,应严格限制在0.7 - 0.8 以下。超过0.8,查表时的 CPU 缓存不命中(cache missing),按照指数曲线上升。因此,一些采用开放定址法的 hash 库,如Java 的系统库限制了载荷因子为0.75,超过 0.75 将 resize 散列表。
载荷因子越小,冲突的概率越小,效率越高,但是空间利用率越低。
载荷因子越大,冲突的概率越大,效率越低,但是空间利用率越高。
2)二次探测
1 线性探测的缺陷是产生冲突的数据堆积在一块,这与其找下一个空位置有关系,因为找空位置的方式就是挨着往后逐个去找,因此二次探测为了避免该问题,找下一个空位置的方法为:Hi = (H0 + i^2)%m 或者 Hi = (H0 - i^2) % m,其中:i = 1,2,3....,H0是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置,m是表的大小。
2 研究表明:当表的长度为质数且表装载因子a不超过0.5时,新的表项一定能够插入,而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置,就不会存在表满的问题。在搜索时可以不考虑表装满的情况,但在插入时必须确保表的装载因子a不超过0.5,如果超出必须考虑增容。
因此:比散列最大的缺陷就是空间利用率比较低,这也是哈希的缺陷。
2.4.2 开散列
1. 开散列的概念
开散列法又叫链地址法(拉链法),首先对关键码集合用散列函数计算散列地址,具有相同地址的关键码归于同一集合,每个子集合称为一个桶,各个桶的元素通过一个单链表连接起来,各链表的头结点存储在哈希表里。
2. 开散列的简单实现
// 开散列==>哈希桶 用这个封装unordered_map / unordered_set
namespace Open
{
// 哈希桶内的结点
template<class T>
struct HashLinkNode
{
T _t;
HashLinkNode<T>* _next;
HashLinkNode(const T& t)
:_t(t)
, _next(nullptr)
{}
};
template<class K, class T, class KeyOfT, class hash = Hash<K>>
class HashTable
{
typedef HashLinkNode<T> Node;
private:
vector<Node*> _table;
size_t _size = 0; // 有效数据个数 缺省值
public:
size_t HashFunc(const K& key, size_t n)
{
hash hf;
size_t ki = hf(key);
return ki % n;
}
pair<Node*, bool> Insert(const T& t)
{
KeyOfT kot;
// 负载因子等于1时增容
if (_size == _table.size())
{
size_t newsize = GetNextPrime(_table.size());
vector<Node*> newtable;
newtable.resize(newsize, nullptr);
for (size_t i = 0; i < _table.size(); i++)
{
// 从旧表中直接取下来挂到新表
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
size_t index = HashFunc(kot(cur->_t), newtable.size());
cur->_next = newtable[index];
newtable[index] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(newtable);
}
// 查看t在不在,在的话就不插入,不在就插入
size_t index = HashFunc(kot(t), _table.size());
Node* cur = _table[index];
// 如果此时cur不为空则t所在的桶存在,但是t值是否真正存在还需顺着链表往后找
while (cur)
{
if (kot(cur->_t) == kot(t))
return make_pair(cur, false);
cur = cur->_next;
}
// 如果不进while 循环程序走到这里证明,t所在的哈希桶并不存在,直接直接头插到index所在位置
Node* newnode = new Node(t);
newnode->_next = _table[index];
_table[index] = newnode;
return make_pair(newnode, true);
}
Node* Find(const K& key)
{
size_t index = HashFunc(key, _table.size());
Node* cur = _table[index];
while (cur)
{
if (key == kot(cur->_t))
return cur;
cur = cur->_next;
}
return cur;
}
bool Erase(const K& key)
{
// 先Find下
Node* ret = Find(key);
if (!ret)
return false;
size_t index = HashFunc(key, _table.size());
Node* cur = _table[index];
if (key == kot(cur->_t))
{
// 头删
Node* next = cur->_next;
delete cur;
cur == nullptr;
_table[index] = next;
}
else
{
while (cur)
{
Node* prev = nullptr;
if (key == kot(cur->_t))
{
prev->_next = cur->_next;
delete cur;
cur = nullptr;
}
prev = cur;
cur = cur->_next;
}
}
return true;
}
};
}
从上图可以看出,开散列中每个桶中放的都是发生哈希冲突的元素。
3. 开散列什么时候增容比较合适
桶的个数是一定的,随着元素的不断插入,每个桶中元素的个数不断增多,极端情况下,可能会导致一个桶中链表节点非常多,会影响的哈希表的性能,因此在一定条件下需要对哈希表进行增容,那该条件怎么确认呢?开散列最好的情况是:每个哈希桶中刚好挂一个节点,再继续插入元素时,每一次都会发生哈希冲突,因此,在元素个数刚好等于桶的个数时,可以给哈希表增容。此时载荷因子为1
4. 关于开散列的两个问题
1)只能存储key为整形的元素,其他类型怎么解决?
哈希函数采用处理余数法,被模的key必须要为整形才可以处理,此处提供将key转化为整形的方法,比如对于string类
// string 哈希映射常用,所以用模板特化
template<>
struct Hash<string>
{
size_t operator()(const string& str)
{
size_t hash = 0;
for (auto & ch : str)
{
hash = hash * 131 + ch;
}
return hash;
}
};
2) 除留余数法,最好模一个素数,如何每次快速取一个类似两倍关系的素数?
static size_t GetNextPrime(size_t prime) {
static const int PRIMECOUNT = 28;
static const size_t primeList[PRIMECOUNT] = {
53ul, 97ul, 193ul, 389ul, 769ul,
1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
1610612741ul, 3221225473ul, 4294967291ul
};
size_t i = 0;
for (; i < PRIMECOUNT; ++i)
{
if (primeList[i] > prime)
return primeList[i];
}
return primeList[i];
}
5. 开散列和闭散列的比较
闭散列(链地址法)处理冲突,需要增设链接指针,似乎是增加了存储开销。事实上:由于开放地址法必须保持大量的空闲时间以确保效率,如二次探测法要求装载因子 <= 0.7,而表项所占的空间又比指针大的多,所以使用链地址法比开放定址法节省存储空间。
3 模拟实现
#pragma once
// 仿函数(类)
template<class K>
struct Hash
{
size_t operator()(const K& key)
{
return key;
}
};
// string 哈希映射常用,所以用模板特化
template<>
struct Hash<string>
{
size_t operator()(const string& str)
{
size_t hash = 0;
for (auto & ch : str)
{
hash = hash * 131 + ch;
}
return hash;
}
};
static size_t GetNextPrime(size_t prime) {
static const int PRIMECOUNT = 28;
static const size_t primeList[PRIMECOUNT] = {
53ul, 97ul, 193ul, 389ul, 769ul,
1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
1610612741ul, 3221225473ul, 4294967291ul
};
size_t i = 0;
for (; i < PRIMECOUNT; ++i)
{
if (primeList[i] > prime)
return primeList[i];
}
return primeList[i];
}
// 闭散列,线性探测法
namespace close
{
enum State
{
EMPTY,
EXIST,
DELETE,
};
template<class T>
struct HashNode
{
State _state = EMPTY;
T _t;
};
// 前置声明
template<class K, class T, class KeyOfT, class hash>
class HashTable;
//迭代器
template<class K, class T, class KeyOfT, class hash>
struct
template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
class HashTable
{
private:
vector<HashNode<T>> _table;
size_t _size = 0; // 有效元素的个数
public:
bool Insert(const T& t)
{
//扩容(负载因子大于0.7)
if (_table.size() == 0 || _size * 10 / _table.size() == 7)
{
//size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
size_t newsize = GetNextPrime(_table.size());
//_table.resize(newsize); 这里解决不了,扩容后哈希表的长度就变了,那么原来的
// 数据分布就变了,所以单纯的扩容是不对的
HashTable<K, T,HashFunc> newht; // 定义这个就是为了能调用Insert,可以复用探测的逻辑
newht._table.resize(newsize);
for (auto& e : _table)
{
if (e._state == EXIST)
{
newht.Insert(e._t);
}
}
_table.swap(newht._table);
}
HashNode<T>* ret = Find(t);
if (ret)
return false;
HashFunc hf;
size_t start = hf(t) % _table.size();
// 线性探测找一个空位置
size_t index = start;
size_t i = 1; // 线性探测的步长
while (_table[index]._state == EXIST)
{
index = start + i;
index %= _table.size();
i++;
}
_table[index]._t = t;
_table[index]._state = EXIST;
_size++;
return true;
}
HashNode<T>* Find(const K& key)
{
HashFunc hf;
size_t start = hf(key) % _table.size();
size_t index = start;
size_t i = 1; // 线性探测的步长
while (_table[index]._state != EMPTY) //只要不是空都继续找
{
if (_table[index]._t == key && _table[index]._state == EXIST)
return &_table[index];
index = start + i;
index %= _table.size();
++i;
}
return nullptr;
}
bool Erase(const K& key)
{
HashNode<T>* ret = Find(key);
if (ret == nullptr)
return false;
else
ret->_state = DELETE;// 伪删除
}
};
void TestHashTable()
{
HashTable<int, int> ht;
ht.Insert(5);
ht.Insert(15);
ht.Insert(25);
// 自己写一个仿函数把string 搞成int
HashTable<string, string> strht;
strht.Insert("string");
strht.Insert("list");
Hash<string> h;
cout << h("abcd") << endl;
cout << h("acbd") << endl;
}
}
// 开散列==>哈希桶 用这个封装unordered_map / unordered_set
namespace Open
{
// 哈希桶内的结点
template<class T>
struct HashLinkNode
{
T _t;
HashLinkNode<T>* _next;
HashLinkNode(const T& t)
:_t(t)
, _next(nullptr)
{}
};
template<class K, class T, class KeyOfT, class hash = Hash<K>>
class HashTable
{
typedef HashLinkNode<T> Node;
private:
vector<Node*> _table;
size_t _size = 0; // 有效数据个数 缺省值
public:
size_t HashFunc(const K& key, size_t n)
{
hash hf;
size_t ki = hf(key);
return ki % n;
}
pair<Node*, bool> Insert(const T& t)
{
KeyOfT kot;
// 负载因子等于1时增容
if (_size == _table.size())
{
size_t newsize = GetNextPrime(_table.size());
vector<Node*> newtable;
newtable.resize(newsize, nullptr);
for (size_t i = 0; i < _table.size(); i++)
{
// 从旧表中直接取下来挂到新表
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
size_t index = HashFunc(kot(cur->_t), newtable.size());
cur->_next = newtable[index];
newtable[index] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(newtable);
}
// 查看t在不在,在的话就不插入,不在就插入
size_t index = HashFunc(kot(t), _table.size());
Node* cur = _table[index];
// 如果此时cur不为空则t所在的桶存在,但是t值是否真正存在还需顺着链表往后找
while (cur)
{
if (kot(cur->_t) == kot(t))
return make_pair(cur, false);
cur = cur->_next;
}
// 如果不进while 循环程序走到这里证明,t所在的哈希桶并不存在,直接直接头插到index所在位置
Node* newnode = new Node(t);
newnode->_next = _table[index];
_table[index] = newnode;
return make_pair(newnode, true);
}
Node* Find(const K& key)
{
size_t index = HashFunc(key, _table.size());
Node* cur = _table[index];
while (cur)
{
if (key == kot(cur->_t))
return cur;
cur = cur->_next;
}
return cur;
}
bool Erase(const K& key)
{
// 先Find下
Node* ret = Find(key);
if (!ret)
return false;
size_t index = HashFunc(key, _table.size());
Node* cur = _table[index];
if (key == kot(cur->_t))
{
// 头删
Node* next = cur->_next;
delete cur;
cur == nullptr;
_table[index] = next;
}
else
{
while (cur)
{
Node* prev = nullptr;
if (key == kot(cur->_t))
{
prev->_next = cur->_next;
delete cur;
cur = nullptr;
}
prev = cur;
cur = cur->_next;
}
}
return true;
}
};
}
用哈希表封装实现 unordered_map 和 unordered_set : https://github.com/CZH214926/C_repo
4 总结
1 map 和 set 里面存储的数据有没有什么要求?unordered_map 和 unordered_set 呢?
- map 和 set 因为其底层是平衡二叉搜索树(红黑树),所以存储的数据的key必须满足可以比较大小和相等。
- unordered_set unordered_map 因为底层是哈希表,所以 key 必须要支持取模和能比较相等,如果不支持取模操作比如字符串,就要自己写仿函数就其转化为整型。因为string 转 整型太常用了,所以采用模板特化将其设在库里。
2 能用 map和set地方,就能用 unordered_map 和 unordered_set
3 载荷因子闭散列不会超过1,开散列(哈希桶)会超过1
4 哈希表的插入会很快,一把算出要插入的位置直接插入,即使已有数据,也不过是在每个桶内进行单链表的头插,只有在增容的时候,会把原来表里的数据重新插入到空间更大的哈希表里。则哈希表的插入的是复杂度可是理解为下图:进入峰值就是增容时候
5 如果大多数甚至超过一半的数据都被挂到一个桶里,则采用改成挂红黑树(java中采用这个,STL未采用),或者多阶哈希。