布隆过滤器

Beyls

于 2024-06-22 01:42:16 发布

阅读量939

点赞数 31

分类专栏：数据结构和算法文章标签： c++ 哈希算法

本文链接：https://blog.csdn.net/m0_66182473/article/details/139859937

版权

数据结构和算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.布隆过滤器的提出

位图适用于在海量无重复的数据中对单个数据的存在进行判断，但仅限于整数类型，那么对于其他类型的海量数据，比如字符串，我们如何判断某个字符串是否存在其中呢？

小布在看抖音视频时，抖音会不停地给他推荐新的内容，它每次推荐都要去掉那些已经看过的视频。

问题来了，抖音APP的推荐系统是如何实现推送去重的？用服务器记录了用户看过的所有历史记录？当推荐系统推荐新闻时会从每个用户的历史记录里进行筛选？过滤掉那些已经存在的记录？如何快速查找呢？（本节主要研究最后一个问题）

1. 用哈希表存储用户记录，缺点：浪费空间

2. 用位图存储用户记录，缺点：位图一般只能处理整形，如果内容编号是字符串，就无法处理了。

3. 将哈希与位图结合，即布隆过滤器。

2.布隆过滤器的概念

位图只能处理整形数据，那么我们可以将其他类型的数据映射成整形吗？当然可以。

在位图中，整形数据和bit位是一一映射，那么将其他类型的数据映射成整形，最好也是一一映射。但整形变量的大小是有范围的，比如unsigned long long，变量的取值区间是[0,2^64-1]，可取一千多万亿个数，而其他类型的变量范围，比如string，一个字母分大小写可取52种，假设string长度为20，52^20远远大于2^62,所以将海量的字符串映射成整形，可能会造成哈希冲突，多个字符串对应一个整形变量。

具体问题具体分析，具体分析的方法可以类比到同类型的具体问题解决中。我们以字符串为例，将海量的字符串变量映射成整形变量，可能会造成哈希冲突，但对于我们的目的——判断字符串是否存在是否有影响呢？

由于多个字符串可能映射成同一个整形变量，所以我们无法准确地判断字符串是否存在，但可以准确地判断不存在。比如下图中的"insert"和"apple"都映射成2233，我们调用位图中的检测函数，如果2233对应的bit位为1，检测函数返回为真，我们无法准确判断"insert"和"apple"是否都存在还是只存在一个，如果检测函数返回假，则可断定两个字符串都不存在。

综上，对于非整数类型的海量数据，我们可以先将这些数据通过哈希函数映射成无重复的整数集，再利用位图，判断要检测的数据是否存在。而布隆过滤器，就是布隆提出的一种数据结构，它的算法思想就是哈希+位图，能够高效的插入和查询，不能准确的判断某个元素的存在，可以准确的判断某个元素不存在。也就是说，布隆过滤器适用于处理需要高效插入和查询，可以接受存在误判的海量数据集。

那么针对布隆过滤器对数据存在不确定性的判断，我们有没有可以优化的地方呢？

有，可以一个值映射多个bit位，用多个哈希函数，将原数据集中每个元素映射成多个整形变量，插入该元素时，该元素映射成的多个变量对于的bit位置1，查询该元素是否存在时，通过检查元素映射成的多个变量对于的bit位，如果bit位都为1，则增加了该元素存在的概率。（注意：多个哈希函数，但只有一个位图，单个数据通过多个哈希函数映射成多个整形变量插入同一个位图）

3.布隆过滤器的实现

在实现布隆过滤器前，有两点我们必须要弄懂：

1.我们要知道如何将原数据集利用哈希函数映射成整形集，同时，要用多少个哈希函数才能达到我们可以接受的误判率；

2.我们要清楚开多大的空间，知道数据集映射后的整形集要占多少位bit，然后将所占位数的近似数（大于所占位数）传入布隆过滤器中，本质上是让位图知道要开辟多少个bit位，让bit位数足以和整形集的元素一一映射。

换言之，在实现布隆过滤器前，该如何选择哈希函数个数和布隆过滤器长度（长度单位：bit），才能有效地降低误报率呢？

可以参考：详解布隆过滤器的原理，使用场景和注意事项 - 知乎 (zhihu.com)https://zhuanlan.zhihu.com/p/43263751/具体地实现：

bitset.h链接：位图/位图/bitset.h · fyehong/cpp - 码云 - 开源中国 (gitee.com)

bloom_filter.h

#pragma once
#include "bitset.h"
struct BKDRHash
{
	size_t operator()(const string& key)
	{
		// BKDR
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}

		return hash;
	}
};

struct APHash
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (size_t i = 0; i < key.size(); i++)
		{
			char ch = key[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& key)
	{
		size_t hash = 5381;
		for (auto ch : key)
		{
			hash += (hash << 5) + ch;
		}
		return hash;
	}
};

//N表示要存储数据的个数（一般比这个值大）
template<size_t N,class K = string,
	class HashFunc1 = BKDRHash,
	class HashFunc2 = APHash,
	class HashFunc3 = DJBHash>
class BloomFilter
{
public:
	//将K映射成三个整形变量后插入位图中
	void Set(const K& key)
	{
		size_t hashi1 = HashFunc1()(key) % N;
		size_t hashi2 = HashFunc2()(key) % N;
		size_t hashi3 = HashFunc3()(key) % N;

		_bs.set(hashi1);
		_bs.set(hashi2);
		_bs.set(hashi3);

		/*cout << hashi1 << endl;
		cout << hashi2 << endl;
		cout << hashi3 << endl << endl;*/
	}
	//检测对应的bit位是否为真，如果都为真，则概率性为真
	//有一个为假，则真假
	bool Test(const K& key)
	{

		size_t hash1 = HashFunc1()(key) % N;
		if (_bs.test(hash1) == false)
			return false;

		size_t hash2 = HashFunc2()(key) % N;
		if (_bs.test(hash2) == false)
			return false;

		size_t hash3 = HashFunc3()(key) % N;
		if (_bs.test(hash3) == false)
			return false;

		//存在误判
		return true;
	}

	//一般不支持删除，因为删除一个值，会影响其他值
	//如果非要支持删除的话，可以采用"引用技术"，比如用3个bit来标记映射位（替代原来的1个bit位），
	//这样一个映射位最多容纳8个不同数据的映射，每映射一次++，删除就--。
	//但会带来空间消耗
	void Reset(const K& key);

private:
	yls::bitset<N> _bs;
};

void TestBF1()
{
	BloomFilter<100> bf;
	bf.Set("猪八戒");
	bf.Set("沙悟净");
	bf.Set("孙悟空");
	bf.Set("二郎神");

	cout << bf.Test("猪八戒") << endl;
	cout << bf.Test("沙悟净") << endl;
	cout << bf.Test("孙悟空") << endl;
	cout << bf.Test("二郎神") << endl;
	cout << bf.Test("二郎神1") << endl;
	cout << bf.Test("二郎神2") << endl;
	cout << bf.Test("二郎神 ") << endl;
	cout << bf.Test("太白晶星") << endl;
}

//测试误判率
void TestBF2()
{
	srand(time(0));
	const size_t N = 100000;
	BloomFilter<N * 30> 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;
}
//总结：开的空间越大，误判率越小

test.cpp:

#include<iostream>
#include<vector>
#include<string>
using std::cout;
using std::endl;
using std::string;
using std::vector;

#include "BloomFilter.h"
int main()
{
	TestBF2();
	
	return 0;
}