bloom filter

最新推荐文章于 2024-11-16 22:28:06 发布

原创最新推荐文章于 2024-11-16 22:28:06 发布 · 627 阅读

1 ·

CC 4.0 BY-SA版权

算法&&数据结构专栏收录该内容

11 篇文章

订阅专栏

布隆过滤器是一种空间效率高的概率型数据结构，用于判断一个元素是否在一个集合中，存在误识别率。文章介绍了其原理、错误率计算公式、优化方法如折叠和动态扩展，并提供了Java源码示例。它常用于大规模数据存储的场景，但不适合需要精确查找的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

布隆过滤器的原理不难理解。相对于一个精简的HashMap的数据结构，存入数据的时候，不存入数据本身，只保存其Hash的值。可以用于判断该数据是否存在。其本质是用Hash对数据进行"有损压缩"的位图索引。
如果想判断一个元素是不是在一个集合里，一般想到的是将所有元素保存起来，然后通过比较确定。链表，树等等数据结构都是这种思路. 但是随着集合中元素的增加，我们需要的存储空间越来越大，检索速度也越来越慢(O(n),O(logn))。

这时候就可以利用哈希表这个数据结构（它可以通过一个Hash函数将一个元素映射成一个位阵列（Bit array）中的一个点）。这样一来，我们只要看看这个点是不是1就知道可以集合中有没有它了。这就是Bloom Filter的基本思想。

但这时，哈希冲突会是一个问题：假设Hash函数是良好的，如果我们的位阵列长度为m个点，那么如果我们想将冲突率降低到例如 1%, 这个散列表就只能容纳m/100个元素。显然这就不叫空间效率了（Space-efficient）了。解决方法也简单，就是使用多个Hash，如果它们有一个说元素不在集合中，那肯定就不在。如果它们都说在，虽然也有一定可能性它们都在说谎，不过直觉上判断这种事情的概率是比较低的。这种多个Hash组成的数据结构就叫Bloom Filter。

一个Bloom Filter是基于一个m位的位向量（b1,…bm），这些位向量的初始值为0。另外，还有一系列的hash函数（h1,…hk），这些hash函数的值域属于1~m。下图是一个bloom filter插入x,y,z并判断某个值w是否在该数据集的示意图：

上图中，m=18，k=3；插入x是，三个hash函数分别得到蓝线对应的三个值，并将对应的位向量改为1，插入y，z时，类似的，分别将红线，紫线对应的位向量改为1。查找时，当查找x时，三个hash值对应的位向量都为1，因此判断x在此数据集中。y，z也是如此。但是查找w时，w有个hash值对应的位向量为0，因此可以判断不在此集合中。但是，假如w的最后那个hash值比上图中的大1，这是就会认为w在此集合中，而事实上，w可能不在此集合中，因此可能出现误报。显然的，插入数据越多，1的位数越多，误报的概率越大。

错误率

如果用来存放Hash值的槽位足够多，那么碰撞的概率就会比较小。但是所占用的空间就会比较大。所以当分配空间的时候，需要通过你能容忍的错误率和需要存放的Key的数量来指定。如果所需存储的Key数量是n,错误率是p，所需要的槽位是m。有计算槽位的公式 m = − n ln ⁡ p ( ln ⁡ 2 ) 2 .。也有计算概率的公式， p = 1 − e − ( m / n ln ⁡ 2 ) n / m ( m / n ln ⁡ 2 ) 这些公式当然不是我推导出来的，想来也不太难，就不赘述推导过程了。下面这张图可以很好的表示n和m取不同的值的时候，p的值。

根据这张图。我们可以计算出所需要的内存使用量。如果把错误率控制在1%以下的话。

保存key数	占用空间
1万	64KB
10万	1MB
100万	16MB
1000万	256MB
1亿	<4GB

可见占用的空间在key的数量在百万级别还是很划算的，但到了上亿的级别就不那么划算了。

Bloom Filter的插入和查询都是常数级别的，所以最大的问题就是占用内存过大。而初次分配内存的时候，如果没有能够确认槽位的个数。如果分配过多会导致内存浪费，太少就会倒是错误率过高。下面提到的两个改进方案可以分别解决这两个问题。

折叠

折叠是指当你初始化一个Bloom Filter的时候，可以分配足够大的槽位，等到Key导入完毕后，可以对使用的槽位进行合并操作。具体方法是将槽位切成两半，一边完全叠加到另一边上。减少内存的使用量。检查key的代码要做稍许改变。例：

通过这个操作，可以使实际使用的内存量减半。多执行几次，能减少更多。

动态扩展

通过折叠操作，可以解决分配过大的问题，但是如果一开始分配过小，就需要扩展槽位才行。如何扩展呢？只要按原尺寸再建立一个Bloom Filter数组。原来的那个保存起来，不再写入。有新的写请求的时候，就将数据写入到新的那个Bloom Filter数组里面去。等到新的也写满了，就再建立一个，以此类推。查询的时候，就需要遍历每一个Bloom Filter数组才行。但因为查询一个Bloom Filter数组的速度很快，查询一组Bloom Filter数组也不会太影响性能。使用这种手段可以是Bloom Filter的大小可以轻易的扩展。但这样做有个的缺陷，就是错误率会随着数组的增加而上升，因为实际的数组长度并没有增加。

通过上面的两个方法，就可以解决BloomFilter的分配内存的问题。但无论哪种方法都有自己局限性，折叠每次只能减半，不是很精确。动态增加的方法会造成错误率增加。最好还是能预先估计到这个BloomFilter的容量。

