本期我们来学习位图，布隆过滤器等相关知识，以及模拟实现，需求前置知识
目录
位图
我们先来看一道面试题
给 40 亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这 40 亿个数中。【腾讯】
这是一个查找在不在的问题，我们该如何解决呢？使用set可以吗？排序+二分查找可以吗？
如果但从效率来看，它们都是longN，但是都不行，40亿整数是160亿字节，换算下来大约是16G左右，内存是不会给我们开16G的，如果用set更恐怖，除了存整形，还要存各种附带的东西，left，right，parent，颜色等等，红黑树，哈希表这些都是有附带消耗的
这是一个在不在的问题，所以我们可以用0和1来表示存在，所以这里可以用比特位来标记，我们开2^32个比特位进行标记，这里和哈希的直接定址法一样，我们这里是开范围，而且2^32比特位是0.5G左右
此时我们来写需要的结构，我们用vector来实现，但是此时又有一个问题，什么类型的大小是一个比特位？没有，但是我们仔细回忆的话，位运算和位段都是可以实现一个比特位的
我们这里要实现两个接口，一个set一个reset，分别是将x映射的位置标记为1和0
一个int是32个比特位，假设此时x=80，我们首先要计算出x在第几个整形的位置，我们用x/32即可，在该整形的第几个位上面，我们可以用x%32，我们带入计算一下，80/32是2，刚好在第二个整形（从第0个开始），再用80%32是16，64+16是80，所以位置刚好是下标
这里还有一个问题，我们的机器其实是小端机
也就是说在内存中其实是这样的
比如我们这里存了一个1，在内存中的存储就是这样的
//x映射的位置标记位1
void set(size_t x)
{
size_t i = x / 32;
size_t j = x % 32;
_a[i] |= (1<<j);
}
//x映射的位置标记位0
void reset(size_t x)
{
size_t i = x / 32;
size_t j = x % 32;
_a[i] &= (~(1 << j));
}我们实现这两个函数，使用位运算就可以巧妙的解决问题
set我们让它的那个位置 | 上1，reset我们让那个位置&上~1（这里1用来移位，所以没有&0）
接下来我们要判断某个位置是0还是1
bool test(size_t x)
{
size_t i = x / 32;
size_t j = x % 32;
return _a[i] & (1 << j);
}我们&1即可，如果是0，返回则为假，是1返回真，注意这里是&，不是&=
我们再加上构造函数，开一下空间，这里向上取整
接着我们测试一下，没有问题
下面我们要来完成面试题，首先我们要开42亿的空间（不是40亿，题目说的是40亿个不重复，有可能比40亿大）
我们在这里写INT_MAX可以吗？不行，INT_MAX是21亿多
我们应该用这个，无符号的最大值
或者用更简单的办法，写个-1即可，因为这里是无符号，-1的补码是全1
手动写16进制也可以
另外位图在库里面也是有的
有各种接口，我们记住test，set和reset即可，其他的基本用不到
我们来看一些位图的应用
1. 给定 100 亿个整数，设计算法找到只出现一次的整数？2. 给两个文件，分别有 100 亿个整数，我们只有 1G 内存，如何找到两个文件交集？3. 位图应用变形： 1 个文件有 100 亿个 int ， 1G 内存，设计算法找到出现次数不超过 2 次的所有整数
我们看第一个，100亿个整数，只出现一次
我们之前用1个位标记在不在，现在我们可以用2个位来表示状态，2个位可以表示出4种状态，我们用3种即可，00表示不在，01表示出现一次，10出现2次及以上，我们把位图改造一下即可解决
还有更省力的方法，我们用bitset来完成
开两个位图，第一个的第一位和第二个的第一位结合起来就是一个数的状态，依次类推
为了方便我们先把之前的myset改名和库里面一样的bitset
template<size_t N>
class twobitset
{
public:
void set(size_t x)
{
//00 -> 01
if (!_bs1.test(x) && !_bs2.test(x))
{
_bs2.set(x);
}//01 -> 10
else if(!_bs1.test(x) && _bs2.test(x))
{
_bs1.set(x);
_bs2.reset(x);
}
// 本身是10代表出现2次及以上，就不变
}
bool is_once(size_t x)
{
return !_bs1.test(x) && _bs2.test(x);
}
private:
bitset<N> _bs1;
bitset<N> _bs2;
};我们实现一个towbitset，实现一个set接口，对于出现的数字，如果00就变为01，01就变为10，10不用变，然后提供一个isonce，判断出现一次的数
我们简单测试一下，没有问题
下面再看第二个问题，找两个文件的交集
我们把一个文件的所有值映射到位图，然后另一个文件来判断在不在可以吗？
可以，但是会有一些问题，比如第一个文件里有一个3，第二个文件里有3个3，那么这里得到的结果也是3个3，是需要进行去重的
我们来看更好的方法
我们把两个文件分别映射到两个位图，存在为1，不存在为0，然后对应的位置&一下即可，或者对应位置都为1的就是交集
比如这样写
我们再看第三个问题
不超过2次就是1次和2次，我们还是用2个位来表示，00表示0次，01表示1次，10表示2次，11表示2次以上，解决思路类似问题1
布隆过滤器
刚才的问题都是数字，如果是string呢？比如文件1和文件2找交集，里面都是字符串，比如“语文“，”数学“，”英语“这些
我们把这些字符串计算成对应成整形，映射到位图里，然后按刚才的思路走就行了，不过这样写会有一些问题，就是冲突，比如还有一个字符串”物理“，它和语文计算出的整形是一样的，映射到了同一个位置，是会受到影响的，就存在误判了
那有什么办法可以解决这个问题吗？
答案是不能，冲突是无法避免的，但是我们可以减少冲突
布隆过滤器是 由布隆（ Burton Howard Bloom ）在 1970 年提出的 一种紧凑型的、比较巧妙的 概 率型数据结构 ，特点是 高效地插入和查询，可以用来告诉你 “ 某样东西一定不存在或者可能存 在 ” ，它是用多个哈希函数，将一个数据映射到位图结构中。此种方式 不仅可以提升查询效率，也 可以节省大量的内存空间 。
举个例子，你要和一个网友去面基，网友告诉你当天他穿的黑色裤子，背着白色的书包，在见面地点你一定不会认错吗？不一定，虽然提供了两个信息，但是还是会有冲突，所以我们只能提供更多的信息来降低冲突，但是不管提供多少信息，在人足够多的情况下还是可能认错
再回到我们的字符串，我们可以给一个字符串映射3个位置，虽然还可能会有认错，但是几率会低很多
而且它们之间可能会有交叉
我们新添加一个物理，甚至可能会有两个位置和前面的元素冲突，但是只要不全冲突就行，容错率是大大提升的
应用场景：
不需要精确的场景，比如快速判断昵称是否注册过，我们就可以把所有昵称放到数据库里，我们可以接受百分之3到5的误判率，比如一个昵称没有被使用，但是却显示被使用了，对于用户来说其实是没什么问题的，换一个即可
假设我们需要精确，不容忍误判，我们可以这样玩，输入的不存在，就返回不存在，如果显示在，我们就去数据库再查一遍，以数据库的结果返回，这样可以减少不在的那些昵称要去查找的损耗，这里就是过滤器的作用，过滤掉了一些，降低数据库的负载压力，提高效率（为什么不全去数据库找？因为太慢了），这也是为什么他叫过滤器的原因
下面我们来对字符串实现过滤器，我们前面使用了字符串哈希算法，这里就需要用到它了，但是这里还有一个问题，会存在双重冲突的问题
第一个是两个字符串不同的，但转出来的整形是相同的，第二个是用除留余数法映射后可能回到相同的位置
基于这两个问题，布隆就想到了映射多个位置，所以就有了布隆过滤器
//BloomFilter.h
struct BKDRHash
{
size_t operator()(const string& str)
{
register size_t hash = 0;
for (auto ch : str)
{
hash = hash * 131 + ch;
}
return hash;
}
};
struct APHash
{
size_t operator()(const string& str)
{
register size_t hash = 0;
size_t ch;
for (size_t i = 0; i < str.size(); i++)
{
size_t ch = str[i];
if ((i & 1) == 0)
{
hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
}
else
{
hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
}
}
return hash;
}
};
struct DJBHash
{
size_t operator()(const string& str)
{
register size_t hash = 5381;
for (auto ch : str)
{
hash += (hash << 5) + ch;
}
return hash;
}
};
template<size_t N,
class K = string,
class Hash1 = BKDRHash,
class Hash2 = APHash,
class Hash3 = DJBHash>
class BloomFilter
{
public:
void Set(const K& key)
{
size_t hash1 = Hash1()(key) % N;
_bs.set(hash1);
size_t hash2 = Hash2()(key) % N;
_bs.set(hash2);
size_t hash3 = Hash3()(key) % N;
_bs.set(hash3);
}
bool Test(const K& key)
{
size_t hash1 = Hash1()(key) % N;
if (_bs.test(hash1) == false)
return false;
size_t hash2 = Hash2()(key) % N;
if (_bs.test(hash2) == false)
return false;
size_t hash3 = Hash3()(key) % N;
if (_bs.test(hash3) == false)
return false;
return true;//存在误判
}
private:
bitset<N> _bs;
};布隆过滤器实现起来就很简单了，我们借助库里面的bitset和三个字符串哈希算法来实现，然后我们将字符串哈希算法改为仿函数，我们只需要实现Set和Test即可
我们简单测试一下，没有问题
我们还可以把hash123打印出来看一看
这里还是有一个冲突的，猪八戒的两个25
如果数据足够多，空间小的话冲突的概率就会很大，这里沙悟净就出现了误判
另外大家可以发现，我们这里是没有实现reset的，是不能实现的，举个例子，如果我们把上面的猪八戒reset了，5和6都会受影响，进而导致孙悟空和二郎神他们都会受影响，就不见了，所以一般不支持删除，删除一个值可能会影响其他值
如果想要强行支持删除，那要付出很大的代价，比如可以使用多个位标识一个值，使用引用计数
这里提供一篇知乎大佬写的布隆过滤器详解
建议大家看一看
下面我们来测试一下，我们set大量的值，然后再给其他大量的值，这些值里有一部分在过滤器里，一部分不在，我们来看看不在过滤器里的值会不会出现误判（也就是原本不在过滤器里的值显示出在）
void TestBloomFilter2()
{
srand(time(0));
const size_t N = 100000;
BloomFilter<N * 4> bf;
std::vector<std::string> v1;
//std::string url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";
std::string url = "猪八戒";
for (size_t i = 0; i < N; ++i)
{
v1.push_back(url + std::to_string(i));
}
for (auto& str : v1)
{
bf.Set(str);
}
// v2跟v1是相似字符串集（前缀一样），但是不一样
std::vector<std::string> v2;
for (size_t i = 0; i < N; ++i)
{
std::string urlstr = url;
urlstr += std::to_string(9999999 + i);
v2.push_back(urlstr);
}
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";
string url = "孙悟空";
url += std::to_string(i + 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到10倍左右
海量数据面试题
哈希切割给一个超过 100G 大小的 log file, log 中存着 IP 地址 , 设计算法找到出现次数最多的 IP 地址？与上题条件相同，如何找到 top K 的 IP ？如何直接用 Linux 系统命令实现？位图应用1. 给定 100 亿个整数，设计算法找到只出现一次的整数？2. 给两个文件，分别有 100 亿个整数，我们只有 1G 内存，如何找到两个文件交集？3. 位图应用变形： 1 个文件有 100 亿个 int ， 1G 内存，设计算法找到出现次数不超过 2 次的所有整数布隆过滤器1. 给两个文件，分别有 100 亿个 query ，我们只有 1G 内存，如何找到两个文件交集？分别给出精确算法和近似算法2. 如何扩展 BloomFilter 使得它支持删除元素的操作
这些题我们讲过了部分，我们来看过滤器的1，要求给出精确算法，这里就需要用到哈希切分
假设平均一个query（查询）是30byte，100亿是3000亿字节，1G大约是10亿字节，也就是说一共是300G左右，而且还是两个这样的文件，现在我们只有1G内存
我们可以把文件切成一个一个的小文件，但是切成小文件后，交集该怎么找呢？一个一个的再去组合测试吗？这样太慢了
我们可以用哈希切分，比如我们把文件切成1000分，但不是平均切分，i = Hash(query) % 1000
i是多少，query就进入第i个小文件，两个文件都用这样的方式来处理
画出来大概就是这样，此时我们只需要对应编号的找即可，比如A0和B0找，A1和B1找即可
哈希切分的效果是，A和B中相同的query一定会分别进入Ai和Bi编号相同的小文件，比如一个query在文件A里经过hash，然后%1000，得到了500，那么如果B里面也有这个query，它也会经过一样的步骤，所以得到的i是相同的，进入小文件的编号也就是一样的，这里有点像哈希桶，同一个桶里就是冲突的，但是也有不冲突的，大多数的这种问题都是可以用哈希切分来解决
这里其实还有一个问题没有解决，找交集，是从Ai中读出来，然后放到set里，再从Bi中读取query，看在不在set，如果在，就是交集，就是可以找到Ai和Bi的交集，这里的切分，如果是平均切分就是一个文件300M，但我们是哈希切分，如果冲突太多，会导致某个Ai文件过大，甚至超过1G（别忘了set也要消耗内存），那该怎么办？
这里会有两个场景，比如Ai有5G，场景1，4G都是相同，1G是冲突，场景2，大多数是冲突
这里场景2我们可以换个哈希函数再次切分，一直切，是可以解决的，但是场景1不可以，相同的是切不开的，并且我们是无法区别到底是场景1还是场景2的
解决方案：1.先把Ai的query读到一个set，如果set的insert报错抛异常（bad_alloc），那么就说明大多数query是冲突，如果能全部读出来，insert到set里面，那么说明Ai中有大量相同的query（set自己可以去重）
2.如果抛异常，说明有大量冲突，我们换一个哈希函数，进行二次切分
我们再看下一个问题
这道题还可以扩展成出现次数最多的K个ip地址
同样的，我们还是使用哈希切分，比如我们切成300份，i = Hash(query) % 300
相同的ip一定会进入同一个小文件，之后我们用map分别统计每个小文件中ip出现的次数即可，出现次数最多的K个我们建小堆即可
全部代码
#pragma once
#include<vector>
using namespace std;
//bitset.h
namespace bai
{
template<size_t N>
class bitset
{
public:
bitset()
{
size_t num = N / 32 + 1;
_a.resize(num);
}
//x映射的位置标记位1
void set(size_t x)
{
size_t i = x / 32;
size_t j = x % 32;
_a[i] |= (1<<j);
}
//x映射的位置标记位0
void reset(size_t x)
{
size_t i = x / 32;
size_t j = x % 32;
_a[i] &= (~(1 << j));
}
bool test(size_t x)
{
size_t i = x / 32;
size_t j = x % 32;
return _a[i] & (1 << j);
}
private:
vector<int> _a;
};
template<size_t N>
class twobitset
{
public:
void set(size_t x)
{
//00 -> 01
if (!_bs1.test(x) && !_bs2.test(x))
{
_bs2.set(x);
}//01 -> 10
else if(!_bs1.test(x) && _bs2.test(x))
{
_bs1.set(x);
_bs2.reset(x);
}
// 本身是10代表出现2次及以上，就不变
}
bool is_once(size_t x)
{
return !_bs1.test(x) && _bs2.test(x);
}
private:
bitset<N> _bs1;
bitset<N> _bs2;
};
}#pragma once
#include<vector>
#include<iostream>
#include<bitset>
#include<string>
using namespace std;
//BloomFilter.h
struct BKDRHash
{
size_t operator()(const string& str)
{
register size_t hash = 0;
for (auto ch : str)
{
hash = hash * 131 + ch;
}
return hash;
}
};
struct APHash
{
size_t operator()(const string& str)
{
register size_t hash = 0;
size_t ch;
for (size_t i = 0; i < str.size(); i++)
{
size_t ch = str[i];
if ((i & 1) == 0)
{
hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
}
else
{
hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
}
}
return hash;
}
};
struct DJBHash
{
size_t operator()(const string& str)
{
register size_t hash = 5381;
for (auto ch : str)
{
hash += (hash << 5) + ch;
}
return hash;
}
};
template<size_t N,
class K = string,
class Hash1 = BKDRHash,
class Hash2 = APHash,
class Hash3 = DJBHash>
class BloomFilter
{
public:
void Set(const K& key)
{
size_t hash1 = Hash1()(key) % N;
_bs.set(hash1);
size_t hash2 = Hash2()(key) % N;
_bs.set(hash2);
size_t hash3 = Hash3()(key) % N;
_bs.set(hash3);
}
bool Test(const K& key)
{
size_t hash1 = Hash1()(key) % N;
if (_bs.test(hash1) == false)
return false;
size_t hash2 = Hash2()(key) % N;
if (_bs.test(hash2) == false)
return false;
size_t hash3 = Hash3()(key) % N;
if (_bs.test(hash3) == false)
return false;
return true;//存在误判
}
private:
bitset<N> _bs;
};以上即为本期全部内容，希望大家可以有所收获
如有错误，还请指正
851
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
