位图/布隆过滤器

一、位图

1.1位图的概念

所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的。

1.2位图的实现

    template<size_t N>
	class bitset
	{
	public:
		bitset()
		{
			//需要N个比特位，一个字节四个比特位，四个字节32个比特位，所以要除以32，向上取整。
			_a.resize(N / 32 + 1);
		}
		void set(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;
			_a[i] |= (1 << j);
		}
		void reset(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;
			_a[i] &= ~(1 << j);
		}
		bool test(size_t x)
		{
			size_t i = x / 32;
			size_t j = x % 32;
			return _a[i] & (1 << j);
		}
	private:
		vector<int> _a;
	};

二、布隆过滤器

2.1布隆过滤器的概念

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

2.2布隆过滤器的插入

布隆过滤器的底层是位图

如果我们要映射一个值到布隆过滤器中，我们需要使用多个不同的哈希函数生成多个哈希值，并对每个生成的哈希值指向的 bit 位置 1，例如值 “baidu” 和三个不同的哈希函数分别生成了哈希值 1、4、7，则上图转变为：

我们现在再存一个值 “tencent”，如果哈希函数返回 3、4、8 的话，图继续变为：

可以看到下标为4的位置被覆盖了。

2.3布隆过滤器的查找

布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特位一定为1。所以可以按照以下方式进行查找：分别计算每个哈希值对应的比特位置存储的是否为
零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。

注意：注意：布隆过滤器如果说某个元素不存在时，该元素一定不存在，如果该元素存在时，该元素可能存在，因为有些哈希函数存在一定的误判。

如果有一个字符串“kkkkkkk” 哈希函数返回的值为1,4,7，而此时1,4,7位置的值为1，刚好和其
他元素的比特位重叠，那么查找字符串“kkkkkkk”的结果为存在，但是实际上这个字符串不存在。所以判断存在会出现误判。

2.4布隆过滤器的删除

布隆过滤器不支持删除操作，因为如果有两个元素的哈希值重叠，那么删除一个元素会影响另一个元素。

2.5布隆过滤器的优点

相比于其它的数据结构，布隆过滤器在空间和时间方面都有巨大的优势。布隆过滤器存储空间和插入/查询时间都是常数，时间复杂度为O(K), (K为哈希函数的个数，一般比较小)。另外，散列函数相互之间没有关系，方便由硬件并行实现。布隆过滤器不需要存储元素本身，在某些对保密要求非常严格的场合有优势。

布隆过滤器可以表示全集，其它任何数据结构都不能；

使用同一组散列函数的布隆过滤器可以进行交、并、差运算

2.5布隆过滤器的缺点

随着存入的元素数量增加，误算率随之增加。

另外，一般情况下不能从布隆过滤器中删除元素。我们很容易想到把位数组变成整数数组，每插入一个元素相应的计数器加1, 这样删除元素时将计数器减掉就可以了。然而要保证安全地删除元素并非如此简单。首先我们必须保证删除的元素的确在布隆过滤器里面。这一点单凭这个过滤器是无法保证的。另外计数器回绕也会造成问题。

在降低误算率方面，有不少工作，使得出现了很多布隆过滤器的变种。

设m为布隆过滤器的大小，n为插入元素的个数，满足 m=4.3*n 综合而言更好。

2.6布隆过滤器的模拟实现

//针对于字符串来说，常用的三个哈希函数
template<class T = string>
struct BKDRHash
{
	size_t operator()(const T& str)
	{
		size_t hash = 0;
		for(auto ch : str)
		{
			hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..           
		}
		return hash;
	}
};

template<class T = string>
struct APHash
{
	size_t operator()(const T& str)
	{
		size_t hash = 0;
		int i = 0;
		for (auto ch : str)
		{
			
			if ((i & 1) == 0)
			{
				hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
			}
			else
			{
				hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
			}
			++i;
		}
		return hash;
	}
};



template<class T = string>
struct DJBHash
{
	size_t operator()(const T& str)
	{
		if (str.length() == 0)
			return 0;
		size_t hash = 5381;
		for(auto ch : str)
		{
			hash += (hash << 5) + ch;
		}
		return hash;
	}
};


template<size_t N, class T = string, class Hash1 = BKDRHash<T>, 
		class Hash2 = APHash<T>, class Hash3 = DJBHash<T>>
class BloomFilter
{
public:
	void set(const T& str)
	{
		size_t hash1 = Hash1()(str) % N;
		size_t hash2 = Hash2()(str) % N;
		size_t hash3 = Hash3()(str) % N;

		_bs.set(hash1);
		_bs.set(hash2);
		_bs.set(hash3);
	}

	bool Test(const T& str)
	{
		size_t hash1 = Hash1()(str) % N;
		if (_bs.test(hash1) == 0)
			return false;
		size_t hash2 = Hash2()(str) % N;
		if (_bs.test(hash2) == 0)
			return false;
		size_t hash3 = Hash3()(str) % N;
		if (_bs.test(hash3) == 0)
			return false;
		
		return true;//存在误判
	}
private:
	bitset<N> _bs;
};