布隆过滤器

概念：

布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存在”，它是用多个哈希函数，将一个数据映射到位图结构中。此种方式不仅可以提升查询效率，也可以节省大量的内存空间。
底层可理解为：hash+bitset;
主要功能：海量数据中查判断一个数据存不存在；

1.插入

eg:向布隆过滤器中插入：“baidu” 和“tencent”
将"baidu"通过三个不同的hash函数映射到bitset中,并将相应的位标记为1.

同理插入“tencent”

2.查找

查找的时候只需要通过hash函数判断hash映射的这些比特位上是否有不为1的位，有则表明该数据一定不存在。 如果映射的这些比特位都为1也不能表示该数据一定存在，只能说有较大概率存在，因为再插入别的数据的时候可能将该bit位标记为1了，并不是这个数据通过映射标记的。

3.删除

布隆过滤器不能直接支持删除工作，因为在删除一个元素时，可能会影响其他元素
比如：删除上图中"tencent"元素，如果直接将该元素所对应的二进制比特位置0，“baidu”元素也被删除了，因为这两个元素在多个哈希函数计算出的比特位上刚好有重叠。
一种支持删除的方法：将布隆过滤器中的每个比特位扩展成一个小的计数器，插入元素时给k个计数器(k个哈希函数计算出的哈希地址)加一，删除元素时，给k个计数器减一，通过多占用几倍存储空间的代价来增加删除操作。
缺陷：

1. 无法确认元素是否真正在布隆过滤器中
2. 存在计数回绕

布隆过滤器优缺点

优点：

1. 增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无关
2. 哈希函数相互之间没有关系，方便硬件并行运算
3. 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势
4. 在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势
5. 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能
6. 使用同一组散列函数的布隆过滤器可以进行交、并、差运算
   缺点：
7. 有误判率，即存在假阳性(False Position)，即不能准确判断元素是否在集合中(补救方法：再建立一个白名单，存储可能会误判的数据)
8. 不能获取元素本身
9. 一般情况下不能从布隆过滤器中删除元素
10. 如果采用计数方式删除，可能会存在计数回绕问题

模拟代码：

这里为了滤除重复网址，找了三个hash函数来映射。

#include<iostream>
#include<bitset>
#include<vector>
#include<string>
#include<map>
using namespace std;

#define _N 1000

template<class T>
struct KeyToInt1
{
	size_t operator()(const T& str)
	{
		return BKDRHash(str.c_str()) % _N;
	}
	size_t BKDRHash(const char* str)
	{
		register size_t hash = 0;
		while (size_t ch = (size_t)*str++)
		{
			hash = hash * 131 + ch;
		}
		return hash;
	}
};

template<class T>
struct KeyToInt2
{
	size_t operator()(const T& str)
	{
		return SDBMHash(str.c_str()) % _N;
	}
	size_t SDBMHash(const char* str)
	{
		register size_t hash = 0;
		while (size_t ch = (size_t)*str++)
		{
			hash = 65599 * hash + ch;
		}
		return hash;
	}
};

template<class T>
struct KeyToInt3
{
	size_t operator()(const T& str)
	{
		return RSHash(str.c_str()) % _N;
	}
	size_t RSHash(const char* str)
	{
		register size_t hash = 0;
		size_t magic = 63689;
		while (size_t ch = (size_t)*str++)
		{
			hash = hash * magic + ch;
			magic *= 378551;
		}
		return hash;
	}
};

template<class K,
	class hashfcn1 = KeyToInt1<K>,
	class hashfcn2 = KeyToInt2<K>,
	class hashfcn3 = KeyToInt3<K>>
	class BloomFilte
{
public:
	BloomFilte() :size(0)
	{}
public:
	void insert(const K& key)
	{
		size_t index1 = hashfcn1()(key);
		size_t index2 = hashfcn2()(key);
		size_t index3 = hashfcn3()(key);
		_bmp.set(index1);
		_bmp.set(index2);
		_bmp.set(index3);
	}
	bool test(const K& key)
	{
		size_t index1 = hashfcn1()(key);
		if (!_bmp.test(index1))
			return false;
		size_t index2 = hashfcn2()(key);
		if (!_bmp.test(index2))
			return false;
		size_t index3 = hashfcn3()(key);
		if (!_bmp.test(index3))
			return false;

		return true;
	}
private:
	bitset<_N> _bmp;
	size_t     size;
};

void main()
{
	string url = "http://www.taobao.com";
	string url2 = "http://www.baidu.com";
	string url3 = "http://www.taobao.con";
	BloomFilte<string> bf;
	bf.insert(url.c_str());

	cout << bf.test(url) << endl; // 1
	cout << bf.test(url3) << endl;
}