数据结构-布隆过滤器

布隆过滤器(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;
};