C++ unordered系列关联式容器与哈希结构深度解析
📚 目录
📦 1. unordered系列关联式容器
在 C++98 中，STL 提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log_2 N log2N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在 C++11 中，STL 又提供了 4 个 unordered 系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对 unordered_map 和 unordered_set 进行介绍，unordered_multimap 和 unordered_multiset 可查看文档介绍。
🗺️ 1.1 unordered_map
📖 1.1.1 unordered_map的文档介绍
- unordered_map 是存储
<key, value>键值对的关联式容器，其允许通过 keys 快速的索引到与其对应的 value。 - 在 unordered_map 中，键值通常用于惟一地标识元素，而3. 在内部，unordered_map 没有对
<key, value>按照任何特定的顺序排序，为了能在常数范围内找到 key 所对应的 value，unordered_map 将相同哈希值的键值对放在相同的桶中。unordered_map 将相同哈希值的键值对放在相同的桶中。 - unordered_map 容器通过 key 访问单个元素要比 map 快，但它通常在遍历元素子集的范围迭代方面效率较低。
- unordered_maps 实现了直接访问操作符 (operator[])，它允许使用 key 作为参数直接访问 value。
- 它的迭代器至少是前向迭代器。
🔧 1.1.2 unordered_map的接口说明
1. unordered_map的构造
| 函数声明 | 功能介绍 |
|---|---|
unordered_map |
构造不同格式的 unordered_map 对象 |
2. unordered_map的容量
| 函数声明 | 功能介绍 |
|---|---|
bool empty() const |
检测 unordered_map 是否为空 |
size_t size() const |
获取 unordered_map 的有效元素个数 |
3. unordered_map的迭代器
| 函数声明 | 功能介绍 |
|---|---|
begin |
返回 unordered_map 第一个元素的迭代器 |
end |
返回 unordered_map 最后一个元素下一个位置的迭代器 |
cbegin |
返回 unordered_map 第一个元素的 const 迭代器 |
cend |
返回 unordered_map 最后一个元素下一个位置的 const 迭代器 |
4. unordered_map的元素访问
| 函数声明 | 功能介绍 |
|---|---|
operator[] |
返回与key对应的value，没有一个默认值 |
注意：该函数中实际调用哈希桶的插入操作，用参数 key 与 V() 构造一个默认值往底层哈希桶中插入，如果 key 不在哈希桶中，插入成功，返回 V()；插入失败，说明 key 已经在哈希桶中，将 key 对应的 value 返回。明 key 已经在哈希桶中，将 key 对应的 value 返回。
5. unordered_map的查询
| 函数声明 | 功能介绍 |
|---|---|
iterator find(const K& key) |
返回 key 在哈希桶中的位置 |
size_t count(const K& key) |
返回哈希桶中关键码为 key 的键值对的个数 |
注意：unordered_map中key是不能重复的，因此count函数的返回值最大为1
| 函数声明 | 功能介绍 |
|---|---|
insert |
向容器中插入键值对 |
erase |
删除容器中的键值对 |
void clear() |
清空容器中的有效元素 |
void swap(unordered_map&) |
交换两个容器中的元素 |
7. unordered_map的桶操作
| 函数声明 | 功能介绍 |
|---|---|
size_t bucket_count() const |
返回哈希桶中桶的总个数 |
size_t bucket_size(size_t n) const |
返回 n 号桶中有效元素的总个数 |
size_t bucket(const K& key) |
返回元素 key 所在的桶号 |
🗃️ 1.2 unordered_set
💻 1.3 在线 OJ
重复 n 次的元素
class Solution {
public:
int repeatedNTimes(vector<int>& A) {
size_t N = A.size() / 2;
// 用 unordered_map 统计每个元素出现的次数
unordered_map<int, int> m;
for (auto e : A)
m[e]++;
// 找出出现次数为 N 的元素
for (auto& e : m) {
if (e.second == N)
return e.first;
}
return -1; // 根据题意，理论上不会走到这里
}
};
两个数组的交集 I
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
// 用 unordered_set 对 nums1 中的元素去重
unordered_set<int> s1;
for (auto e : nums1)
s1.insert(e);
// 用 unordered_set 对 nums2 中的元素去重
unordered_set<int> s2;
for (auto e : nums2)
s2.insert(e);
// 遍历 s1，如果 s1 中某个元素在 s2 中出现过，即为交集
vector<int> vRet;
for (auto e : s1) {
if (s2.find(e) != s2.end())
vRet.push_back(e);
}
两个数组的交集 II
存在重复元素
两句话中不常见的单词
🏗️ 2. 底层结构
unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。
🔍 2.1 哈希概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为 O ( N ) O(N) O(N)，平衡树中为树的高度，即 O ( l o g 2 N ) O(log_2 N) O(log2N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数 (hashFunc) 使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
- 插入元素：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
- 搜索元素：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希 (散列) 方法，哈希方法中使用的转换函数称为哈希 (散列) 函数，构造出来的结构称为哈希表 (Hash Table) (或者称散列表)。
例如：数据集合 {1, 7, 6, 4, 5, 9}；
哈希函数设置为：hash(key) = key % capacity; capacity 为存储元素底层空间总的大小。
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？
📻2.2 哈希冲突
对于两个数据元素的关键字 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)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
发生哈希冲突该如何处理呢？
⚙️ 2.3 哈希函数
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。
哈希函数设计原则：
- 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有 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 种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：
假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前 7 位都是相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转 (如 1234 改成 4321)、右环位移 (如 1234 改成 4123)、左环移位、前两数与后两数叠加 (如 1234 改成 12+34=46) 等方法。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况
注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。
🛠️ 2.4 哈希冲突解决
解决哈希冲突两种常见的方法是：闭散列和开散列。
🔓 2.4.1 闭散列
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把 key 存放到冲突位置中的“下一个”空位置中去。那如何寻找下一个空位置呢？
1. 线性探测
比如 2.1 中的场景，现在需要插入元素 44，先通过哈希函数计算哈希地址，hashAddr 为 4，因此 44 线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
插入
- 通过哈希函数获取待插入元素在哈希表中的位置
- 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
删除
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素 4，如果直接删除掉，44 查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};
线性探测实现要点：
- 状态标记：每个位置有三种状态：EMPTY（空）、EXIST（有元素）、DELETE（已删除）
- 插入流程：
- 计算哈希地址
- 如果该位置状态为EXIST且key相同，插入失败（不允许重复）
- 如果该位置状态为EMPTY或DELETE，插入元素并标记为EXIST
- 如果发生冲突，线性向后探测直到找到合适位置
- 查找流程：
- 计算哈希地址
- 从该位置开始线性探测
- 遇到EMPTY状态停止（说明元素不存在）
- 遇到EXIST状态且key匹配则找到
- 遇到DELETE状态继续探测
- 删除流程：
- 先查找元素位置
- 将状态标记为DELETE（伪删除）
- 不实际删除数据，只改变状态标记
- 扩容机制：
- 当负载因子（元素个数/容量）超过阈值（如0.7）时扩容
- 扩容需要重新哈希所有元素
线性探测哈希表实现示例：
// 线性探测哈希表实现
template<class K, class V>
class HashTable
{
struct Elem
{
pair<K, V> _val;
State _state;
};
public:
HashTable(size_t capacity = 10)
: _size(0)
{
_ht.resize(capacity);
for (size_t i = 0; i < capacity; ++i)
{
_ht[i]._state = EMPTY;
}
}
// 插入元素
bool Insert(const pair<K, V>& val)
{
// 检查是否需要扩容
CheckCapacity();
size_t hashAddr = HashFunc(val.first);
// 线性探测
while (_ht[hashAddr]._state == EXIST)
{
// 如果key已经存在，插入失败
if (_ht[hashAddr]._val.first == val.first)
return false;
// 继续探测下一个位置
++hashAddr;
if (hashAddr == _ht.capacity())
hashAddr = 0;
/* // 转一圈也没有找到，注意：动态哈希表，该种情况可以不用考虑，哈希表中元
//素个数到达一定的数量，哈希冲突概率会增大，需要扩容来降低哈希冲突，因此哈希表中元素是不会存满的
if(hashAddr == startAddr)
return false;
*/
}
// 插入元素
_ht[hashAddr]._val = val;
_ht[hashAddr]._state = EXIST;
++_size;
return true;
}
// 查找元素
int Find(const K& key)
{
size_t hashAddr = HashFunc(key);
size_t startAddr = hashAddr;
while (_ht[hashAddr]._state != EMPTY)
{
if (_ht[hashAddr]._state == EXIST &&
_ht[hashAddr]._val.first == key)
{
return hashAddr; // 找到，返回位置
}
++hashAddr;
if (hashAddr == _ht.capacity())
hashAddr = 0;
// 如果回到起点，说明没找到
if (hashAddr == startAddr)
break;
}
return -1; // 没找到
}
// 删除元素（伪删除）
bool Erase(const K& key)
{
int index = Find(key);
if (index != -1)
{
_ht[index]._state = DELETE;
--_size;
return true;
}
return false;
}
// 哈希函数（简单示例，实际需要更复杂的哈希函数）
size_t HashFunc(const K& key)
{
return key % _ht.capacity();
}
// 检查并扩容
void CheckCapacity()
{
// 当负载因子超过0.7时扩容
if (_size * 10 / _ht.capacity() >= 7)
{
size_t newCapacity = GetNextPrime(_ht.capacity() * 2);
HashTable<K, V> newHt(newCapacity);
// 重新插入所有元素
for (size_t i = 0; i < _ht.capacity(); ++i)
{
if (_ht[i]._state == EXIST)
{
newHt.Insert(_ht[i]._val);
}
}
_ht.swap(newHt._ht);
}
}
// 获取下一个质数（用于扩容）
size_t GetNextPrime(size_t num)
{
static const size_t primeList[] = {
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
};
for (size_t i = 0; i < sizeof(primeList) / sizeof(primeList[0]); ++i)
{
if (primeList[i] > num)
return primeList[i];
}
return primeList[sizeof(primeList) / sizeof(primeList[0]) - 1];
}
private:
vector<Elem> _ht;
size_t _size;
};
// 使用示例
int main()
{
HashTable<int, string> ht;
// 插入元素
ht.Insert(make_pair(1, "one"));
ht.Insert(make_pair(2, "two"));
ht.Insert(make_pair(11, "eleven")); // 11 % 10 = 1，会发生哈希冲突
// 查找元素
int pos = ht.Find(11);
if (pos != -1)
cout << "找到元素11" << endl;
// 删除元素
ht.Erase(2);
return 0;
}
思考：哈希表什么情况下进行扩容？如何扩容？
线性探测优点：实现非常简单
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同
关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降
低。如何缓解呢？
2. 二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： 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，如果超出必须考虑增容。
因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。
🔗 2.4.2 开散列
1. 开散列概念
开散列法又叫链地址法 (开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。
2. 开散列实现
template<class V>
struct HashBucketNode
{
HashBucketNode(const V& data)
: _pNext(nullptr), _data(data)
{}
HashBucketNode<V>* _pNext;
V _data;
};
// 本文所实现的哈希桶中key是唯一的
template<class V>
class HashBucket
{
typedef HashBucketNode<V> Node;
typedef Node* PNode;
public:
HashBucket(size_t capacity = 3): _size(0)
{
_ht.resize(GetNextPrime(capacity), nullptr);
}
// 哈希桶中的元素不能重复
PNode* Insert(const V& data)
{
// 确认是否需要扩容...
// _CheckCapacity();
// 1. 计算元素所在的桶号
size_t bucketNo = HashFunc(data);
// 2. 检测该元素是否在桶中
PNode pCur = _ht[bucketNo];
while(pCur)
{
if(pCur->_data == data)
return pCur;
pCur = pCur->_pNext;
}
// 3. 插入新元素
pCur = new Node(data);
pCur->_pNext = _ht[bucketNo];
_ht[bucketNo] = pCur;
_size++;
return pCur;
}
// 删除哈希桶中为data的元素(data不会重复)
bool Erase(const V& data)
{
size_t bucketNo = HashFunc(data);
PNode pCur = _ht[bucketNo];
PNode pPrev = nullptr, pRet = nullptr;
while(pCur)
{
if(pCur->_data == data)
{
if(pCur == _ht[bucketNo])
_ht[bucketNo] = pCur->_pNext;
else
pPrev->_pNext = pCur->_pNext;
delete pCur;
_size--;
return true;
}
}
return false;
}
PNode* Find(const V& data);
size_t Size()const;
bool Empty()const;
void Clear();
bool BucketCount()const;
void Swap(HashBucket<V, HF>& ht;
~HashBucket();
private:
size_t HashFunc(const V& data)
{
return data%_ht.capacity();
}
private:
vector<PNode*> _ht;
size_t _size; // 哈希表中有效元素的个数
};
3. 开散列增容
桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。
void _CheckCapacity()
{
size_t bucketCount = BucketCount();
if(_size == bucketCount)
{
HashBucket<V, HF> newHt(bucketCount);
for(size_t bucketIdx = 0; bucketIdx < bucketCount; ++bucketIdx)
{
PNode pCur = _ht[bucketIdx];
while(pCur)
{
// 将该节点从原哈希表中拆出来
_ht[bucketIdx] = pCur->_pNext;
// 将该节点插入到新哈希表中
size_t bucketNo = newHt.HashFunc(pCur->_data);
pCur->_pNext = newHt._ht[bucketNo];
newHt._ht[bucketNo] = pCur;
pCur = _ht[bucketIdx];
}
}
newHt._size = _size;
this->Swap(newHt);
}
}
4. 开散列的思考
- 只能存储 key 为整形的元素，其他类型如何解决？
// 哈希函数采用处理余数法，被模的key必须要为整形才可以处理，此处提供将key转化为整形的方法
// 整形数据不需要转化
template<class T>
class DefHashF
{
public:
size_t operator()(const T& val)
{
return val;
}
};
// key为字符串类型，需要将其转化为整形
class Str2Int
{
public:
size_t operator()(const string& s)
{
const char* str = s.c_str();
unsigned int seed = 131; // 31 131 1313 13131 131313
unsigned int hash = 0;
while (*str)
{
hash = hash * seed + (*str++);
}
return (hash & 0x7FFFFFFF);
}
};
// 为了实现简单，此哈希表中我们将比较直接与元素绑定在一起
template<class V, class HF>
class HashBucket
{
// ……
private:
size_t HashFunc(const V& data)
{
return HF()(data.first)%_ht.capacity();
}
};
- 除留余数法，最好模一个素数，如何每次快速取一个类似两倍关系的素数？
size_t GetNextPrime(size_t prime)
{
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];
}
5. 开散列与闭散列比较
应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子 a <= 0.7，而表项所占空间又比指针大得多，所以使用链地址法反而比开
👨💻 3. 模拟实现
在前面的章节中，我们已经了解了哈希表的基本原理和两种冲突解决方法（闭散列和开散列）。现在，让我们动手实现一个完整的哈希表，并基于它封装出类似 STL 中 unordered_map 的容器。
🔩 3.1 哈希表的改造
首先，我们需要对前面介绍的开散列哈希桶进行改造，使其能够支持泛型键值对，并适配 unordered_map 的需求。
1. 哈希节点结构改造
// 哈希节点结构
template<class T>
struct HashNode
{
T _data;
HashNode<T>* _next;
HashNode(const T& data)
: _data(data)
, _next(nullptr)
{}
};
2. 哈希表模板参数设计
// 为了实现简单，在哈希桶的迭代器类中需要用到hashBucket本身，
template<class K, class T, class KeyOfT, class HashFunc>
class HashTable;
// 哈希表迭代器
// K:关键码类型
// V: 不同容器V的类型不同，如果是unordered_map，V代表一个键值对，如果是
unordered_set,V 为 K
// KeyOfValue: 因为V的类型不同，通过value取key的方式就不同，详细见
unordered_map/set的实现
// HF: 哈希函数仿函数对象类型，哈希函数使用除留余数法，需要将Key转换为整形数字才能
取模
// 注意：因为哈希桶在底层是单链表结构，所以哈希桶的迭代器不需要--操作
template<class K, class T, class KeyOfT, class HashFunc>
struct __HashIterator
{
typedef HashNode<T> Node;
typedef HashTable<K, T, KeyOfT, HashFunc> HT;
typedef __HashIterator<K, T, KeyOfT, HashFunc> Self;
Node* _node; // 当前迭代器关联的节点
HT* _pht; // 哈希桶--主要是为了找下一个空桶时候方便
__HashIterator(Node* node, HT* pht)
: _node(node)
, _pht(pht)
{}
T& operator*()
{
return _node->_data;
}
T* operator->()
{
return &_node->_data;
}
Self& operator++()
{
if (_node->_next)
{
// 当前桶还有节点
_node = _node->_next;
}
else
{
// 当前桶已遍历完，找下一个桶
KeyOfT kot;
HashFunc hf;
size_t hashi = hf(kot(_node->_data)) % _pht->_tables.size();
++hashi;
// 寻找下一个非空桶
for (; hashi < _pht->_tables.size(); ++hashi)
{
if (_pht->_tables[hashi])
{
_node = _pht->_tables[hashi];
return *this;
}
}
// 后面没有桶了
_node = nullptr;
}
return *this;
}
bool operator!=(const Self& s) const
{
return _node != s._node;
}
bool operator==(const Self& s) const
{
return _node == s._node;
}
};
3. 哈希表主体实现
template<class K, class T, class KeyOfT, class HashFunc>
class HashTable
{
template<class K, class T, class KeyOfT, class HashFunc>
friend struct __HashIterator;
typedef HashNode<T> Node;
public:
typedef __HashIterator<K, T, KeyOfT, HashFunc> iterator;
HashTable()
: _n(0)
{
_tables.resize(__stl_next_prime(0));
}
~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;
}
}
iterator begin()
{
for (size_t i = 0; i < _tables.size(); ++i)
{
if (_tables[i])
{
return iterator(_tables[i], this);
}
}
return end();
}
iterator end()
{
return iterator(nullptr, this);
}
pair<iterator, bool> Insert(const T& data)
{
KeyOfT kot;
// 检查是否需要扩容
if (_n == _tables.size())
{
vector<Node*> newTables;
newTables.resize(__stl_next_prime(_tables.size()), nullptr);
// 遍历旧表，重新哈希到新表
for (size_t i = 0; i < _tables.size(); ++i)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
// 重新计算哈希位置
size_t hashi = HashFunc()(kot(cur->_data)) % newTables.size();
// 头插到新表
cur->_next = newTables[hashi];
newTables[hashi] = cur;
cur = next;
}
_tables[i] = nullptr;
}
_tables.swap(newTables);
}
size_t hashi = HashFunc()(kot(data)) % _tables.size();
// 查找是否已存在
Node* cur = _tables[hashi];
while (cur)
{
if (kot(cur->_data) == kot(data))
{
return make_pair(iterator(cur, this), false);
}
cur = cur->_next;
}
// 头插
Node* newnode = new Node(data);
newnode->_next = _tables[hashi];
_tables[hashi] = newnode;
++_n;
return make_pair(iterator(newnode, this), true);
}
iterator Find(const K& key)
{
if (_tables.size() == 0)
return end();
KeyOfT kot;
size_t hashi = HashFunc()(key) % _tables.size();
Node* cur = _tables[hashi];
while (cur)
{
if (kot(cur->_data) == key)
{
return iterator(cur, this);
}
cur = cur->_next;
}
return end();
}
bool Erase(const K& key)
{
if (_tables.size() == 0)
return false;
KeyOfT kot;
size_t hashi = HashFunc()(key) % _tables.size();
Node* prev = nullptr;
Node* cur = _tables[hashi];
while (cur)
{
if (kot(cur->_data) == key)
{
if (prev == nullptr)
{
// 头节点
_tables[hashi] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
delete cur;
--_n;
return true;
}
prev = cur;
cur = cur->_next;
}
return false;
}
// 获取下一个质数（用于扩容）
inline size_t __stl_next_prime(size_t n)
{
static const size_t __stl_prime_list[] = {
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
};
for (size_t i = 0; i < sizeof(__stl_prime_list) / sizeof(__stl_prime_list[0]); ++i)
{
if (__stl_prime_list[i] > n)
{
return __stl_prime_list[i];
}
}
return __stl_prime_list[sizeof(__stl_prime_list) / sizeof(__stl_prime_list[0]) - 1];
}
private:
vector<Node*> _tables; // 指针数组
size_t _n = 0; // 存储的有效数据个数
};
🗺️ 3.2 unordered_map
基于我们实现的哈希表，现在可以封装出 unordered_map。
1. unordered_map 的实现
// unordered_map中存储的是pair<K, V>的键值对，K为key的类型，V为value的类型，HF哈希
函数类型
// unordered_map在实现时，只需将hashbucket中的接口重新封装即可
template<class K, class V, class Hash = HashFunc<K>>
class unordered_map
{
// 用于从pair中提取key
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
typedef typename HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::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);
}
// 删除
bool erase(const K& key)
{
return _ht.Erase(key);
}
// 查找
iterator find(const K& key)
{
return _ht.Find(key);
}
// 重载[]运算符
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
// 大小
size_t size() const
{
return _ht.Size();
}
// 是否为空
bool empty() const
{
return _ht.Empty();
}
// 清空
void clear()
{
_ht.Clear();
}
private:
HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;
};
2. 哈希函数仿函数
// 默认哈希函数（针对整数类型）
template<class K>
struct HashFunc
{
size_t operator()(const K& key)
{
return key;
}
};
// 针对string类型的特化
template<>
struct HashFunc<string>
{
size_t operator()(const string& s)
{
// BKDR哈希算法
size_t hash = 0;
for (auto ch : s)
{
hash = hash * 131 + ch;
}
return hash;
}
};
3. 使用示例
#include <iostream>
#include <string>
using namespace std;
void TestUnorderedMap()
{
unordered_map<string, string> dict;
// 插入元素
dict.insert(make_pair("sort", "排序"));
dict.insert(make_pair("string", "字符串"));
dict.insert(make_pair("map", "地图"));
// 使用[]插入（如果key不存在则插入，存在则修改value）
dict["left"] = "左边";
dict["right"] = "右边";
dict["string"] = "（字符串）"; // 修改已存在的key
// 遍历
cout << "遍历unordered_map:" << endl;
unordered_map<string, string>::iterator it = dict.begin();
while (it != dict.end())
{
cout << it->first << ":" << it->second << endl;
++it;
}
cout << endl;
// 查找
auto pos = dict.find("map");
if (pos != dict.end())
{
cout << "找到map: " << pos->second << endl;
}
// 删除
dict.erase("left");
cout << "删除left后大小: " << dict.size() << endl;
// 统计水果出现次数
string fruits[] = { "苹果", "香蕉", "苹果", "橙子", "香蕉", "苹果", "葡萄" };
unordered_map<string, int> countMap;
for (auto& fruit : fruits)
{
countMap[fruit]++;
}
cout << "\n水果出现次数统计:" << endl;
for (auto& kv : countMap)
{
cout << kv.first << ":" << kv.second << endl;
}
}
int main()
{
TestUnorderedMap();
return 0;
}
🚀 4. 哈希的应用
🔢 4.1 位图
💡 4.1.1 位图概念
- 面试题
给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在
这40亿个数中。【腾讯】
1. 遍历，时间复杂度O(N)
2. 排序(O(NlogN))，利用二分查找: logN
3. 位图解决
数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一
个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0
代表不存在。比如：
- 位图概念
所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用
来判断某个数据存不存在的。
⚙️ 4.1.2 位图的实现
class bitset
{
public:
bitset(size_t bitCount)
: _bit((bitCount>>5)+1), _bitCount(bitCount)
{}
// 将which比特位置1
void set(size_t which)
{
if(which > _bitCount)
return;
size_t index = (which >> 5);
size_t pos = which % 32;
_bit[index] |= (1 << pos);
}
// 将which比特位置0
void reset(size_t which)
{
if(which > _bitCount)
return;
size_t index = (which >> 5);
size_t pos = which % 32;
_bit[index] &= ~(1<<pos);
}
// 检测位图中which是否为1
bool test(size_t which)
{
if(which > _bitCount)
return false;
size_t index = (which >> 5);
size_t pos = which % 32;
return _bit[index] & (1<<pos);
}
// 获取位图中比特位的总个数
size_t size()const{ return _bitCount;}
// 位图中比特为1的个数
size_t Count()const
{
int bitCnttable[256] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2,
3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3,
3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3,
4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4,
3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5,
6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4,
4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5,
6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5,
3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3,
4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6,
6, 7, 6, 7, 7, 8};
size_t size = _bit.size();
size_t count = 0;
for(size_t i = 0; i < size; ++i)
{
int value = _bit[i];
int j = 0;
while(j < sizeof(_bit[0]))
{
unsigned char c = value;
count += bitCntTable[c];
++j;
value >>= 8;
}
}
return count;
}
private:
vector<int> _bit;
size_t _bitCount;
};
📊 4.1.3 位图的应用
- 快速查找某个数据是否在一个集合中
- 排序 + 去重
- 求两个集合的交集、并集等
- 操作系统中磁盘块标记
🌸 4.2 布隆过滤器
❓ 4.2.1 布隆过滤器提出
我们在使用新闻客户端看新闻时，它会给我们不停地推荐新的内容，它每次推荐时要去重，去掉
那些已经看过的内容。问题来了，新闻客户端推荐系统如何实现推送去重的？ 用服务器记录了用
户看过的所有历史记录，当推荐系统推荐新闻时会从每个用户的历史记录里进行筛选，过滤掉那
些已经存在的记录。 如何快速查找呢？
- 用哈希表存储用户记录，缺点：浪费空间
- 用位图存储用户记录，缺点：位图一般只能处理整形，如果内容编号是字符串，就无法处理
了。 - 将哈希与位图结合，即布隆过滤器
📖 4.2.2 布隆过滤器概念
布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概
率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存
在”，它是用多个哈希函数，将一个数据映射到位图结构中。此种方式不仅可以提升查询效率，也
可以节省大量的内存空间。
https://zhuanlan.zhihu.com/p/43263751/
📥 4.2.3 布隆过滤器的插入
向布隆过滤器中插入：“baidu”
struct BKDRHash
{
size_t operator()(const string& s)
{
// BKDR
size_t value = 0;
for (auto ch : s)
{
value *= 31;
value += ch;
}
return value;
}
};
struct APHash
{
size_t operator()(const string& s)
{
size_t hash = 0;
for (long i = 0; i < s.size(); i++)
{
if ((i & 1) == 0)
{
hash ^= ((hash << 7) ^ s[i] ^ (hash >> 3));
}
else
{
hash ^= (~((hash << 11) ^ s[i] ^ (hash >> 5)));
}
}
return hash;
}
};
struct DJBHash
{
size_t operator()(const string& s)
{
size_t hash = 5381;
for (auto ch : s)
{
hash += (hash << 5) + ch;
}
return hash;
}
};
template<size_t N,
size_t X = 5,
class K = string,
class HashFunc1 = BKDRHash,
class HashFunc2 = APHash,
class HashFunc3 = DJBHash>
class BloomFilter
{
public:
void Set(const K& key)
{
size_t len = X*N;
size_t index1 = HashFunc1()(key) % len;
size_t index2 = HashFunc2()(key) % len;
size_t index3 = HashFunc3()(key) % len;
/* cout << index1 << endl;
cout << index2 << endl;
cout << index3 << endl<<endl;*/
_bs.set(index1);
_bs.set(index2);
_bs.set(index3);
}
bool Test(const K& key)
{
size_t len = X*N;
size_t index1 = HashFunc1()(key) % len;
if (_bs.test(index1) == false)
return false;
size_t index2 = HashFunc2()(key) % len;
if (_bs.test(index2) == false)
return false;
size_t index3 = HashFunc3()(key) % len;
if (_bs.test(index3) == false)
return false;
return true; // 存在误判的
}
// 不支持删除，删除可能会影响其他值。
void Reset(const K& key);
private:
bitset<X*N> _bs;
};
🔎 4.2.4 布隆过滤器的查找
布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特
位一定为1。所以可以按照以下方式进行查找：分别计算每个哈希值对应的比特位置存储的是否为
零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。
注意：布隆过滤器如果说某个元素不存在时，该元素一定不存在，如果该元素存在时，该元素可
能存在，因为有些哈希函数存在一定的误判。
比如：在布隆过滤器中查找"alibaba"时，假设3个哈希函数计算的哈希值为：1、3、7，刚好和其
他元素的比特位重叠，此时布隆过滤器告诉该元素存在，但实该元素是不存在的。
🗑️ 4.2.5 布隆过滤器删除
布隆过滤器不能直接支持删除工作，因为在删除一个元素时，可能会影响其他元素。
比如：删除上图中"tencent"元素，如果直接将该元素所对应的二进制比特位置0，“baidu”元素也
被删除了，因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。
一种支持删除的方法：将布隆过滤器中的每个比特位扩展成一个小的计数器，插入元素时给k个计
数器(k个哈希函数计算出的哈希地址)加一，删除元素时，给k个计数器减一，通过多占用几倍存储
空间的代价来增加删除操作。
缺陷：
- 无法确认元素是否真正在布隆过滤器中
- 存在计数回绕
✅ 4.2.6 布隆过滤器优点
- 增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无
关 - 哈希函数相互之间没有关系，方便硬件并行运算
- 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势
- 在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势
- 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能
- 使用同一组散列函数的布隆过滤器可以进行交、并、差运算
⚠️ 4.2.7 布隆过滤器缺陷
- 有误判率，即存在假阳性(False Position)，即不能准确判断元素是否在集合中(补救方法：再
建立一个白名单，存储可能会误判的数据) - 不能获取元素本身
- 一般情况下不能从布隆过滤器中删除元素
- 如果采用计数方式删除，可能会存在计数回绕问题
🧠 5. 海量数据处理面试题
5.1 哈希切割
给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？
与上题条件相同，如何找到top K的IP？如何直接用Linux系统命令实现？
5.2 位图应用
- 给定100亿个整数，设计算法找到只出现一次的整数？
- 给两个文件，分别有100亿个整数，我们只有1G内存，如何找到两个文件交集？
- 位图应用变形：1个文件有100亿个int，1G内存，设计算法找到出现次数不超过2次的所有整
数
5.3 布隆过滤器
- 给两个文件，分别有100亿个query，我们只有1G内存，如何找到两个文件交集？分别给出
精确算法和近似算法 - 如何扩展BloomFilter使得它支持删除元素的操作
更多推荐
9
0- 0
已为社区贡献20条内容
所有评论(0)