本文深入探讨哈希表的底层结构与哈希概念，解析哈希冲突的原因及解决方案，包括线性探测和二次探测等方法，阐述哈希函数的设计原则及常见类型。
一、底层结构
unordered_set/map介绍
https://blog.youkuaiyun.com/chenxiyuehh/article/details/89737056
unordered_set/map应用
https://blog.youkuaiyun.com/chenxiyuehh/article/details/89964419
unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。
二、哈希概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(
l
o
g
2
N
log_2 N
log2N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
- 插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放 - 搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)
举个栗子理解一下
LeetCode387题字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
案例:
- s = “leetcode”
- 返回 0.
- s = “loveleetcode”,
- 返回 2.
- 我们可以看到我们在解决该问题的时候是开辟了一个大小为26的数组(只出现小写字符),然后将出现的字符映射到数组对应的位置，并在对应位置进行计数，这就是哈希的思想，但是这种思想只适用与已知序列较小并且是连续的情况。
三、哈希冲突
3.1 概念
- 对于两个数据元素的关键字 k i k_i ki和 k j k_j kj(i != j)，有 k i k_i ki != k j k_j kj，但有：Hash( k i k_i ki) == Hash( k j k_j kj)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
- 把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
3.2 栗子
我们来看一个栗子理解一下什么是哈希冲突：
例如：我们有 数据集合{1，7，6，4，5，9，16 , 10 , 19 , 21}
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
四、哈希函数
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则：
- 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
- 哈希函数计算出来的地址能均匀分布在整个空间中
- 哈希函数应该比较简单
常见哈希函数
- 直接定制法–(常用)
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况 - 除留余数法–(常用)
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址 - 平方取中法–(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况 - 折叠法–(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况 - 随机数法–(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。通常应用于关键字长度不等时采用此法 - 数学分析法–(了解)
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况
哈希冲突解决之闭散列
闭散列
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？
- 线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
举个栗子
线性探测实现
存储元素定义
- 定义一个哈希表中存储的元素类型，我这里定义为HashNode,存储的是键值对pair<K,V>,考虑到哈希表的删除问题，直接将元素删除会影响哈希地址相同的另一个元素的查找，因此需要存储哈希表中存储元素的状态。
// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State
{
EMPTY,
DELETE,
EXIST
};//
template<class K,class V>
struct HashNode
{
pair<K, V> _kv;
State _state;//元素状态
};
插入元素
- 通过哈希函数获取待插入元素在哈希表中的位置
- 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
bool Insert(const pair<K, V>& kv)
{
size_t index = kv.first % _table.size();
while (_table[index]._state == EXIST)
{
if (_table[index]._kv.first == kv.first)
{
return true;
}
//线性探测解决哈希冲突问题
++index;
if (index == _table.size())
index = 0;
}
//若是该位置没值，直接插入
_table[index]._kv = kv;
_table[index]._state = EXIST;
_size++;
return true;
}
删除元素
- 采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素6，如果直接删除掉，16查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
bool Erase(const K& key)
{
HashNode* node = Find(ket);
if (node != nullptr)
{
node->_state = DELETE;
--_size;
return true;
}
else
{
return false;
}
}
查找元素
- 思想很简单，通过哈希函数找到该元素的对应位置，由于有冲突问题，该位置不一定是要查找的元素，因此我们需要像插入一个元素一样，顺序往后查找这个元素，若是遇到哈希表中状态为EMPTY时停止查找，找到返回该元素的地址，无法返回下标，因为哈希表是私有成员，在类外无法进行访问，返回下标无意义。
HashNode* Find(const K& key)
{
size_t index = key%_table.size();
while (_table[index]._state != EMPTY)
{
if (_table[index]._kv.first == key && _table[index] == EXIST)
{
return &_table[index];
}
++index;
if (index == _table.size())
index = 0;
}
return nullptr;
}
哈希表的增容
- 这里解释一下一个概念：负载因子load factor = 哈希表的大小 / 有效元素的个数，负载因子越小，出现哈希冲突的概率越低，哈希表的效率越高，但是浪费的空间越多
- 这里我把负载因子控制在0.7，当负载因子大于0.7时开始增容，思路是开辟一个新的哈希表，遍历旧表重新计算元素在新表中的位置，计算好了之后，交换两个表
- 这里使用了一个很巧妙的方法，交换两个表之后，旧表更新为newht，得到了新的空间和对应元素的位置，而我们创建的临时对象newht为本函数中的局部对象，出了该函数了作用域之后会自动调用析构函数释放旧表资源，就不需要我们手动释放原来旧表的资源了。
void CheckCapacity()
{
//load factor 等于0.7开始增容，负载因子越小效率越高，空间浪费越多
if (_tabele.size() == 0 || (_size * 10) / _table.size() == 7)
{//增容
size_t newcapacity = _table.size() == 0 ? 10 : _table.size() * 2;
HashTable<K, V> _newht(newcapacity);
//旧表的数据重新计算在新表中的位置
for (size_t i = 0; i < _table.size(); ++i)
{
if (_table[i]._state == EXIST)
_newht.Insert(_table[i]._kv);
}
//交换之后，旧表更新为newht，newht为本函数中的局部对象，
//出了该函数了作用域之后会自动调用析构函数释放旧表资源
_table.swap(_newht._table);
}
}
线性探测完整代码
#pragma once
#include <iostream>
#include <vector>
using namespace std;
enum State
{
EMPTY,
DELETE,
EXIST
};
template<class K,class V>
struct HashNode
{
pair<K, V> _kv;
State _state;
};
template<class K, class V>
class HashTable
{
typedef HashNode<K, V> HashNode;
public:
HashTable(size_t N = 10)
{
_table.resize(N);
for (size_t i = 0; i < _table.size(); ++i)
{
_table[i]._state = EMPTY;
}
_size = 0;
}
void CheckCapacity()
{
//load factor 等于0.7开始增容，负载因子越小效率越高，空间浪费越多
if (_tabele.size() == 0 || (_size * 10) / _table.size() == 7)
{//增容
size_t newcapacity = _table.size() == 0 ? 10 : _table.size() * 2;
HashTable<K, V> _newht(newcapacity);
//旧表的数据重新计算在新表中的位置
for (size_t i = 0; i < _table.size(); ++i)
{
if (_table[i]._state == EXIST)
_newht.Insert(_table[i]._kv);
}
//交换之后，旧表更新为newht，newht为本函数中的局部对象，
//出了该函数了作用域之后会自动调用析构函数释放旧表资源
_table.swap(_newht._table);
}
}
bool Insert(const pair<K, V>& kv)
{
size_t index = kv.first % _table.size();
while (_table[index]._state == EXIST)
{
if (_table[index]._kv.first == kv.first)
{
return true;
}
//线性探测解决哈希冲突问题
++index;
if (index == _table.size())
index = 0;
}
//若是该位置没值，直接插入
_table[index]._kv = kv;
_table[index]._state = EXIST;
_size++;
return true;
}
HashNode* Find(const K& key)
{
size_t index = key%_table.size();
while (_table[index]._state != EMPTY)
{
if (_table[index]._kv.first == key && _table[index] == EXIST)
{
return &_table[index];
}
++index;
if (index == _table.size())
index = 0;
}
return nullptr;
}
bool Erase(const K& key)
{
HashNode* node = Find(ket);
if (node != nullptr)
{
node->_state = DELETE;
--_size;
return true;
}
else
{
return false;
}
}
private:
//HashNode* _table;
//size_t _size;//有效数据个数
//size_t _capacity;//哈希表的空间大小
vector<HashNode> _table;
size_t _size;//哈希表中有效数据的个数
};
void TestHashTable()
{
HashTable<int, int> ht;
int a[] = { 3, 2, 5, 1 };
for (auto& e : a)
{
ht.Insert(make_pair(e, e));
}
}
二次探测
- 线性探测优点：实现非常简单，
- 线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：
H
i
H_i
Hi = (
H
0
H_0
H0 +
i
2
i^2
i2 )% m, 或者：
H
i
H_i
Hi = (
H
0
H_0
H0 -
i
2
i^2
i2 )% m。其中：i = 1,2,3…，
H
0
H_0
H0是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。 对于2.1中如果要插入44，产生冲突，使用解决后的情况为：
研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
扫一扫
973
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
