結合了點陣圖和Hash表兩者的優點，點陣圖的優點是節省空間，但是隻能處理整型值一類的問題，無法處理字串一類的問題，而Hash表卻恰巧解決了點陣圖無法解決的問題，然而Hash太浪費空間。針對這個問題，布隆提出了一種基於二進位制向量和一系列隨機函式的資料結構-布隆過濾器。它的空間利用率和時間效率是很多演算法無法企及的，但是它也有一些缺點，就是會有一定的誤判率並且不支援刪除操作。
實現程式碼：

#include"comm.h"
#include"BitMap.h"
//布隆過濾器
template <class T, class HashFun1 =  __HashFunc1<T>,
                   class
 
 HashFun2 = __HashFunc2<T>,
                   class HashFun3 = __HashFunc3<T>,
                   class HashFun4 = __HashFunc4<T>,
                   class HashFun5 = __HashFunc5<T> >
class BloomFilter
{
public:
    BloomFilter(size_t size)
        : _bmp(size)
        , _capacity(size
 
)
    {}
    void Insert(string str)
    {

        size_t idx1 = _HashFunc1()(str) % _capacity;
        size_t idx2 = _HashFunc2()(str) % _capacity;
        size_t idx3 = _HashFunc3()(str) % _capacity;
        size_t idx4 = _HashFunc4()(str) % _capacity;
        size_t idx5 = _HashFunc5()(str) % _capacity;
        _bmp.set(idx1
 
);
        _bmp.set(idx2);
        _bmp.set(idx3);
        _bmp.set(idx4);
        _bmp.set(idx5);
    }
    bool Find(string str)
    {
        size_t idx1 = _HashFunc1()(str) % _capacity;
        size_t idx2 = _HashFunc2()(str) % _capacity;
        size_t idx3 = _HashFunc3()(str) % _capacity;
        size_t idx4 = _HashFunc4()(str) % _capacity;
        size_t idx5 = _HashFunc5()(str) % _capacity;
        if (!_bmp.Test(idx1)
            || !_bmp.Test(idx2)
            || !_bmp.Test(idx3)
            || !_bmp.Test(idx4)
            || !_bmp.Test(idx5))
            return false;
        else
        if (_bmp.set(idx1) &&
            _bmp.set(idx2) &&
            _bmp.set(idx3) &&
            _bmp.set(idx4) &&
            _bmp.set(idx5))
            return true;
    }
private:
    Bitmap _bmp;
    size_t _capacity;
};

comm.h

#include<string>
template<class K>
class HashFunDef
{
public:
    size_t operator()(const K& key)
    {
        return key;
    }
};
template<>
class HashFunDef<string>
{
public:
    size_t operator()(const string& key)
    {
        return BKDRHash(key.c_str());
    }
};

static size_t BKDRHash(const char * str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313
    unsigned int hash = 0;
    while (*str)
    {
        hash = hash * seed + (*str++);
    }
    return (hash & 0x7FFFFFFF);
}
size_t SDBMHash(const char* 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;
}

size_t RSHash(const char *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;
}

size_t APHash(const char* str)
{
    register size_t hash = 0;
    size_t ch;
    for (long i = 0; ch = (size_t)*str++; i++)
    {
        if (0 == (i & 1))
        {
            hash ^= ((hash << 7) ^ (hash >> 3));
        }
        else
        {
            hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
        }
    }

    return hash;
}

size_t JSHash(const char* str)
{
    if (!*str)
        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 __HashFunc1
{
    size_t operator()(const K& key)
    {
        return BKDRHash(key.c_str());
    }
};

template<class K>
struct __HashFunc2
{
    size_t operator()(const K& key)
    {
        return SDBMHash(key.c_str());
    }
};

template<class K>
struct __HashFunc3
{
    size_t operator()(const K& key)
    {
        return RSHash(key.c_str());
    }
};

template<class K>
struct __HashFunc4
{
    size_t operator()(const K& key)
    {
        return APHash(key.c_str());
    }
};

template<class K>
struct __HashFunc5
{
    size_t operator()(const K& key)
    {
        return JSHash(key.c_str());
    }
};

BitMap.h

#include<iostream>
using namespace std;
#include<vector>
class Bitmap
{
public:
    Bitmap()
    {}
    Bitmap(size_t size)
    {
        _table.resize((size >> 5) + 1);
    }
    void set(size_t data)
    {
        //將資料所在位元組的位元位置1
        size_t byte = data >> 5;
        size_t bit = data % 32;
        _table[byte] |= 1 << bit;
    }
    void ReSet(size_t data)
    {
        //將資料所在位元組的位元位置0
        size_t byte = data >> 5;
        size_t bit = data % 32;
        _table[byte] &= ~(1 << bit);
    }
    //所查data是否存在
    bool test(size_t data)
    {
        size_t byte = data >> 5;
        size_t bit = data % 32;
        //1<<bit將其餘位置0，除bit位
        if ((1 << bit)&_table[byte])
            return true;
        return false;
    }
private:
    vector<int>  _table;

};