C++——位图和布隆过滤器

1、位图

2、布隆过滤器

---

1、位图

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

来判断某个数据存不存在的。

比如有一道题: 给 40 亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在 这 40 亿个数中。

这道题的解法有很多，最简单的就是遍历一遍，时间复杂度为O（n），也可以排序后再使用二分查找，但是无论用哪种方法，怎么样存这40亿个数首先就是个问题，它所占用的空间太大了，所以这里就可以使用位图，用比特位置1的方式来代表一个数据存在，那么原本一个整形的4字节就可以用来表示32个位数的值是否存在。

位图的实现：

class bitset
{
public:
 bitset(size_t bitCount)
 : _bit((bitCount>>5)+1), _bitCount(bitCount)
 {}
 // 将which比特位置1
 void set(size_t which)
 {
 if(which > _bitCount)
 return;
 size_t index = (which >> 5);
 size_t pos = which % 32;
_bit[index] |= (1 << pos);
 }
 // 将which比特位置0
 void reset(size_t which)
 {
 if(which > _bitCount)
 return;
 size_t index = (which >> 5);
 size_t pos = which % 32;
 _bit[index] &= ~(1<<pos);
 }
 // 检测位图中which是否为1
 bool test(size_t which)
 {
 if(which > _bitCount)
 return false;
 size_t index = (which >> 5);
 size_t pos = which % 32;
 return _bit[index] & (1<<pos);
 }
 // 获取位图中比特位的总个数
 size_t size()const{ return _bitCount;}
 // 位图中比特为1的个数
 size_t Count()const
 {
     int bitCnttable[256] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2,
3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3,
3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3,
4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4,
3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5,
6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4,
4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5,
6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5,
3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3,
4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6,
6, 7, 6, 7, 7, 8};
 
 size_t size = _bit.size();
 size_t count = 0;
 for(size_t i = 0; i < size; ++i)
 {
 int value = _bit[i];
 int j = 0;
 while(j < sizeof(_bit[0]))
 {
 unsigned char c = value;
 count += bitCntTable[c];
 ++j;
 value >>= 8;
 }
 }
 return count;
 }
private:
 vector<int> _bit;
size_t _bitCount;
};

位图的应用：

1. 快速查找某个数据是否在一个集合中

2. 排序 + 去重

3. 求两个集合的交集、并集等

4. 操作系统中磁盘块标记

---

2、布隆过滤器

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

比如先插入baidu，hash对应出地址1、4、5

再插入wangyi，对应1、2、6

此时如果要查询tengxun，对应的是1、3、5，因为3的位置为0，所以一定不存在tengxun，而因为每个位置都会被覆盖会出现即使没有插入baidu，1、4、5位置也有可能会因为多个值的插入而被置1导致baidu存在，而实际上并没有插入，所以布隆过滤器很难判断一个值是否一定存在。同理，布隆过滤器也不能直接删除，因为可能会影响到其他的元素。

布隆过滤器实现：

struct BKDRHash
{
 size_t operator()(const string& s)
 {
 // BKDR
 size_t value = 0;
 for (auto ch : s)
 {
 value *= 31;
 value += ch;
 }
 return value;
 }
};
struct APHash
{
 size_t operator()(const string& s)
 {
 size_t hash = 0;
 for (long i = 0; i < s.size(); i++)
 {
 if ((i & 1) == 0)
 {
 hash ^= ((hash << 7) ^ s[i] ^ (hash >> 3));
 }
 else
 {
 hash ^= (~((hash << 11) ^ s[i] ^ (hash >> 5)));
 }
 }
 return hash;
 }
};
struct DJBHash
{
 size_t operator()(const string& s)
 {
 size_t hash = 5381;
 for (auto ch : s)
 {
 hash += (hash << 5) + ch;
 }
 return hash;
 }
};
template<size_t N,
size_t X = 5,
class K = string,
class HashFunc1 = BKDRHash,
class HashFunc2 = APHash,
class HashFunc3 = DJBHash>
class BloomFilter
{
public:
 void Set(const K& key)
 {
 size_t len = X*N;
 size_t index1 = HashFunc1()(key) % len;
 size_t index2 = HashFunc2()(key) % len;
 size_t index3 = HashFunc3()(key) % len;
 /* cout << index1 << endl;
 cout << index2 << endl;
 cout << index3 << endl<<endl;*/
 _bs.set(index1);
 _bs.set(index2);
 _bs.set(index3);
 }
 bool Test(const K& key)
 {
 size_t len = X*N;
 size_t index1 = HashFunc1()(key) % len;
 if (_bs.test(index1) == false)
 return false;
 size_t index2 = HashFunc2()(key) % len;
 if (_bs.test(index2) == false)
 return false;
 size_t index3 = HashFunc3()(key) % len;
 if (_bs.test(index3) == false)
 return false;
 return true;  // 存在误判的
 }
 // 不支持删除，删除可能会影响其他值。
 void Reset(const K& key);
private:
 bitset<X*N> _bs;
};