数据结构专题 -- 哈希思想详解
代码会存放在:
https://github.com/sjmshsh/Data-Struct-HandWriting
通过阅读本篇文章,你可以学到:
- 哈希思想及其本质
- 使用C++实现简易的哈希表
- 哈希思想的应用
- 位图
- 布隆过滤器
- 哈希切分
- 极致升华,海量数据处理面试题
- 拓展 – 一致性哈希算法
- 用Golang实现简易的一致性哈希算法
哈希的本质我认为是以空间换取时间。牺牲空间以换取时间复杂度为O(1),哈希的用途很广泛,例如Redis,C++的STL,Java的集合,Go的map等等都用到了哈希,他们的原理虽然略有区别,但是基本上相同,所以我们只要理解了这个思想,就可以以分钟为单位的去学习其他地方的哈希。
哈希概念
其实增删查改(CRUD)一直是一个很大的话题,为何要增删查改,增删查改本质上是一种管理方式,就好比操作系统中,操作系统是一个管理员,管理员需要先描述再组织,描述就是把相关的数据抽象成一个结构体,或者说类对象。组织就是对这些结构体或者类对象使用某种方式管理起来。数据的管理方式有很多,常见的数据结构有:链表,栈,堆,红黑树,AVL树,B/B+树等等,当然,还有我们的哈希。
顺序结构以及平衡树中,元素关键码与其存储位置之间没有对应的关系,因此在查找一个元素时,必须要经过关键码的多次比较。顺序查找时间复杂度为O(N),平衡树中为树的高度,即O(logN),搜索的效率取决
于搜索过程中元素的比较次数。
理想的搜索方法:可以不经过任何比较,一次直接从表中得到要搜索的元素。 如果构造一种存储结构,通过某种函数hashFunc使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么在查找时通过该函数可以很快找到该元素。
所以哈希的本质其实是简历映射关系的过程,映射的建立是需要花费空间的,但是它带来的O(1)的时间复杂度。
插入元素
根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放。
搜索元素
对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若关键码相等,则搜索成功。
该方式即为哈希(散列)方法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(Hash Table)(或者称散列表)。
现在可能还是很迷,但是举一个例子就好了。
例如:数据集合{1,7,6,4,5,9};
哈希函数设置为:hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
好,那么我们现在再次插入44这个元素,可以发现,我的位置已经被占了,这就是所谓的哈希冲突问题。
哈希冲突
对不同的关键字可能得到同一散列地址,即[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2mcgJXBA-1673943600773)(null)],而{[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ChcppzIi-1673943601177)(null)],这种现象称为冲突(英语:Collision)。
– 来自《维基百科》
哈希冲突是否可以避免?
答:哈希冲突是不可能避免的,只能尽量的减小哈希冲突的概率,因为在算哈希值的时候,我们使用某种算法进行计算,难免会遇到计算的哈希值是相同的情况。
哈希冲突会带来什么影响?
答:当冲突到达一定的程度的时候,哈希表的效率会显著的降低,具体原因后续再讲。
如何尽可能的规避哈希冲突?
答:引起哈希冲突的一个很重要的原因就是:哈希函数的设计不合理。一个优秀的哈希函数应该满足以下几个条件:
- 哈希函数的定义域必须包括需要存储的全部关键码,而如果散列表允许有m个地址时,其值域必须在0到m-1之间
- 哈希函数计算出来的地址能均匀分布在整个空间中
- 哈希函数应该比较简单,如果很复杂的话,那么计算成本也是很高的
因此我们这个时候来介绍一下哈希函数。
哈希函数
这里跳过,可以去网上查一下,数学问题。我们到时候模拟实现采用的是除留余数法。
除留余数法–(常用)
设散列表中允许的地址数为m,取一个不大于m,但最接近或者等于m的质数p作为除数,按照哈希函数:Hash(key) = key% p(p<=m)
,将关键码转换成哈希地址哈希函数设计的越精妙,产生哈希冲突的可能性就比较低,但是无法避免,那么我们如果真的遇到了哈希冲突,应该怎么解决呢?
哈希冲突解决
解决哈希冲突的两种常见方法是:闭散列和开散列
闭散列
闭散列:也叫开放定址法,当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有空位置,那
么可以把key存放到冲突位置中的下一个空位置中去。那如何寻找下一个空位置呢?
线性探测
线性探测:从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位为止。
插入
- 通过哈希函数获取待插入元素在哈希表中的位置
- 如何该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突,使用线性探测找到下一个空位置插入新元素。
删除
采用闭散列处理哈希冲突时,不能随便物理删除哈希表中的已有元素,若直接删除元素会影响其他元素的搜索。例如删除了元素4,那么我的44其实就找不到了。因为我们应该使用伪删除法来删除一个元素。
enum Status{EXIST, // 位置已经有元素EMPTY, // 位置为空DELETE // 删除};
线性探测的实现
先给出几个需要注意的点:
注意我的取模不能模容量,要模大小
size_t i = kv.first % _tables.size();// 不能取模capacity// size_t i = kv.first % _tables.capacity();
原因是如果你模容量的话可能会出现内存访问越界的问题。
思考哈希表什么情况下进行扩容?如何扩容?
首先回答一个问题,为什么要进行扩容?原因很简答
- 数据量太多了,哈希表放不下了
- 你可以想象一下,在同一片空间下,数据越来越多,是不是发生哈希冲突的概率会越来越大,那么再向一下线性探测的过程,如果哈希冲突很严重的话,就相当于遍历了,哈希表效率严重下降。
那么什么时候进行扩容呢?
散列表的载荷因子定义为:α = 填入表中的元素个数 / 散列表的长。度[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传α是散列表装满程度的标志因子。由于表长是定值,[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传α与“填入表中的元素个数”成正比,所以,α越大,表明填入表中的元素越多,产生冲突的可能性就越大;反之,α越小,标明填入表中的元素越少,产生冲突的可能性就越小。实际上,散列表的平均查找长度是载荷因子[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传α的函数,只是不同处理冲突的方法有不同的函数。
对于开放定址法,荷载因子是特别重要因素,应严格限制在0.7-0.8以下。超过0.8,查表时的CPU缓存不命中(cache missing)按照指数曲线上升。因此,一些采用开放定址法的hash库,如Java的系统库限制了荷载因子为0.75,超过此值将resize散列表。
#pragma once
#include <vector>
#include <string>using namespace std;template<class K>
struct Hash
{size_t operator() (const K& key){return key;}
};// 如果K是stribg类型会走这个特化版本
template<>
struct Hash<string>
{size_t operator() (const string& s){// BKDRsize_t value = 0;for (auto ch : s){value *= 31;value += ch;}return value;}
};namespace CloseHash
{enum Status{EXIST,EMPTY,DELETE};template<class K, class V>struct HashData{pair<K, V> _kv;Status _status = EMPTY;};template<class K, class V, class HashFunc = Hash<K>>class HashTable{public:bool Erase(const K& key){HashData<K, V>* ret = Find(key);if (ret == nullptr){// 没有找到说明没有这个数据,当然是不能删除的return false;}else{--_n;ret->_status = DELETE;return true;}}HashData<K, V>* Find(const K& key){if (_tables.size() == 0){return nullptr;}HashFunc hf;size_t start = hf(key) % _tables.size();size_t i = 0;size_t index = start;// 线性探测 or 二次探测while (_tables[index]._status != EMPTY){if (_tables[index]._kv.first == key && _tables[index]._status == EXIST){return &_tables[index];}i++;index = start + i;index %= _tables.size();}return nullptr;}bool Insert(const pair<K, V>& kv){HashData<K, V>* ret = Find(kv.first);if (ret){return false;}// 负载因子到0.7// 负载因子越小,冲突概率就越小,效率越高,空间浪费越多if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7){// 扩容size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;//vector<HashData<K, V>> newTables;//newTables.resize(newSize); 遍历原表,把原表中的数据重新按newSize映射到新表//for (size_t i = 0; i < _tables.size(); i++)//{// // //} 交换内存并把以前的内存销毁//_tables.swap(newTables);HashTable<K, V> newHT;newHT._tables.resize(newSize);for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._status == EXIST){newHT.Insert(_tables[i]._kv);}}_tables.swap(newHT._tables);}HashFunc hf;size_t start = hf(kv.first) % _tables.size();size_t i = 0;size_t index = start;// 不能取模capacity// size_t i = kv.first % _tables.capacity();// 线性探测while (_tables[index]._status == EXIST){i++;index = start + i * i;index %= _tables.size();}_tables[index]._kv = kv;_tables[index]._status = EXIST;++_n;return true;}private:vector<HashData<K, V>> _tables;size_t _n; // 有效数据的个数};struct Date{public:int a = 1;};struct HashDate{size_t operator() (const Date* d){// ...}};void TestHashTable1(){HashTable<string, int> ht;ht.Insert(make_pair("lxy", 12));cout << ht.Find("lxy") << endl;ht.Erase("lxy");cout << ht.Find("lxy") << endl;// 当key是一个定义类型时,需要配置这个仿函数,将key转换成整形HashTable<Date, string, HashDate> htds;}
}
线性探测其实缺点很大,一旦发生哈希冲突,所有的冲突连在一起,容易产生数据堆积。因此我们可以进行一次优化,使用二次探测。
二次探测
线性探测是每次遇到重复的就找下一个位置,而二次探测就是遇到重复的话,就跳过一段距离,避免数据的堆积。
线性探测的缺陷是产生冲突的数据堆积在一块,这与其找下一个空位置有关系,因为找空位置的方式就
是挨着往后逐个去找,因此二次探测为了避免该问题,找下一个空位置的方法为: Hi = (H0 + i^2) % m
。其中:i = 1,2,3…,是通过散列函数Hash(x)对元素的关键码key进行计算得到的位置,m是表的大小。如果要插入44,产生冲突,使用解决后的情况为:
但是二次探测也有很大的缺点,就是每次跳跃平方的话,在负载因子到达一定程度的时候,你可能跳几万次都跳不到空位,因此如果是二次探测的话要严格控制负载因子。
研究表明甚至要到达0.5。对空间的浪费是很大的。于是我们有了一个更好的解决方案,也就是开散列。
顺便放一个代码,我们只需要改一个地方就可以了,就是扩容的时候控制一下即可。
开散列
开散列法又叫链地址法(开链法),首先对关键码集合用散列函数计算散列地址,具有相同地址的关键码归于同一子集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链接起来,各链表的头结点存储在哈希表中。
这个位置我们可以称作是哈希桶,每一个哈希桶里面存放的是发生了哈希冲突的元素。
极端场景是一个哈希桶内冲突的元素太多了,链表太长,因此,当一个桶长度超过一定的值之后,由链表转换为红黑树,代码实现就链表吧,红黑树太难了。
关于开散列的负载因子,实际上是1,也就是每一次插入的时候都会发生哈希冲突的时候再扩容比较好。因为它不会像闭散列一样发生堆积。
扩容的代价是很大的,所以能少扩容,负载因子就尽量大一点,要做权衡。如果数据量大到离谱,例如一个亿,每次扩容都可能会造成一定的性能抖动。
那么关于字符串放入哈希表,使用字符串哈希算法就可以了,在网上搜几个就可以。然后C++使用仿函数实现即可。
还有一个需要注意的点就是:研究表明,我们每次最好模一个素数,这样可以减小哈希冲突的概率。
因此使用素数表的方法来实现,STL也是这么做的。
代码实现
namespace LinkHash
{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 HashFunc = Hash<K>>class HashTable{typedef HashNode<K, V> Node;public:bool Erase(const K& key){if (_tables.empty()){return false;}HashFunc hf;size_t index = hf(key) % _tables.size();Node* cur = _tables[index];Node* prev = nullptr;while (cur){if (cur->_kv.first == key){if (prev == nullptr){// 头删_tables[index] = cur->_next;}else{// 中间的地方进行删除prev->_next = cur->_next;}--_n;delete cur;return true;}else{prev = cur;}}}size_t GetNextPrime(size_t num){static const unsigned long __stl_prime_list[28] = {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 < 28; i++){if (__stl_prime_list[i] > num){return __stl_prime_list[i];}}return __stl_prime_list[27];}Node* Find(const K& key){if (_tables.empty()){return nullptr;}HashFunc hf;size_t index = hf(key) % _tables.size();Node* cur = _tables[index];while (cur){if (cur->_kv.first == key){return cur;}else{cur = cur->_next;}}return nullptr;}bool Insert(const pair<K, V>& kv){Node* ret = Find(kv.first);if (ret){return false;}// 负载因子 == 1 时扩容if (_n == _tables.size()){size_t newSize = GetNextPrime(_tables.size());vector<Node*> newTables;newTables.resize(newSize);for (size_t i = 0; i < _tables.size(); i++){HashFunc hf;Node* cur = _tables[i];while (cur){Node* next = cur->_next;size_t index = hf(cur->_kv.first) % newTables.size();// 头插cur->_next = newTables[index];cur = next;}_tables[i] = nullptr;}newTables.swap(_tables);}HashFunc hf;size_t index = hf(kv.first) % _tables.size();Node* newnode = new Node(kv);// 头插newnode->_next = _tables[index];_tables[index] = newnode;++_n;return true;}private://struct Data//{// forward_list<T> _list;// set<T> _rbtree;// size_t _len;//};// 这里就不考虑极端场景了vector<Node*> _tables;size_t _n; // 有效数据的个数};void TestHashTable(){int a[] = { 4, 24, 14, 7,37,37,57,67,34,14,54 };HashTable<int, int> ht;for (auto e : a){ht.Insert(make_pair(e, e));}}
}
哈希的应用
位图
海量数据处理面试题1
我们从一道面试题来引入位图:
给40亿个不重复的无符号整数,没排过序。给一个无符号整数,如何快速判断一个数是否在这40亿个数
中。【腾讯】
- 首先分析题目,我的脑子里面的第一想法是遍历,时间复杂度O(N),然后进行优化,先排序,时间复杂度O(NlogN),然后利用二分查找:logN。d
- 仔细一想,哎,40亿个数字,内存放不下哎,只能用其他的方式。
这里可以使用位图。
位图就是用每一个比特位来存放某种状态,适用于海量数据,数据无重复的场景,通常是用来判断数据是否存在的。
#pragma once#include <vector>using namespace std;namespace bit
{template<size_t N>class bit_set{public:bit_set(){_bits.resize(N / 8 + 1);}// 设置为1void set(size_t x){// 这个i算的是它在第几个char里面size_t i = x / 8;// 这个j算的是它是第几个位size_t j = x % 8;_bits[i] |= (1 << j);}// 清理为0void reset(size_t x){size_t i = x / 8;size_t j = x % 8; _bits[i] &= (~(1 << j));}// 探测这个位是否是1bool test(size_t x){size_t i = x / 8;size_t j = x % 8;return _bits[i] & (1 << j);}private:vector<char> _bits;// vector<int> _bits;};void test_bit_set(){bit_set<0xffffffff> bs;}
}
海量数据处理面试题2
给定100亿个整数,设计算法找到只出现一次的整数。
首先分析一下题目:
数字出现的频率可以分为三种情况:
- 出现0次
- 出现1次
- 出现2次以及以上
思路是:改造位图结构,以前是一个比特位标识一个值,现在改成两个比特位标识一个值。
定义两个比特位图:
bit_set<N> _bs1;
bit_set<N> _bs2;
这两个比特位图可以标识以下几种状态:
- 00 数字出现了0次
- 01 数字出现了1次
- 10 数字出现了2次
- 11 数字出现了3次
这样用两个比特位图就可以找到只出现一次的整数了。
#pragma once#include <vector>using namespace std;namespace bit
{template<size_t N>class bit_set{public:bit_set(){_bits.resize(N / 8 + 1);}// 设置为1void set(size_t x){// 这个i算的是它在第几个char里面size_t i = x / 8;// 这个j算的是它是第几个位size_t j = x % 8;_bits[i] |= (1 << j);}// 清理为0void reset(size_t x){size_t i = x / 8;size_t j = x % 8; _bits[i] &= (~(1 << j));}// 探测这个位是否是1bool test(size_t x){size_t i = x / 8;size_t j = x % 8;return _bits[i] & (1 << j);}private:vector<char> _bits;// vector<int> _bits;};template<size_t N>class TwoBitSet{public:void Set(size_t x){if (!_bs1.test(x) && !_bs2.test(x)) // 00 -> 01{_bs2.set(x);}else if (!_bs1.test(x) && _bs2.test(x)) // 01 -> 10{_bs1.set(x);_bs2.reset(x);}// 11 表示以及出现2次或者以上,不用处理 }void PrintOnceNum(){for (size_t i = 0; i < N; i++){if (!_bs1.test(i) && _bs2.test(i)) // 01{cout << i << endl;}}}private:// 然后设置的到bs1,一旦设置到bs1就已经说明完成了两次了bit_set<N> _bs1;// 第一次设置到bs2bit_set<N> _bs2;};void test_bit_set(){bit_set<0xffffffff> bs;}void TestTwoBitSet(){int a[] = { 99,0,4,50,33,44,2,5,99,0,50,99,50,2 };TwoBitSet<100> bs;for (auto e : a){bs.Set(e);}bs.PrintOnceNum();}
}
海量数据处理面试题3
给两个文件,分别有100亿个整数,我们只有1G内存,如何找到两个文件的交集?
思路1:把一个文件中的整数set到一个比特位图,读取第二个文件中的整数判断在不在位图。在就是交际,不在就不是交集。
这个思路看起来可以,但是实际上有一个很大的缺点:
int a1[] = {5, 30, 1, 99, 10};
int a2[] = {8, 10, 11, 9, 30, 10, 30};
8不在。10在。11不在。9不在。30在。10在。30在。最终结果。
10 30 10 30
还要加入到set进行去重。可行,但是还是不完美。
思路2:把文件set到一个位图,然后同时再set到另外一个位图,然后把两个位图相与,与完是1的就是交集。
海量数据处理面试题4
1个文件有100亿个int,1G内存,设计算法找到出现次数不能超过2次的所有整数。
两个位图即可,跟第二题差不多。
总结一下
- 快速查找某一个数据是否在一个集合中
- 排序
- 求两个集合的交集,并集
- 操作系统中磁盘块标记
- 。。。。
布隆过滤器
布隆过滤器的提出
我们在使用新闻客户端看新闻时,它会给我们不停地推荐新的内容,它每次推荐时要去重,去掉那些已经看
过的内容。问题来了,新闻客户端推荐系统如何实现推送去重的? 用服务器记录了用户看过的所有历史记
录,当推荐系统推荐新闻时会从每个用户的历史记录里进行筛选,过滤掉那些已经存在的记录。 如何快速查
找呢?(Tips:推荐系统是可以有容错性的,所以这是一种解决方案)
- 用哈希表存储用户记录,缺点:浪费空间
- 用位图存储用户记录,缺点:不能处理哈希冲突
- 将哈希与位图结合,即布隆过滤器
特点
一句话解决:
本质上布隆过滤器是一种数据结构,比较巧妙的概率型数据结构(probabilistic data structure),特点是高效地插入和查询,可以用来告诉你 “某样东西一定不存在或者可能存在”。
布隆过滤器是可以过滤字符串的,首先我们使用字符串哈希算法把字符串转换成一个整数。
然后把这个整数映射到比特位图里面,其实这就是布隆过滤器。
如果比特位是0的话,那么说明这个位置对应的字符串一定不存在,如果比特位是1的话,代码可能存在,因为我们前面已经了解到了,哈希冲突是无法避免的。
既然无法避免,我们就需要去尽可能规避。
- 首先选择优秀的字符串哈希函数
- 其次,使用多个字符串哈希函数,同时进行映射,减少冲突的概率。
- 开的空间尽可能提升,负载因子尽可能小
例如这里是3个哈希函数的例子。
插入
算3个哈希插入。
查找
如果我找到了有一个比特位为0,那么我可以百分百说没有这个字符串。如果我找到了3个比特位都是1。那么这个值因为哈希冲突的原因可能不存在,就是这么一个道理。
删除
不能支持删除工作,因为在删除一个元素的时候,可能会影响其他元素。
比如:删除上图中"tencent"元素,如果直接将该元素所对应的二进制比特位置0,“baidu”元素也被删除了,
因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。
一种支持删除的方法:将布隆过滤器中的每个比特位扩展成一个小的计数器,插入元素时给k个计数器(k个哈
希函数计算出的哈希地址)加一,删除元素时,给k个计数器减一,通过多占用几倍存储空间的代价来增加删
除操作。这相当于是引用计数吧。但是存在计数回绕问题。所以这个计数器取多少,是一个玄学问题。
代码实现
#pragma once#include <bitset>
#include <string>
#include <time.h>struct BKDRHash
{size_t operator()(const string& s){// BKDRsize_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 = 8,// 这个X越大,空间分配越多,但是于此同时误判率是越低的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;cout << len << endl;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;
};void TestBloomFilter1()
{BloomFilter<100> bits;bits.Set("我的名字是李鑫阳");
}void TestBloomFilter2()
{/*BloomFilter<100> bf;bf.Set("张三");bf.Set("李四");bf.Set("牛魔王");bf.Set("红孩儿");bf.Set("eat");cout << bf.Test("张三") << endl;cout << bf.Test("李四") << endl;cout << bf.Test("牛魔王") << endl;cout << bf.Test("红孩儿") << endl;cout << bf.Test("孙悟空") << endl;cout << bf.Test("二郎神") << endl;cout << bf.Test("猪八戒") << endl;cout << bf.Test("ate") << endl;*/BloomFilter<100> bf;srand(time(0));size_t N = 100;std::vector<std::string> v1;for (size_t i = 0; i < N; ++i){std::string url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";url += std::to_string(1234 + i);v1.push_back(url);}for (auto& str : v1){bf.Set(str);}for (auto& str : v1){cout << bf.Test(str) << endl;}cout << endl << endl;std::vector<std::string> v2;for (size_t i = 0; i < N; ++i){std::string url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";url += std::to_string(6789 + i);v2.push_back(url);}size_t n2 = 0;for (auto& str : v2){if (bf.Test(str)){++n2;}}cout << "相似字符串误判率:" << (double)n2 / (double)N << endl;std::vector<std::string> v3;for (size_t i = 0; i < N; ++i){// string url = "zhihu.com";//std::string url = "https://www.baidu.com/s?wd=ln2&rsv_spt=1&rsv_iqid=0xc1c7784f000040b1&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&tn=baiduhome_pg&rsv_dl=tb&rsv_enter=1&rsv_sug3=8&rsv_sug1=7&rsv_sug7=100&rsv_sug2=0&rsv_btype=i&prefixsug=ln2&rsp=5&inputT=4576&rsv_sug4=5211";//std::string url = "https://zhidao.baidu.com/question/1945717405689377028.html?fr=iks&word=ln2&ie=gbk&dyTabStr=MCw0LDMsMiw2LDEsNSw3LDgsOQ==";std::string url = "https://www.cnblogs.com/-clq/archive/2012/01/31/2333247.html";url += std::to_string(rand());v3.push_back(url);}size_t n3 = 0;for (auto& str : v3){if (bf.Test(str)){++n3;}}cout << "不相似字符串误判率:" << (double)n3 / (double)N << endl;}
应用场景
- 规避缓存击穿
- 垃圾邮件判断
- 。。。数据量大,节约空间,允许误判等场景
海量数据面试题5
给两个文件,分别有100亿个query,我们只有1G内存,如何找到两个文件交集?分别给出精确算法和近似算法
近似算法使用布隆过滤器即可。但是存在误判。
如果要给出精确算法的话,那么我们就得使用哈希切分思想了。
哈希切分
首先分析一下内存,1个G内存,1个query大概10字节。100亿个query大概100G左右。那么我们切分成200个小文件即可。
我们把两个文件命名为A号文件和B号文件。
首先在A号文件中读取query,i = BKRDHash(query) % 200
。这个quert就进入Ai号小文件。B同理。
我们有结论:**A和B中相同的query一定进入编号相同的小文件。**这是由哈希的性质决定的,因为哈希一样的query计算出来的i是相同的。
所以我们查找的时候只需要把Ai号和Bi号文件加载进入内存,然后查找就可以了,相同的query必定是相同的字符串里面。
海量数据面试题6
给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址? 与上题条件相同,如何找到top K的IP?如何直接用Linux系统命令实现?
答:使用哈希切分,这样相同IP的一定进入相同文件,然后使用小根堆来以O(logN)来统计出现次数最多的IP地址。
步骤如下:
- Hash分桶法:
- 将100G文件分成1000份,将每个IP地址映射到相应文件中:file_id = hash(ip) % 1000
- 在每个文件中分别求出最高频的IP,再合并 Hash分桶法:
- 使用Hash分桶法把数据分发到不同文件
- 各个文件分别统计top K
- 最后Top K汇总
- Linux命令,假设top 10:
sort log_file | uniq -c | sort -nr k1,1 | head -10
拓展:一致性哈希算法
我写过博客,可以看一看:
https://blog.csdn.net/qq_61039408/article/details/128697332?spm=1001.2014.3001.5501
数据结构专题 -- 哈希思想详解相关推荐
- 【数据结构】哈希表详解以及代码实现
目录 1.来源: 2.哈希函数 1.哈希函数的设计规则 2.哈希函数的设计思路 3.哈希碰撞 4.解决哈希碰撞的方案 5.负载因子 3.基于开散列方案的HashMap实现 1.HashMap类中的属性 ...
- 【数据结构】 哈希表 详解
目录 1. 概念 引入 2. 冲突 2.1 概念 2.2 避免 2.3 冲突-避免-哈希函数设计 2.4 冲突-避免-负载因子调节(重点) 2.5 冲突-解决 2.5.1 闭散列 2.6 冲突-解决- ...
- 【卷积神经网络结构专题】一文详解AlexNet(附代码实现)
关注上方"深度学习技术前沿",选择"星标公众号", 资源干货,第一时间送达! [导读]本文是卷积神经网络结构系列专题第二篇文章,前面我们已经介绍了第一个真正意义 ...
- 用DFS 解决全排列问题的思想详解
用DFS 解决全排列问题的思想详解 参考文章: (1)用DFS 解决全排列问题的思想详解 (2)https://www.cnblogs.com/curo0119/p/8414195.html 备忘一下 ...
- 数据结构与算法之时间复杂度详解
数据结构与算法之时间复杂度详解 目录 排序算法的介绍和分类 算法的时间复杂度概念 常见的时间复杂度解析 平均时间复杂度和最坏时间复杂度 空间复杂度介绍 1. 排序算法的介绍和分类 排序算法的介绍 排序 ...
- 数据结构殷人昆电子版百度云资源_数据结构精讲与习题详解(C语言版第2版清华大学计算机系列教材)...
导语 内容提要 殷人昆编著的<数据结构精讲与习题详解(C语言版第2版清华大学计算机系列教材)>是清华大学出版社出版的<数据结构(C语言版)>(第2版)的配套教材,对" ...
- (7)Java数据结构--集合map,set,list详解
MAP,SET,LIST,等JAVA中集合解析(了解) - clam_clam的专栏 - CSDN博---有颜色, http://blog.csdn.net/clam_clam/article/det ...
- dataframe drop_Pandas数据结构Series和DataFrame基础详解
作者:Zarten知乎专栏:python数据分析与挖掘深入详解知乎ID: Zarten简介: 互联网一线工作者,尊重原创并欢迎评论留言指出不足之处,也希望多些关注和点赞是给作者最好的鼓励 ! 概述 p ...
- c++数据结构中 顺序队列的队首队尾_数据结构与算法—队列图文详解
前言 栈和队列是一对好兄弟,前面我们介绍过数据结构与算法-栈详解,那么栈的机制相对简单,后入先出,就像进入一个狭小的山洞,山洞只有一个出口,只能后进先出(在外面的先出去).而队列就好比是一个隧道,后面 ...
最新文章
- graphpad做折线图坐标轴数字_多组数据制作折线图,四步让你的图表实用又美观,老板看了都说好...
- 想知道你在网上的发言,被怎么分析么?
- Error: cmd: Command failed with exit code ENOENT
- 考勤助手——数据库3.0版本
- 3150 Pibonacci数 - Wikioi
- MassTransit Get Started-
- 如何开发 Servlet 程序
- 一文教你掌握 ZooKeeper 核心知识
- FreeSql (二)自动迁移实体
- Openstack入门篇(十一)之neutron服务(控制节点)的部署与测试
- java webservice ssl_[转贴]Java客户端调用Https Webservice
- 心痛!你的快递可能已经被烧毁,13吨快递“无一生还”
- Check_ping监控测试原理
- zookeeper leader选举过程
- IGS精密星历及其下载(自PureSky_Memory的博客)
- 【学习笔记】Creo如何创建钣金件(利用骨架)
- 信道估计之LMMSE估计
- 你不知道的JavaScript(上卷)- - 书本知识点记录
- 中南大学计算机学院王瑞,中南大学优秀毕业生.xls
- 离散数学常用符号TeX输入
热门文章
- python 的代码格式_python代码格式
- UE5导入自定义MetaHuman虚拟人和服装并联动
- QQ空间里面的照片变模糊了怎么办?时间越久越模糊怎么修复清晰?
- element el-table(:render-header)实现动态表头的自适应
- 笔记本安装TIA博途V17后出现蓝屏的解决办法
- 1秒内通关扫雷?他创造属于自己的世界记录!Python实现自动扫雷
- linux切换桌面环境bug,LinuxMint 17.1 Cinnamon桌面窗口焦点bug
- 完美日记母公司逸仙电商招股书:重营销、轻研发,前三季度亏11亿
- aviator教程-表达式执行引擎
- 秘密secret社群价值