位图与布隆

1K=1024byte

1M=1024k=1024*1024byte(约100万个字节)

1G=1024M=1024*1024*1024byte(约为10亿个字节)

先看一个题,给40亿个不重复无符号整数,给一个无符号整数,快速判断一个数是否在这40亿个数中。

判断一个数在或者不在,我们通常有以下方法:

1.暴力查找  时间复杂度O(N)   

2.排序完,进行二分查找O(N)+O(N lgN)

3.哈希/搜索树  哈希O(1)搜索树O(NlgN)

上面的可以看出,如果只查找一次,用暴力查找比较好,查多次用后面的较好。

但是上面的

1.暴力查找需要报40亿个整数都要加入磁盘中16G,存不下

 2.排序也一样,存不下

 3.如果用搜索树当然更不行,一个节点有左右孩子,数等,比16G还大,哈希桶也存不下,有一个指针,和数据

   这时我们想到直接定址法的哈希,但是直接定地址法的哈希要开整形最大值那么大的整形的空间。42亿九千万个整形                       大概也就是16G多,存不下,但是我们想到只让判断这个数在或者不在两种状态,用一个比特位就可以表示,没有必要                   开一个整形,这样就不需要16G,只需16G/4/8=500M,这时我们的内存就可以存下,这就是所说的位图

位图:也是一种直接定址法的哈希。本质是用一个数组,但是用一个比特位来表示一种状态,0表示不存在,1表示存在

位图的具体实现如下:

 

#include
#include
using namespace std;
class BitSet
{

public:
	BitSet(size_t range)
	{
		_bits.resize((range >> 5) + 1, 0);//注意移位运算符,优先级特别低
	}
	void Set(size_t x)
	{
		size_t num = x >> 5;//知道在哪个字节
		size_t pos = x % 32;//知道在哪个比特位
		//把这一位置为1,给这一位或1,给其他位或0.0与任何数或为任何数
		_bits[num] |= (1 << pos);
	}
	void ReSet(size_t x)
	{
		size_t num = x >> 5;
		size_t pos = x % 32;
		//1与任何数与为任何数,0与任何数与为0
		_bits[num] &= ~(1 << pos);
	}
	bool Test(size_t x)
	{
		size_t num = x >> 5;
		size_t pos = x % 32;
		//如何测试这一位为1,还是0
		return _bits[num] & (1 << pos);

	}
protected:
	vector_bits;
};

