数据结构-布隆过滤器

布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。

如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定。链表、树、散列表（哈希表，Hash table）等数据结构都是这种思想。但是随着集合中元素的增加，我们需要的存储空间越来越大。同时检索速度也会越来越慢。

• 
  

• 原理

Bloom Filter 是一种空间效率很高的随机数据结构，Bloom Filter 可以看做是对bit-map的扩展，它的原理是：当一个元素被加入集合中时，通过K个hash函数将这个元素映射成一个位阵列（Bit array）中的K个点，将它们置成1. 检索时，我们只需要看这些点是不是都是1就能（大约）知道集合中有没有它：如果这些点中有任何一个0，则被检索元素一定不在；如果都是1，则被检索元素很可能在。 

• 优点

  它的优点是空间效率和查询时间都远远超过一般的算法，布隆过滤器存储空间和插入\查询时间都是O(K),另外，散列函数相互之间没有关系，方便硬件并行实现，布隆过滤器不需要存储元素本身，在某些对保密要求非常严格的场合有优势。

• 缺点 
  

   布隆过滤器的缺点和优点同样明显。误算率是其中之一。随着存入元素的增加，误算率随之增加。但是元素数量太少，则使用散列就可以了。 
  一般情况下不能从布隆过滤器中删除元素，我们很容易想到把位数组变成整数数组，每插入一个元素相应的计数器加1，这样删除元素时将计数器减掉就可以了。然而要保证安全地删除元素并非这么简单。首先我们必须保证删除的元素的确存在布隆过滤器里面，另外计数器回绕也会造成问题。

  bloom_filter.h
  #pragma once
  #include"hash.h"
  #include"bitmap.h"
  
  template <class T>
  struct _HashFunk1
  {
      size_t operator()(const T& key)
      {
          return BKDRHash<T>(key.c_str());
      }
  };
  
  template <class T>
  struct _HashFunk2
  {
      size_t operator()(const T& key)
      {
          return SDBMHash<T>(key.c_str());
      }
  };
  
  template <class T>
  struct _HashFunk3
  {
      size_t operator()(const T& key)
      {
          return RSHash<T>(key.c_str());
      }
  };
  
  template <class T>
  struct _HashFunk4
  {
      size_t operator()(const T& key)
      {
          return APHash<T>(key.c_str());
      }
  };
  
  template <class T>
  struct _HashFunk5
  {
      size_t operator()(const T& key)
      {
          return JSHash<T>(key.c_str());
      }
  };
  
  template <class T,
  class HashFunk1 = _HashFunk1<T>,
  class HashFunk2=_HashFunk2<T>,
  class HashFunk3 =_HashFunk3<T>,
  class HashFunk4 = _HashFunk4<T>,
  class HashFunk5 = _HashFunk5<T>>
  class Bloom_Filter
  {
  public:
      Bloom_Filter(size_t n)
          :_bp(10*n)
          , _range(10*n)
      {}
  
      void Set(const T& key)
      {
          _bp.Set(HashFunk1()(key) % _range);
          _bp.Set(HashFunk2()(key) % _range);
          _bp.Set(HashFunk3()(key) % _range);
          _bp.Set(HashFunk4()(key) % _range);
          _bp.Set(HashFunk5()(key) %   _range);
      }
  
      bool Exist_bloom(const T& key)
      {
          if (!_bp.Exist(HashFunk1()(key) % _range))
              return false;
          if (!_bp.Exist(HashFunk2()(key) % _range))
              return false;
          if (!_bp.Exist(HashFunk3()(key) % _range))
              return false;
          if (!_bp.Exist(HashFunk4()(key) % _range))
              return false;
          if (!_bp.Exist(HashFunk5()(key) % _range))
              return false;
          return true;
      }
  protected:
      Bitmap _bp;
      size_t _range;
  };
    
    
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
    
    
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91

  bitmap.h
  #pragma once
  
  #include<vector>
  #include<iostream>
  
  class Bitmap
  {
  public:
      Bitmap(size_t size = 1024)
      {
          _vt.resize((size>>5)+1);
      }
  
      //设置某个数的位置1
      void Set(size_t num)
      {
          size_t index = num >> 5;
          size_t pos = num % 32;
          _vt[index] |= (1 << pos);//从右至左依次增大
          //_vt[index] |= (1<<(31-pos));//从左至右依次增大
      }
  
      //设置某个数的位置为0
      void Reset(size_t num)
      {
          size_t index = num >> 5;
          size_t pos = num % 32;
          _vt[index] &= (~(1 << pos));
      }
  
      //判断一个数是否存在
  
      bool Exist(size_t num)
      {
          size_t index = num >> 5;
          size_t pos = num % 32;
          return _vt[index] & (1 << pos);
      }
  
  private:
      std::vector<size_t> _vt;
  };