目录
布隆过滤器的提出
我们在使用新闻客户端看新闻时，它会给我们不停地推荐新的内容，它每次推荐时要去重，去掉那些已经看过的内容。问题来了，新闻客户端推荐系统如何实现推送去重的？ 用服务器记录了用户看过的所有历史记录，当推荐系统推荐新闻时会从每个用户的历史记录里进行筛选，过滤掉那些已经存在的记录。 如何快速查找呢？
用哈希表存储用户记录，缺点：浪费空间
用位图存储用户记录，缺点：位图一般只能处理整形，如果内容编号是字符串，就无法处理了。
将哈希与位图结合，即布隆过滤器
即通过位图的方式确定字符串在还是不在，我们可以采用HashFunc将字符串转换成整形映射到位图中，这就是布隆过滤器。
布隆过滤器概念
布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存在”，它是用多个哈希函数，将一个数据映射到位图结构中。此种方式不仅可以提升查询效率，也可以节省大量的内存空间。
但实际上这种布隆过滤器的方式可能会产生误判：
- 在 是不一定准确的。（hashFunc映射冲突）
- 不在 一定是准确的。
可能存在是因为映射可能出现重复，即产生冲突，这是布隆过滤器无法避免的，但是可以通过增加HashFunc的映射次数从而降低冲突引起的误判率。
如图，映射之后，当查找时，如果三个映射值都不为0，那么可以大概认为这个变量是存在的。（映射函数越多，越准确）当然映射越多的话，同样会浪费空间，因此需要根据需求设计HashFunc的个数。
如何选择哈希函数个数和布隆过滤器长度
很显然，过小的布隆过滤器很快所有的 bit 位均为 1，那么查询任何值都会返回“可能存在”，起不到过滤的目的了。布隆过滤器的长度会直接影响误报率，布隆过滤器越长其误报率越小。
另外，哈希函数的个数也需要权衡，个数越多则布隆过滤器 bit 位置位 1 的速度越快，且布隆过滤器的效率越低；但是如果太少的话，那我们的误报率会变高。
k 为哈希函数个数，m 为布隆过滤器长度，n 为插入的元素个数，p 为误报率
如何选择适合业务的 k 和 m 值呢：k = m ∗ ln2 / n
可以看出，当k=3时，m≈4.2*n。因此，下面代码中我们采用5*N大小的布隆过滤器长度无疑是非常合适的。
注：布隆过滤器在STL中并没有实现，因为需求不一样，即所需哈希哈数个数不同，官方库就没有给出，有需要需要自己实现
布隆过滤器的实现
布隆过滤器实现直接复用STL的bitset
size_t N 是位图长度，size_t X 是每个元素映射时建议的位图大小，布隆过滤器可以实现为一个模板类，因为插入布隆过滤器的元素不仅仅是字符串，也可以是其他类型的数据，只有调用者能够提供对应的哈希函数将该类型的数据转换成整型即可，但一般情况下布隆过滤器都是用来处理字符串的，所以这里可以将模板参数K的缺省类型设置为string
template<
size_t N,//位图长度，N*X需要开的空间大小
size_t X = 5,//使用3个哈希函数，布隆过滤器的长度应该是插入元素个数的5倍左右
class K = string,
class Hash1 = BKDRHash,
class Hash2 = APHash,
class Hash3 = DJBHash>基本框架如下：
template<
size_t N,//位图长度，N*X需要开的空间大小
size_t X = 5,//使用3个哈希函数，布隆过滤器的长度应该是插入元素个数的5倍左右
class K = string,
class Hash1 = BKDRHash,
class Hash2 = APHash,
class Hash3 = DJBHash>
//有需要再增加哈希函数
class bloomfilter {
public:
private:
std::bitset<N*X> _bs; // 位图
};这里还需增加字符串转换成整型的哈希函数，字符串哈希算法博客：
各种字符串Hash函数 - clq - 博客园 (cnblogs.com)编辑https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html
struct BKDRHash {
// BKDR
size_t operator()(const string& str) {
size_t hash = 0;
for (size_t i = 0; i < str.size(); ++i) {
hash *= 131;
hash += str[i];
}
return hash;
}
};
struct APHash {
size_t operator()(const string& str)
{
unsigned int hash = 0;
int i = 0;
for (auto& ch : str)
{
if ((i & 1) == 0)
{
hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
}
else
{
hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
}
++i;
}
return hash;
}
};
struct DJBHash
{
size_t operator()(const string& key)
{
unsigned int hash = 5381;
for (auto ch : key)
{
hash += (hash << 5) + ch;
}
return hash;
}
};布隆过滤器的插入
向布隆过滤器中插入：“baidu”
void set(const K& key) {
size_t index1 = Hash1()(key) % (N * X); // Hash1()匿名对象
size_t index2 = Hash2()(key) % (N * X);
size_t index3 = Hash3()(key) % (N * X);
//cout << "哈希值" << index1 << endl;
//cout << "哈希值" << index2 << endl;
//cout << "哈希值" << index3 << endl;
_bs.set(index1);
_bs.set(index2);
_bs.set(index3);
}布隆过滤器的查找
布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特位一定为1。所以可以按照以下方式进行查找：分别计算每个哈希值对应的比特位置存储的是否为零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。
注意：布隆过滤器如果说某个元素不存在时，该元素一定不存在，如果该元素存在时，该元素可能存在，因为有些哈希函数存在一定的误判。
比如：在布隆过滤器中查找"alibaba"时，假设3个哈希函数计算的哈希值为：1、3、7，刚好和其他元素的比特位重叠，此时布隆过滤器告诉该元素存在，但是该元素是不存在的。
bool test(const K& key) {
size_t index1 = Hash1()(key) % (N * X);
if (_bs.test(index1) == false) {
return false;
}
size_t index2 = Hash2()(key) % (N * X);
if (_bs.test(index2) == false) {
return false;
}
size_t index3 = Hash3()(key) % (N * X);
if (_bs.test(index3) == false) {
return false;
}
return true; // 但是这里也不一定是真的在，还是存在误判
// 判断在，是不准确的，可能存在误判
// 判断不在，是准确的
}布隆过滤器的删除
布隆过滤器不能直接支持删除工作，因为在删除一个元素时，可能会影响其他元素。
比如：删除上图中"tencent"元素，如果直接将该元素所对应的二进制比特位置0，“baidu”元素也被删除了，因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。
一种支持删除的方法：将布隆过滤器中的每个比特位扩展成一个小的计数器，插入元素时给k个计数器(k个哈希函数计算出的哈希地址)加一，删除元素时，给k个计数器减一，通过多占用几倍存储空间的代价来增加删除操作。
缺陷：
无法确认元素是否真正在布隆过滤器中
存在计数回绕
完整代码
#include<bitset>
#include<string>
// 布隆过滤器
// 优点：节省空间，高效，可以标记存储任意类型
// 缺点：存在误判，不支持删除
namespace hek {
//https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html
struct BKDRHash {
// BKDR
size_t operator()(const string& str) {
size_t hash = 0;
for (size_t i = 0; i < str.size(); ++i) {
hash *= 131;
hash += str[i];
}
return hash;
}
};
struct APHash {
size_t operator()(const string& str)
{
unsigned int hash = 0;
int i = 0;
for (auto& ch : str)
{
if ((i & 1) == 0)
{
hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
}
else
{
hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
}
++i;
}
return hash;
}
};
struct DJBHash
{
size_t operator()(const string& key)
{
unsigned int hash = 5381;
for (auto ch : key)
{
hash += (hash << 5) + ch;
}
return hash;
}
};
template<
size_t N,//位图长度，N*X需要开的空间大小
size_t X = 5,//使用3个哈希函数，布隆过滤器的长度应该是插入元素个数的5倍左右
class K = string,
class Hash1 = BKDRHash,
class Hash2 = APHash,
class Hash3 = DJBHash>
//有需要再增加哈希函数
class bloomfilter {
public:
void set(const K& key) {
size_t index1 = Hash1()(key) % (N * X); // Hash1()匿名对象
size_t index2 = Hash2()(key) % (N * X);
size_t index3 = Hash3()(key) % (N * X);
//cout << "哈希值" << index1 << endl;
//cout << "哈希值" << index2 << endl;
//cout << "哈希值" << index3 << endl;
_bs.set(index1);
_bs.set(index2);
_bs.set(index3);
}
bool test(const K& key) {
size_t index1 = Hash1()(key) % (N * X);
if (_bs.test(index1) == false) {
return false;
}
size_t index2 = Hash2()(key) % (N * X);
if (_bs.test(index2) == false) {
return false;
}
size_t index3 = Hash3()(key) % (N * X);
if (_bs.test(index3) == false) {
return false;
}
return true; // 但是这里也不一定是真的在，还是存在误判
// 判断在，是不准确的，可能存在误判
// 判断不在，是准确的
}
//void reset(const K& key) {
// // 将映射的位置给值0就行了 ？
// // 不支持删除，可能会存在误删。一般布隆过滤器不支持删除。
//}
private:
//bitset2<N* X> _bs; // 位图
std::bitset<N*X> _bs; // 位图
};
void test_bloomfilter() {
const size_t N = 100000;
bloomfilter<N> bf;
bf.set("abcd");
bf.set("aadd");
bf.set("bcad");
cout << bf.test("abcd") << endl;
cout << bf.test("aadd") << endl;
cout << bf.test("bcad") << endl;
cout << bf.test("cbad") << endl;
}
void test_bloomfilter2()
{
srand(time(0));
const size_t N = 100000;
bloomfilter<N> bf;
std::vector<std::string> v1;
std::string url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";
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 url = "https://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html";
url += std::to_string(999999 + 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";
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;
}
}布隆过滤器的优缺点
优点：
- 增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无关
- 哈希函数相互之间没有关系，方便硬件并行运算
- 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势
- 在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势
- 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能
- 使用同一组散列函数的布隆过滤器可以进行交、并、差运算
缺点：
- 有误判率，即存在假阳性(False Position)，即不能准确判断元素是否在集合中(补救方法：再
- 建立一个白名单，存储可能会误判的数据)
- 不能获取元素本身
- 一般情况下不能从布隆过滤器中删除元素
- 如果采用计数方式删除，可能会存在计数回绕问题
2688
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