int main()
{

	//BitSet bs(-1);
	BitSet bs(~0);
	bs.Set(1);
	bs.Set(19);
	bs.Set(1000);
	bs.ReSet(1000);
	cout<

在40亿个字符串集合中,快速判断一个字符串在或者不在?

这个题我们也可以用位图,可是这是字符串又不是整数,可是我们可以把字符串通过在字符串哈希转换为整数。可是这时候会产生哈希冲突,会产生误判,一个数明明没在,却判断为在,于是我们可以将一个元素经过不同的哈希函数,映射到多个位置,如果这几个位置上都为1,我们就认为这个元素存在,如果有一个位为0,就表示不存在。这就是所谓的布隆。

布隆:是位图+字符串哈希的结合,基本思想是,通过一个哈希函数将一个元素映射到一个位置,我们只要判断这个位置是不是存在,就能判断是否存在,但是由于哈希冲突的原因,不同的元素经过哈希函数会映射到相同的哈希地址,导致误判,为了缓解误判,我们将一个元素经过多个散列函数映射到多个位置上,如果这多个位都存在,我们认为存在,如果有一个位不存在,则不存在。

注意:布隆过滤器是存在不准确,不存在准确。

1.怎样降低误判的概率?

多个哈希函数进行映射

具体实现代码如下:

#include
#include
using namespace std;
class BitSet
{

public:
	BitSet(size_t range)
	{
		_bits.resize((range >> 5) + 1, 0);//注意移位运算符,优先级特别低
	}
	void Set(size_t x)
	{
		size_t num = x >> 5;//知道在哪个字节
		size_t pos = x % 32;//知道在哪个比特位
		//把这一位置为1,给这一位或1,给其他位或0.0与任何数或为任何数
		_bits[num] |= (1 << pos);
	}
	void ReSet(size_t x)
	{
		size_t num = x >> 5;
		size_t pos = x % 32;
		//1与任何数与为任何数,0与任何数与为任何数
		_bits[num] &= ~(1 << pos);
	}
	bool Test(size_t x)
	{
		size_t num = x >> 5;
		size_t pos = x % 32;
		//如何测试这一位为1,还是0
		return _bits[num] & (1 << pos);

	}
protected:
	vector_bits;
};
struct  _HashFunc1
{
	size_t operator()(const string& str)
	{
		size_t num = 0;
		for (int i = 0; i < str.size(); i++)
		{
			num = num * 131 + str[i];
		}
		return num;
	}
};
struct _HashFunc2
{
	size_t operator()(const string& str)
	{
		size_t num = 0;
		for (int i = 0; i < str.size(); i++)
		{
			num = num * 65596 + str[i];
		}
		return num;
	}
};
struct _HashFunc3
{

	size_t operator()(const string& str)
	{
		size_t magic = 63689;
		size_t num = 0;
		for (int i = 0; i < str.size(); i++)
		{
			
			num = num*magic + str[i];
			magic = magic * 378551;
		}
		return num;
	}
};
struct _HashFunc4
{
	size_t operator()(const string& str)
	{
		size_t num = 0;
		for (int i = 0; i < str.size(); i++)
		{
			if ((i & 1) == 0)
			{
				num ^= ((num << 7) ^ str[i] ^ (num >> 3));
			}
			else
			{
				num ^= (~((num << 1) ^ str[i] ^ (num >> 5)));
			}
		}
		return num;
	}

};
class BloomFilter
{
public:
	BloomFilter(size_t x)
		:_bs(x)
		, _capacity(x)
	{}
	void Set(const string & key)
	{
		size_t index1 = (_HashFunc1()(key)) % _capacity;
		size_t index2 = (_HashFunc2()(key)) % _capacity;
		size_t index3 = (_HashFunc3()(key)) % _capacity;
		size_t index4 = (_HashFunc4()(key)) % _capacity;
		_bs.Set(index1);
		_bs.Set(index2);
		_bs.Set(index3);
		_bs.Set(index4);

	}
	int Test(const string& key)
	{
		size_t index1 = (_HashFunc1()(key)) % _capacity;
		size_t index2 = (_HashFunc2()(key)) % _capacity;
		size_t index3 = (_HashFunc3()(key)) % _capacity;
		size_t index4 = (_HashFunc4()(key)) % _capacity;
		//只有四个位都为1才存在
		if (!_bs.Test(index1))
		{
			return false;
		}
		if (!_bs.Test(index2))
		{
			return false;
		}
		if (!_bs.Test(index2))
		{
			return false;
		}
		if (!_bs.Test(index2))
		{
			return false;
		}

		return true;
	}
private:
	BitSet _bs;
	size_t _capacity;

};
int main()
{
	BloomFilter bf(-1);
	bf.Set("nihao");
	bf.Set("wohenhao");
	bf.Set("nihaoma");
	bf.Set("nihao ");
	cout<

以上的代码没有对布隆进行删除操作?

2.如何对布隆过滤器进行删除操作

因为一个位可能对应着多个元素,所以当我们删除一个位的时候,不能直接删除,否则会影响其他元素。这时候我们采取引用计数的方式来实现删除操作,为了记录这个元素出现的次数,我们不能用一个位来表示状态了,我们可以用一个无符号整形来表示状态。这样就要用四个字节表示在或者不在。我们不支持这样做,因为我们用布隆就是为了解决避免空间的浪费,如果增加了,取消设置,违背了。

3.布隆过滤器的优点:空间效率和查询时间都很好,超过一般的算法。插入和查找0(1)

   布隆过滤器的缺点:误判

4.布隆过滤器的应用场景:

爬虫爬某个网站是否被访问过(允许漏爬)。

检测一个英语单词拼写是否拼写正确(也就是判断它在某个已知的字典里)

破案当中一个嫌疑犯的名字是否已经在嫌疑犯名单上

过滤垃圾邮件

 

位图布隆对比:位图针对整形,布隆针对字符串。

 

 

 

你可能感兴趣的:(数据结构)