位图与布隆

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.布隆过滤器的应用场景：

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

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

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

过滤垃圾邮件

 

位图布隆对比：位图针对整形，布隆针对字符串。