布隆过滤器

一、原理

哈希表：元素的值作为位数组的下标，位数组的长度取决于元素的最大值

布隆过滤器：将元素的值模取位数组的长度，多个哈希值决定一个元素的存在与否。

具体的看这里：http://www.cnblogs.com/allensun/archive/2011/02/16/1956532.html

二、例子

数组：int arr[] = { 1,2,3,4,5 };

需要两个参数

       数组长度：sz=5;     精确度:p=0.01;

根据公式

m=-(n*log(p) / (log(2)*log(2)))=75
k=0.7*(tmp_m / n)=7

1.根据参数构建布隆过滤器

class Bloom
{
public:
	Bloom(int n, double p)
	{
		double tmp_m = 0;
		double tmp_k = 0;
		tmp_m = -(n*log(p) / (log(2)*log(2)))+4; //根据精确度p计算位数组长度m
		tmp_k = 0.7*(tmp_m / n); //根据m,n的值计算哈希函数的个数k
		m = (int)tmp_m/8;//位数组转换成字符数组
		k = (int)tmp_k;
		arr = new char[m];
		memset(arr, 0, m);
	}

2.哈希

bool Hash(int d,bool key)
    {
        bool re = true;
        int i = 0;
        int num = d;
        int x = 0;
        int y = 0;
        for (i = 0; i < k; i++)
        {
            num = num*(i+1)+i;//根据i修改输入值，模拟多次独立哈希
            x = num%m; //元素模取字符数组长度，计算下标
            y = num%8; //元素模取8，计算偏移量
            if (key == true)
            {
                arr[x] = arr[x]|(1 << y);
            }
            if (key==false)
            {
                if ((arr[x] & (1 << y))!=(1<<y))
                {
                    re = false;
                }
            }
        }
        return re;
    }

3、测试

void test()
{
	int arr[] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(int);
	int i = 0;
	int d = 20;
	Bloom b(sz, 0.001);
	for (i = 0; i < sz; i++)
	{
		b.Set(arr[i]);
	}
	for (i = 1; i <= 200; i++)
	{
		cout << b.Find(i);
		if (i % 24 == 0)
		{
			cout << endl;
		}
	}	
}





因为布隆滤器的原理是将输入数据映射到长度为M的位数组上
所以数据以m（位数组长度）为周期分布，由于类型转和哈希函数的问题出现了6个错误数据
实际误差6/72大于预定的0.001误差





将k赋值为1，即只有一个哈希函数


误差为0小于0.001







三、完整代码

#pragma once
#include<iostream>
#include<cassert>
#include<cmath>
using namespace std;
class Bloom
{
public:
	Bloom(int n, double p)
	{
		double tmp_m = 0;
		double tmp_k = 0;
		tmp_m = -(n*log(p) / (log(2)*log(2)))+4;
		tmp_k = 0.7*(tmp_m / n);
		m = (int)tmp_m/8;
		k = (int)tmp_k;
		arr = new char[m];
		memset(arr, 0, m);
	}
	void Set(int d)
	{
		Hash(d, true);
	}
	bool Find(int d)
	{
		return Hash(d, false);
	}
protected:
	bool Hash(int d,bool key)
	{
		bool re = true;
		int i = 0;
		int num = d;
		int x = 0;
		int y = 0;
		for (i = 0; i < k; i++)
		{
			num = num*(i+1)+i;
			x = num%m;
			y = num%8;
			if (key == true)
			{
				arr[x] = arr[x]|(1 << y);
			}
			if (key==false)
			{
				if ((arr[x] & (1 << y))!=(1<<y))
				{
					re = false;
				}
			}
		}
		return re;
	}
private:
	char*arr;
	int m;
	int k;
};
void test()
{
	int arr[] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(int);
	int i = 0;
	int d = 20;
	Bloom b(sz, 0.001);
	for (i = 0; i < sz; i++)
	{
		b.Set(arr[i]);
	}
	for (i = 1; i <= 200; i++)
	{
		cout << b.Find(i);
		if (i % 72 == 0)
		{
			cout << endl;
		}
	}	
}
int main()
{
	test();
	return 0;
}