布隆过滤器-----时间+空间
最近在研究哈希表，写了闭散列和开散列的代码，哈希表的查找效率确实比较高，但是我发现哈希表的空间效率却有点低，一个好点的哈希表估计能达到50%的空间利用率吧。
我们知道STl中有一种数据结构叫做 bitset 个人觉得叫 bitmap 会更形象一点（这里不去关系这个了），位图是具有很高的空间效率的数据结构，在处理有些大数据的时候能够发挥出很大的作用。
看到这里应该懂我了吧，既然一个时间快，一个节约空间，那么你们在一起吧----------这就是布隆过滤器！一种时间和空间都比较高效的数据结构。布隆过滤器的设计原理是：使用 k 个哈希函数对同一个key进行定址，在bitmap中将各个哈希函数产生的index都置为1，这样就大大降低了哈希冲突（哈希冲突是不能完全避免的），此话怎讲呢？当我们去查找一个key是否存在的时候，也是通过使用一系列的哈希函数产生index，查看该index对应的位图位置是否为1，来判断该key是否出现过。结论如下：
1.若有哈希函数产生的 index 对应的位置不为 1 ，则说明该 key 没有出现过
2.若所有哈希函数产生的 index 对应的位置都为 1，我们可以推测该 key 有很大的概率出现过，因为哈希函数产出的 index 有一定的错误率的
布隆过滤器的应用还是比较广泛的，比如谷歌就使用到了布隆过滤来屏蔽骚扰邮箱，因为光光靠哈下表不能满足需求，举例说明一下吧，十亿个邮箱的URL所需要的存储空间大约16G吧，这么大的内存一般计算机是不能达到的，而使用布隆过滤器就能很好的解决问题了。不过布隆过滤器还是有缺点的，就是当bitmap中被置为1的位的个数接近总数目的时候，就容易产生错误，所以使用的时候要估计一下空间问题。
我实现了一个简单的布隆过滤器，用来判断string是否出现在其中，我使用了5个哈希函数来产生index，这些哈希函数都是一些经过测试的比较高效的字符哈希函数，我的项目结构如下：
其中包括了三个头文件BitMap，BloomFilter，commom：BitMap实现了一个位图，commom中包含了一些可以复用的字符串哈希函数，BloomFilter中实现布隆过滤器：
BitMap.h
#pragma once
#include <iostream>
#include <vector>
using namespace std;
class BitMap
{
public:
BitMap(size_t size)
{
_array.resize((size>>5) + 1);
}
void Set(size_t num)
{
size_t index = num>>5;
size_t pos = num % 32;
_array[index] |= (1 << pos);
}
void Reset(size_t num)
{
size_t index = num>>5;
size_t pos = num % 32;
_array[index] &= ~(1 << pos);
}
bool Test(size_t num)
{
size_t index = num>>5;
size_t pos = num % 32;
return _array[index] & (1 << pos);
}
~BitMap()
{}
private:
vector<size_t> _array;
};
commom.h
/*
* commom 头文件主要存放公共接口函数，提高代码的复用性，例如常见的字符哈系函数
*
*create by admin-zou in 2015/5/13
*
*/
#pragma once
//素数表
const int HashSize = 28;
static const unsigned long PrimeList[HashSize] = {
53ul, 97ul, 193ul, 389ul, 769ul, 1543ul, 3079ul, 6151ul,12289ul,
24593ul, 49157ul, 98317ul, 196613ul, 393241ul, 786433ul,1572869ul,
3145739ul, 6291469ul, 12582917ul, 25165843ul, 50331653ul,100663319ul,
201326611ul, 402653189ul, 805306457ul, 1610612741ul, 3221225473ul,4294967291ul
};
size_t GetNextPrimeNum(size_t size)
{
for(size_t i = 0; i < HashSize; ++i)
{
if(size < PrimeList[i])
{
return PrimeList[i];
}
}
return PrimeList[HashSize-1];
}
// 字符哈系函数
template<class K>
size_t BKDRHash(const K *str)
{
register size_t hash = 0;
while (size_t ch = (size_t)*str++)
{
hash = hash * 131 + ch; // 也可以乘以31、131、1313、13131、131313..
}
return hash;
}
template<class K>
struct hashFunc1
{
size_t operator() (const char* key)
{
return BKDRHash(key);
}
};
template<class K>
size_t SDBMHash(const K *str)
{
register size_t hash = 0;
while (size_t ch = (size_t)*str++)
{
hash = 65599 * hash + ch;
//hash = (size_t)ch + (hash << 6) + (hash << 16) - hash;
}
return hash;
}
template<class K>
struct hashFunc2
{
size_t operator() (const char* key)
{
return SDBMHash(key);
}
};
template<class K>
size_t RSHash(const K *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>
struct hashFunc3
{
size_t operator() (const char* key)
{
return RSHash(key);
}
};
template<class K>
size_t APHash(const K *str)
{
register size_t hash = 0;
size_t ch;
for (long i = 0; ch = (size_t)*str++; i++)
{
if ((i & 1) == 0)
{
hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
}
else
{
hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
}
}
return hash;
}
template<class K>
struct hashFunc4
{
size_t operator() (const char* key)
{
return APHash(key);
}
};
template<class K>
size_t JSHash(const K *str)
{
if (!*str) // 这是由本人添加，以保证空字符串返回哈希值0
return 0;
register size_t hash = 1315423911;
while (size_t ch = (size_t)*str++)
{
hash ^= ((hash << 5) + ch + (hash >> 2));
}
return hash;
}
template<class K>
struct hashFunc5
{
size_t operator() (const char* key)
{
return JSHash(key);
}
};
最后
BloomFilter.h
/* 布隆过滤器
*
* Bloom Filter 是一种空间效率很高的随机数据结构，Bloom filter 可以看做是对bit-map 的扩展, 它的原理是：
*当一个元素被加入集合时，通过K个Hash函数将这个元素映射成一个位阵列（Bit array）中的 K 个点，把它们置为 1。检索时，我们只要看看这些点是不是都是 1 就（大约）知道集合中有没有它了：
* 如果这些点有任何一个 0，则被检索元素一定不在；
* 如果都是 1，则被检索元素很可能在。
*
* create by admin-zou in 2016/5/13
*/
#pragma once
#include <iostream>
#include <string>
#include "BitMap.h"
#include "common.h"
using namespace std;
template <class K,
class HashFuncer1 = hashFunc1<K>,
class HashFuncer2 = hashFunc2<K>,
class HashFuncer3 = hashFunc3<K>,
class HashFuncer4 = hashFunc4<K>,
class HashFuncer5 = hashFunc5<K>
>
class BloomFiter
{
public:
BloomFiter(size_t size)
:_capacity(GetNextPrimeNum(size))
,_bt(_capacity)
{}
void Add(const K& key)
{
size_t index1 = HashFuncer1()(key.c_str()) % _capacity;
_bt.Set(index1);
//cout<<index1<<endl;
size_t index2 = HashFuncer2()(key.c_str()) % _capacity;
_bt.Set(index2);
//cout<<index2<<endl;
size_t index3 = HashFuncer3()(key.c_str()) % _capacity;
_bt.Set(index3);
//cout<<index3<<endl;
size_t index4 = HashFuncer4()(key.c_str()) % _capacity;
_bt.Set(index4);
//cout<<index4<<endl;
size_t index5 = HashFuncer5()(key.c_str()) % _capacity;
_bt.Set(index5);
//cout<<index5<<endl;
}
bool Check(const K& key)
{
size_t index1 = HashFuncer1()(key.c_str()) % _capacity;
//cout<<index1<<endl;
if(! _bt.Test(index1))
{
return false;
}
size_t index2 = HashFuncer2()(key.c_str()) % _capacity;
//cout<<index2<<endl;
if(! _bt.Test(index2))
{
return false;
}
size_t index3 = HashFuncer3()(key.c_str()) % _capacity;
//cout<<index3<<endl;
if(! _bt.Test(index3))
{
return false;
}
size_t index4 = HashFuncer4()(key.c_str()) % _capacity;
//cout<<index4<<endl;
if(! _bt.Test(index4))
{
return false;
}
size_t index5 = HashFuncer5()(key.c_str()) % _capacity;
//cout<<index5<<endl;
if(! _bt.Test(index5))
{
return false;
}
return true;
}
private:
size_t _capacity;
BitMap _bt;
};
以上就是布隆过滤器的实现了，我觉得我们学以致用，在以后的 IT 生涯中要会使用它。
--Just do IT