【C++】哈希表的搭建【开放定址法vs链地址法】
文章目录
1. 哈希的概念
哈希（hash）又称散列，是一种组织数据的方式。它的数据结构是按照一定的规则散乱排列的。本质就是通过哈希函数把关键字key和存储位置建立意义映射的关系，查找时通过哈希函数来计算出存储的位置，进行快速查找。
1.1 直接定址法
当关键字的范围比较集中时，直接定址法是个非常简单高效的方法。比如一组关键字都在[0,99]之间，我们就可以开一个大小为100的数组，每个关键字的值直接就是存储位置的下标。再比如一组关键字的值是[a,z]的小写英文字母，我们就可以开一个大小为26的数组，每个关键字的ascii码减去'a'的ascii码的值就是存储位置的下标。直接定址法本质就是直接用关键字计算出一个绝对位置或者相对位置。
缺点：比较局限，只适合一些特殊的场景。当数据比较分散的时候，比较浪费内存。
例如下面这道题：
387. 字符串中的第一个唯一字符
解题思路：
构建一个简单的哈希结构，给每一个字母建立一个映射位置,每个字母的ascii码减'a'的ascii码作为下标映射到count数组,此时a就对应了数组下标为0的位置，依次类推。数组里面存这个字符出现的次数。
代码实现：
class Solution {
public:
int firstUniqChar(string s) {
//每个字母的ascii码减去`a`的ascii码作为下标映射到hash数组。
int hash[128] = {0};
//统计次数
for(auto ch : s)
{
hash[ch-'a']++;
}
//找出第一个出现的不重复字符
for(int i = 0;i < s.size();i++)
{
if(hash[s[i] - 'a'] == 1)
return i;
}
return -1;
}
};1.2 哈希冲突
上面我们就已经说过，直接定址法的缺点是：当关键字的范围比较分散的时候，就很浪费内存甚至内存不够用。假设我们的数据范围是[0,9999]的N个值，我们要映射到一个空间为M的数组中(M≥N),那么就要借助哈希函数（hash function）hf,关键字key被放到了数组的h（key）位置,这里要注意的是h（key）计算出的值必须在[0,M)之间。
这里就存在了一个问题，两个不同的key可能会映射到同一个位置，这种问题叫做哈希冲突或者哈希碰撞。理想的情况就是我们找到一个好的哈希函数去避免哈希冲突，但实际场景中冲突是不可避免的，所以我们就要尽可能地设计出优秀的哈希函数，减少碰撞的次数，同时也要设计出解决冲突的方案。
1.3 负载因子
假设哈希表中已经映射存储了N个值，哈希表的大小为M，那么负载因子=N/M，负载因子有些地方也翻译为载荷因子/装载因子等，英文名load factor。负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低。
1.4 将关键字转为整数
我们将关键字映射到数组中的位置，一般数整数好做映射计算，如果不是整数，我们要先想办法转化成整数。转化位整数了才好做取余运算。
1.5 哈希函数
一个好的哈希函数应该让N个关键字被等概率的均匀的分布到哈希表的M个空间中，但是实际中这样的函数并不好实现，我们在设计的时候应该去趋于这样的方向。
1.5.1 除法散列法/除留余数法
- 除法散列法也叫除留余数法，假设哈希表的大小为M，那么通过Key除以M的余数作为映射位置的下标，也就是哈希函数为：h(key) = key % M。
- 当使用除留余数法时，要尽量避免M为这些值：2的幂，10的幂等。如果是 2 X 2^X 2X,那么key % 2 X 2^X 2X本质就相当于保留key的后X位，那么X位相同的值，计算出的哈希值都是一样的，就冲突了。如{63,31}看起来没有关联的值，如果M是16，也就是 2 4 2^4 24，那么计算出来的哈希值都是15，因为63的二进制后8位是00111111，31二进制后8位是00011111.,如果是 1 0 X 10^X 10X，就更明显了，保留的都是十进制的后x位，如{112,12313},如果M是100，也就是 1 0 2 10^2 102，那么计算出来的哈希值都是12。
- 当使用除留余数法时，建议M取不太接近2的整数次幂的一个质数（素数）。
1.5.2 乘法散列法
- 乘法散列法对哈希表的大小M没有要求，它的大思路第一步：用关键字K乘上常数A（0<A<1）,并抽取出
k*a的小数部分。第二步：再用M乘以小数部分，再向下取整。 - h(key) = floor(M ×（ (A × K) % 1.0)），其中
floor表示对表达式进行向下取整。这里最重要的是A的值应该如何设定，knuth认为 A = （ 5 \sqrt 5 5 - 1 ） / 2 = 0.6180339887…(黄金分割点)比较好。 - 乘法散列法对哈希表的大小M是没有要求的，假设M为1024，key为1234，A = 0.6180339887,
A*keym = 762.6539420558，取小数部分为0.6539420558, M×((A×key)%1.0) = 0.6539420558*1024 = 669.6366651392，那么h(1234) = 669。
1.5.3 全域散列法
我们将我们的数据进行哈希映射了之后，也存在着被人攻击的风险。如果存在一个恶意的对手，它知道我们在哈希映射时使用了某一个函数。那么此时就会引发一些问题，它故意造一些很容易引发哈希冲突的数据集。比如，让所有关键字全部落入同一个位置中。这种情况是可以存在的，只要散列函数是公开的且确定的，就可以实现此攻击。解决方法是给散列函数增加随机性,攻击者就无法找到确定可以导致最坏情况的数据。这种方法叫做全域散列。
h ab(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,则h34(8) = ((3 × 8 + 4)%17)%6 = 5。需要注意的是每次初始化哈希表时，随机选取全域散列函数组中的一种一个函数来使用，后续增删查改也都固定使用这个散列函数，否则每次哈希都选择一个散列函数，那么插入时是一个散列函数，查找时又是一个散列函数，就会导致找不到对应的
key值了。
1.6 处理哈希冲突
实践中还是选择除留余数法作为哈希函数，当然哈希表无论选择什么函数都避免不了哈希冲突，那么插入数据时，如何解决哈希冲突呢？
主要有两种方法：开放定址法和链地址法
1.6.1 开放定址法
当一个关键字（key）用哈希函数计算出的位置冲突了，则按照某种规则找到一个没有存储数据的位置进行存储。这里的规则有三种：线性探测、二次探测、双重探测。
线性探测
- 从哈希冲突的位置开始，依次向后探测，直到寻找到下一个没有存储数据的位置为止，如果走到哈希表的结尾，则回绕到哈希表头的位置。
- 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的表中。
- 下面演示
h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) = 10，h(12) = 1
二次探测
- 从发生冲突的位置开始，依次左右按二次方跳跃式的探测，直到寻找到下一个没有存储数据的位置为止，如果往右走到哈希表尾，则回绕到哈希表头的位置；如果往左走到哈希表头的位置，则回绕到哈希表尾的位置；
- h(key) = hash0 = key % M, hash0位置冲突了，则二次探测的公式为：
- hc(key,i) = hashi = (hash0 ± i 2 i^2 i2) % M,i = {1,2,3,…, M 2 \frac{M}{2} 2M}
- 二次探测当hashi = (hash0 - i 2 i^2 i2) % M时，hashi < 0 时，hashi += M。
- 下面演示
{19,30,52,63,11,22}等这⼀组值映射到M=11的表中。
h(19) = 8, h(30) = 8, h(52) = 8, h(63) = 8, h(11) = 0, h(22) = 0
双重散列
- 如果第一个哈希函数发生了冲突，使用第二个哈希函数算出一个与
key有关的偏移量，不断往后探测，直到探测到下一个没有存储数据的位置即可。 - h1(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]任选一个奇数u；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
1.6.2 开放定址法代码实现
首先来看一个小的问题：当我们插入30后再次插入20时就会引发哈希冲突，此时就会根据线性探测来到30的下一个位置插入20。那么我们有没有想过当我们把30删除后在进行查找20，还能查找得到吗？显然是查找不到的。
所以我们在设计哈希表的时候为每一个位置上的数据添加一个状态包括：空，存在，删除。最开始这个表都是空。
向上面的问题我们就可以在删除30这个数据后把这个位置标记为删除。
扩容
这里我们哈希表的负载因子控制在0.7，当负载因子到0.7以后我们就需要扩容了，我们还是按照2倍扩容，但是我们还要同时保证哈希表的大小是一个质数，2倍后就不是质数了。那么如何解决呢？我们可以使用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;
}接下来的问题就是我们的表满了后我们如何进行扩容？开了新空间后这些数都得重新映射。
方法一：遍历原表，把原表中的数据放入到新表中
获取素数表里面比当前表大的下一个素数
size_t newSize = __stl_next_prime(_table.size() + 1);
vector<HashData<K, V>> newTables(newSize);
//遍历旧表，将数据全都映射到新表
for (size_t i = 0; i < _table.size(); i++)
{
if (_table[i]._state == EXIST)
{
}
}
_table.swap(newTables);我们之前的方式是定义了一个vector，创建一个新表，我们得自己遍历旧表，自己得算它在新表当中的位置，我们得自己解决冲突。
//下面是新的实现方法
size_t newSize = __stl_next_prime(_table.size() + 1);
HashTable<K, V> newHT;
newHT.resize(newSize);//创建一个哈希表，让哈希表resize到newsize
//遍历旧表，将数据全都映射到新表
for (size_t i = 0; i < _table.size(); i++)
{
if (_table[i]._state == EXIST)
{
newHT.Insert(_tables[i].kv);
}
}
_tables.swap(newHT._tables);
}现在我们创建一个哈希表对象，把表的大小直接开好开到newSize，然后遍历旧表将数据进行插入，插入的时候相当于用新的对象调用Insert，但这里不是递归，只是调用了同一个函数而已。那么有人就要问了，这里是否也调用了扩容？答案是不会调用扩容的，原因是比如原来的表的大小是53，我们大概有40多个数据，下次新表的大小是97，负载因子肯定是小于0.7的，达不到扩容的标准。所以说这里是不会调用扩容的。
但是我们相较于方法一，就把下面这段逻辑复用了。
size_t hash0 = kv.first % _tables;
size_t i = 1;
size_t hashi = hash0;
while (_table[hashi]._state == EXIST)//如果hash0这个位置存在值
{
//冲突探测
hashi = (hash0 + i) % _table.size();
++i;
}
_table[hashi]._kv = kv;
_table[hashi]._state = EXIST;
_n++;key不能取模的问题
比如果我们要实现一个词典，当key为string类型时 ，key不能取模，我们要给HashTable添加一个仿函数，这个仿函数可以把key转换成一个可以取模的整形，如果key可以转换成整形并且不容易冲突，那么这个仿函数就用默认参数即可，如果这个key不能转换成整形，那么我们就需要自己实现一个仿函数传给这个参数，实现这个仿函数的要求就是要key的每一个值都参与到计算中，让不同的key转换成不同的整型值。string做哈希表的key非常非常常见，所以我们要想办法将string 转换成整形值。
我们可以把一个单词的每个字符的ascii码加起来作为整型值
class stringHashFunc
{
public:
size_t operator()(const string& s)
{
size_t hash = 0;
for (auto ch : s)
{
hash += ch;//把这个字符的所有的Ascii码值加起来
}
return hash;
}
private:
};但是这样做又有一个问题，像下面的这些对象的ascii码值加起来一样，不是也导致冲突了吗？
void TestHT2()
{
HashTable<string, string,stringHashFunc> ht2;
ht2.Insert({"sort","排序"});
ht2.Insert({ "string","字符串" });
cout << stringHashFunc()("abcd") << endl;
cout << stringHashFunc()("acbd") << endl;
cout << stringHashFunc()("abbe") << endl;
}解决思路：BKDR_HASH
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& key)
{
size_t hash = 0;
for (auto ch : key)
{
hash += ch;//把这个字符的所有的Ascii码值加起来
hash *= 131;
}
return hash;
}
};由于string 类是我们经常用到的，所以我们对string进行特化，意味着如果数据是整形或者浮点型将走原模版，将转成无符号的整形；如果是string就走特化。因为string太常见了，我们对string 单独进行处理，这也意味着string类的数据不需要我们写仿函数了。
1.6.3 链地址法
解决冲突的思路
开放地址法中所有的元素都放到哈希表里，连地址法中所有的数据不再存储在哈希表里，哈希表中存储一个指针，没有数据映射到这个位置时，这个指针为空；有多个数据映射到这个位置时，我们把这些冲突的数据链接成一个链表，挂在哈希表这个位置下面，链地址法也叫做拉链法或者哈希桶。
下面演示 {19,30,5,36,13,20,21,12,24,96} 等这一组值映射到M=11的表中
h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) = 10，h(12) = 1,h(24) = 2,h(96) = 88
扩容
开放地址法的负载因子必须小于1，链地址法的负载因子没有限制，也可以大于1.负载因子越大，哈希冲突的概率越高，空间利用率越高；负载因子越小，哈希冲突的概率越低，空间利用率越低。stl中unordered_xxx的最大负载因子基本控制在1，大于1就扩容，我们下面实现也使用这个方式。
插入的时候会出现两种情况：第一种情况是有值，第二种情况是没有值。这里头插尾插都可以，但是我们这里原则头插，因为尾插还得找尾更麻烦一点。
这里和上面不同的是，上面的每一个数据都是在表里面的。而这里的数据是一个一个的结点，结点是一小块的内存，所以我们就可以直接把这一个一个的结点挪动到新表中。如果我们再次像上面那样再次调用Insert就会把原表中的结点数据拷贝一份插入到新表中，再去调用delete销毁原表中的Node结点，这样太过冗余。
1.6.4 链地址法代码实现
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& key)
{
size_t hash = 0;
for (auto ch : key)
{
hash += ch;//把这个字符的所有的Ascii码值加起来
hash *= 131;
}
return hash;
}
};
namespace open_address
{
enum State
{
EXIST,
EMPTY,
DELETE
};
template<class K, class V>
struct HashData
{
pair<K, V> _kv;
State _state = EMPTY;//每个位置的值的状态
};
namespace hash_bucket
{
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.resize(__stl_next_prime(1),nullptr);
}
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;
}
~HashTable()
{
//依次释放每个桶
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_tables[i] = nullptr;
}
}
bool Insert(const pair<K, V>& kv)
{
if (Find(kv.first))
return false;
Hash hs;
//负载因子到1就扩容
if (_n == _tables.size())
{
long newSize = __stl_next_prime((long)_tables.size() + 1);
vector<Node*> newtables(newSize,nullptr);
//遍历旧表，把就旧表的结点挪动到新表中
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
//算出cur在新表当中的位置
size_t hashi =hs(cur->_kv.first) % newSize;
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;
}
}
private:
//vector<list<pair<K, V>>> _tables;
vector<Node*> _tables; //指针数组
size_t _n = 0; //表中存储数据个数
};
void TestHT1()
{
HashTable<int, int> ht1;
ht1.Insert({ 54,1 });
ht1.Insert({ 1,1 });
for (int i = 0; i < 53; i++)
{
ht1.Insert({ rand(),i});
}
}
void TestHT2()
{
HashTable<string, string> ht2;
ht2.Insert({ "sort","排序" });
ht2.Insert({ "string","字符串" });
}
}如果对你有帮助，欢迎：
- 点赞 ⭐️
- 收藏
- 关注
浙公网安备 33010602011771号