处理大数据运算的利器 — 布隆过滤器原理以及设计

最新推荐文章于 2023-01-20 12:00:00 发布

Dawn_sf

最新推荐文章于 2023-01-20 12:00:00 发布

阅读量1.9k

点赞数 1

分类专栏： c++概念数据结构文章标签：布隆过滤器大数据处理

本文链接：https://blog.csdn.net/dawn_sf/article/details/78553999

版权

c++概念同时被 2 个专栏收录

48 篇文章 6 订阅

订阅专栏

数据结构

21 篇文章 2 订阅

订阅专栏

布隆过滤器

说到布隆过滤器千万别想到英雄联盟里面的布隆大叔. 我们今天认识的布隆过滤器是一个处理大数据问题的利器. 它可以进行粗略估计

一个数据是否存在在该集合当中.如果想判断一个元素是不是在一个集合当中，一般想到的是将所有元素保存起来，然后通过比较确定.

链表，树等等结构都是这种思路. 但是随着集合中元素的增多，我们需要的存储空间越来越大.检索的速度也越来越慢. 效果不错的就是

我们的哈希表，当然我们的布隆过滤器其实也是使用了我们的hash映射思想. 我们可以通过一个Hash函数将一个元素映射到一个位图当

中，如果这个点被置为1，那么集合当中就是有她的.反之则没有.这就是布隆过滤器的基本思想.

布隆过滤器用于字符串去重复，比如网络爬虫抓取时url去重，邮件提供商反垃圾黑名单Email地址去重，等等，用哈希表也可以用于元素

去重，但是占用空间比较大，而且空间使用率只有50%，布隆过滤器只占哈希表的1/8和1/4的空间复杂度，就能解决同样的问题，但是存在

误判，而且不能够删除已经有的元素，元素越多，误报率越大，但是不会漏报. 对于还需要删除的布隆过滤器，还有Counter Bloom

Filter ，这个是布隆过滤器的变体，可以删除元素.

但是我们都知道的哈希表是有哈希冲突的. 况且你是使用位处理的那么也就不存在Hash开链法这种优化方式了. 那么当你好几个数据同

时映射到一个位怎么办?? 那你就映射呗我对于映射真的没有办法改变? 但是布隆过滤器不会坐以待毙，如果这样我可不可以使用好几

个Hash算法，然后让你映射不同的位置当你过来检验的时候，必须这几个位都被置为1，那样你才能认定这个数字是存在的. 当然这里都

是有数学建模的基础的，然而我又不是很理解... 我就找到网上的一个图过来瞧瞧~

下图是布隆过滤器假正列概率p与位数大小m和集合中插入数据个数n的关系图. 假定Hash函数个数选取最优数目: K = (M/N)In

我们也看到了布隆过滤器是有缺陷的，他不够准确当数值足够大的时候误判率就会越来越大. 所以布隆过滤器只能够作为一个粗略的判

断.我们目前为止已经大概的了解到它的基本原理. 我们可以发现布隆过滤器的判断存在是不准确的. 但是它判断不存在一定是准确的.

好了我们来缕一下布隆过滤器的优缺点.

优点:相比于其他的数据结构，布隆过滤器在空间和时间方面都有巨大的优势.布隆过滤器存储空间和插入/查询时间都是常数.另外，

Hash函数相互之间没有关系，方便由硬件并行实现. 布隆过滤器不需要存储元素本身,在某些对保密要求非常严格的场合有优势. 布

隆过滤器可以表示所有类型的数据，其他任何数据结构都不能.

缺点: 首先误判率是一定要提出来的，如果存入的元素数量增加，误判率就会增加. 但是如果元素数量过少，那还不如使用Hash表呢

还有，布隆过滤器当中不能随便删除元素. 因为同一个位有可能有好几个数据标记了它, 如果涉及一个引用计数却又太复杂啦.

现在我们理解清楚布隆过滤器的原理，那么我们尝试实现一个最简单的布隆过滤器试一试！

代码实现：

#include"BitMap.h"
#include<string>


template<class K>
struct __HashFunc1
{
	static size_t BKDRHash(const char * str)
	{
		unsigned int seed = 131; // 31 131 1313 13131 131313
		unsigned int hash = 0;
		while (*str)
		{
			hash = hash * seed + (*str++);
		}
		return (hash & 0x7FFFFFFF);
	}

	size_t operator()(const K& key)
	{
		return  BKDRHash(key.c_str());
	}
};


template<class K>
struct __HashFunc2
{
	size_t SDBMHash(const char *str)
	{
		register size_t hash = 0;
		while (size_t ch = (size_t)*str++)
		{
			hash = 65599 * hash + ch;
			//hash = (size_t)ch + (hash << 6) + (hash << 16) - hash;  
		}
		return hash;
	}

	size_t operator()(const K& key)
	{
		return  SDBMHash(key.c_str());
	}
};


template<class K>
struct __HashFunc3
{
	size_t APHash(const char *str)
	{
		register size_t hash = 0;
		size_t ch;
		for (long i = 0; ch = (size_t)*str++; i++)
		{
			if ((i & 1) == 0)
			{
				hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
			}
			else
			{
				hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
			}
		}
		return hash;
	}

	size_t operator()(const K& key)
	{
		return  APHash(key.c_str());
	}
};


template<class K = string, class HashFunc1 = __HashFunc1<K>, class HashFunc2 = __HashFunc2<K>, class HashFunc3 = __HashFunc3<K>>
class BloomFilter
{
public:

	BloomFilter(size_t num)
		:_bm(num * 5)
		, _bitSize(num * 5)
	{}

	void Set(const K& key)
	{
		size_t index1 = HashFunc1()(key);
		_bm.SetBit(index1);

		size_t index2 = HashFunc2()(key);
		_bm.SetBit(index2);

		size_t index3 = HashFunc3()(key);
		_bm.SetBit(index3);
	}

	bool Test(const K& key)
	{
		size_t index1 = HashFunc1()(key);
		if (_bm.TestBit(index1) == false)
		{
			return false;
		}

		size_t index2 = HashFunc2()(key);
		if (_bm.TestBit(index2) == false)
		{
			return false;
		}

		size_t index3 = HashFunc3()(key);
		if (_bm.TestBit(index3) == false)
		{
			return false;
		}

		//所有位置都为真. 但是它是不准确的.
		return true;
	}

private:
	BitMap _bm;
	size_t _bitSize;
};

void Test()
{
	BloomFilter<> T(4000000000);

	T.Set("12312312411231215151251251252151251");
	T.Set("12312312411231215151251251252151252");
	T.Set("12312312411231215151251251252151253");
	T.Set("12312312411231215151251251252151254");
	T.Set("12312312411231215151251251252151255");
	T.Set("12312312411231215151251251252151256");
	T.Set("12312312411231215151251251252151257");

	cout << T.Test("12312312411231215151251251252151251") << endl;
	cout << T.Test("12312312411231215151251251252151252") << endl;
	cout << T.Test("12312312411231215151251251252151253") << endl;
	cout << T.Test("12312312411231215151251251252151254") << endl;
	cout << T.Test("12312312411231215151251251252151255") << endl;
	cout << T.Test("12312312411231215151251251252151256") << endl;
	cout << T.Test("12312312411231215151251251252151257") << endl;

	system("pause");

}

用到的位图的代码在我的另外一个博客当中: 位图的原理以及设计