附：这里有一个布隆过滤器的PHP扩展，http://bbs.phpchina.com/thread-254492-1-3.html。
另外，此算法也是各大互联网公司热衷的面试题之一。我没记错的话，这个应该是百度的某个笔试题。

假设有A,B两个文件，文件里面都是url地址，各有10亿条，如何找出AB两个文件里面都存在的Url。(内存装不下任何一个文件的十分之一）

吴军的《数学之美》也有讲解。

下面贴Java源码，已注释。

import java.util.BitSet;

//传统的Bloom filter 不支持从集合中删除成员。

//Counting Bloom filter由于采用了计数，因此支持remove操作。

//基于BitSet来实现，性能上可能存在问题

public class SimpleBloomFilter {

    //DEFAULT_SIZE为2的25次方

    private static final int DEFAULT_SIZE = 2 << 24;

    /* 不同哈希函数的种子，一般应取质数,seeds数据共有7个值，则代表采用7种不同的HASH算法 */

    private static final int[] seeds = new int[] { 5, 7, 11, 13, 31, 37, 61 };

    //BitSet实际是由“二进制位”构成的一个Vector。假如希望高效率地保存大量“开－关”信息，就应使用BitSet.

    //BitSet的最小长度是一个长整数（Long）的长度：64位

    private BitSet bits = new BitSet(DEFAULT_SIZE);

    /* 哈希函数对象 */

    private SimpleHash[] func = new SimpleHash[seeds.length];



    public static void main(String[] args) {

       String value = "stone2083@yahoo.cn";

       //定义一个filter，定义的时候会调用构造函数，即初始化七个hash函数对象所需要的信息。

       SimpleBloomFilter filter = new SimpleBloomFilter();

       //判断是否包含在里面。因为没有调用add方法，所以肯定是返回false

       System.out.println(filter.contains(value));

       filter.add(value);

       System.out.println(filter.contains(value));

    }

    //构造函数

    public SimpleBloomFilter() {

       for (int i = 0; i < seeds.length; i++) {

           //给出所有的hash值，共计seeds.length个hash值。共7位。

           //通过调用SimpleHash.hash(),可以得到根据7种hash函数计算得出的hash值。

           //传入DEFAULT_SIZE(最终字符串的长度），seeds[i](一个指定的质数)即可得到需要的那个hash值的位置。

           func[i] = new SimpleHash(DEFAULT_SIZE, seeds[i]);

       }

    }



    // 将字符串标记到bits中，即设置字符串的7个hash值函数为1

    public void add(String value) {

       for (SimpleHash f : func) {

           bits.set(f.hash(value), true);

       }

    }



    //判断字符串是否已经被bits标记

    public boolean contains(String value) {

       //确保传入的不是空值

       if (value == null) {

           return false;

       }

       boolean ret = true;

       //计算7种hash算法下各自对应的hash值，并判断

       for (SimpleHash f : func) {

           //&&是boolen运算符，只要有一个为0，则为0。即需要所有的位都为1，才代表包含在里面。

           //f.hash(value)返回hash对应的位数值

           //bits.get函数返回bitset中对应position的值。即返回hash值是否为0或1。

           ret = ret && bits.get(f.hash(value));

       }

       return ret;

    }

    /* 哈希函数类 */

    public static class SimpleHash {

       //cap为DEFAULT_SIZE的值，即用于结果的最大的字符串长度。

       //seed为计算hash值的一个给定key，具体对应上面定义的seeds数组

       private int cap;

       private int seed;



       public SimpleHash(int cap, int seed) {

           this.cap = cap;

           this.seed = seed;

       }



       //计算hash值的具体算法,hash函数，采用简单的加权和hash

       public int hash(String value) {

           //int的范围最大是2的31次方减1，或超过值则用负数来表示

           int result = 0;

           int len = value.length();

           for (int i = 0; i < len; i++) {

              //数字和字符串相加，字符串转换成为ASCII码

              result = seed * result + value.charAt(i);

              //System.out.println(result+"--"+seed+"*"+result+"+"+value.charAt(i));

           }

       //  System.out.println("result="+result+";"+((cap - 1) & result));

       //  System.out.println(414356308*61+'h');  执行此运算结果为负数，为什么？

           //&是java中的位逻辑运算，用于过滤负数（负数与进算转换成反码进行）。

           return (cap - 1) & result;

       }

    }

}

结论:

测试	m/n	K（括号内为最优解）	数据基数	误判数	误判率	理论值	用时（单位：秒）	一次判定时间(单位：微秒)	一次Hash时间(单位：微秒.估参考)
1	20	6(14)	1000W	3035	0.03035%	0.0303%	25	2.5	0.417
2	20	6(14)	2000W	5839	0.029%	0.0303%	51	2.55	0.425
3	20	14(14)	1000W	605	0.00605%	0.014%	37	3.7	0.265
4	20	14(14)	2000W	1224	0.00612%	0.014%	84	4.2	0.3
5	20	20(14)	1000W	914	0.00914%	不计算	48	4.8	0.24
6	20	20(14)	2000W	1881	0.00941%	不计算	99	4.95	0.2475
7	10	7（7）	1000w	517854	0.786%	0.819%	41	4.1	0.59
8	5	3（3）	1000w	901411	9.014%	9.2%	31	3.1	1.033
9	2	1(1)	1000w	3910726	39.107%	39.3%	29	2.9	2.9
10	2	2(1)	1000w	3961065	39.61%	40%	30	3.0	3.0
11	2	5(1)	1000w	6436696	64.37%	不计算	76	7.6	1.52