精华内容
下载资源
问答
  • 2 计数布隆过滤器 2.1 优点 支持添加和删除 支持计数 2.2 缺点 内存消耗是标准布隆过滤器的3-4倍 3 布谷鸟过滤器 3.1 优点 支持动态新增和删除元素 布谷鸟哈希表更加紧凑,可以更加节省空间,散列确保了高...

    1 标准布隆过滤器

    1.1 优点

    • 支持添加和查询
    • 节省空间

    1.2 缺点

    • 不支持删除操作
    • 布隆过滤器要采用多种哈希函数进行多次哈希

    2 计数布隆过滤器

    2.1 优点

    • 支持添加和删除
    • 支持计数

    2.2 缺点

    • 内存消耗是标准布隆过滤器的3-4倍

    3 布谷鸟过滤器

    3.1 优点

    • 支持动态新增和删除元素
    • 布谷鸟哈希表更加紧凑,可以更加节省空间,散列确保了高空间占用率
    • 布隆过滤器要采用多种哈希函数进行多次哈希,而布谷鸟过滤器只需一次哈希,因此查询效率很高,提供了比标准布隆过滤器更高的查找性能
    • 如果要求错误率小于3%,那么在许多实际应用中,它比布隆过滤器占用的空间更小
    • 比商过滤器(quotient filter,另一种过滤器)之类的替代方案更容易实现

    3.2 缺点

    • 布谷鸟过滤器采用一种备用候选桶的方案,候选桶与首选桶可以通过位置和存储值互相异或得出,这种对应关系要求桶的大小必须是 2 的指数倍
    • 布隆过滤器插入时计算好哈希直接写入位即可,而布谷鸟过滤器在计算后可能会出现当前位置上已经存储了指纹,这时候就需要将已存储的项踢到候选桶,随着桶越来越满,产生冲突的可能性越来越大,插入耗时越来越高,因此其插入性能相比布隆过滤器很差
    • 插入重复元素:布隆过滤器在插入重复元素时并没有影响,只是对已存在的位再置一遍。而布谷鸟过滤器对已存在的值会做踢出操作,因此重复元素的插入存在上限
    • 布谷鸟过滤器的删除并不完美:有上述重复插入的限制,删除时也会出现相关的问题:
      • 删除仅在相同哈希值被插入一次时是完美的
      • 如果元素没有插入便进行删除,可能会出现误删除,这和假阳性率的原因相同
      • 如果元素插入了多次,那么每次删除仅会删除一个值,你需要知道元素插入了多少次才能删除干净,或者循环运行删除直到删除失败为止

    3.3 参数

    • 哈希函数个数(k):哈希个数,取 2 就足够
    • 桶大小(b):每个桶存储多少个指纹
    • 指纹大小(f):每个指纹存储键的哈希值的多少位

    3.4 删除

    布谷鸟过滤器就像计数布隆过滤器,可以通过从哈希表删除相应的指纹删除插入的项。

    展开全文
  • 使用扩展计数布隆过滤器的快速近似哈希表
  • 布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多,...

    简介

    布隆过滤器(Bloom Filter)是1970年由一个叫Bloom的老哥提出的。本质上属于一种数据结构,实际组成是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多,缺点是有一定的误识别率和删除困难。

    思想

    布隆过滤器的原理:当一个元素被加入集合时,通过 K 个散列(hash)函数将这个元素映射成一个位(bit)数组中的 K 个点,把它们置为 1。检索时,我们只要看看这些点是不是都是 1 就(大约)知道集合中有没有它了:如果这些点有任何一个 0,则被检元素一定不在;如果都是 1,则被检元素很可能存在。

    特点

    某条数据一定不存在或可能存在。

    优点

    空间:存储数据使用的位数组,极大节省了空间。若在内存中存储海量数据,提升是很可观的;

    时间:插入、查询的时间复杂度都是O(k),k为hash函数数量;

    效率:哈希函数相互之间没有关系,可以在硬件指令层面并行计算;

    数据加密:布隆过滤器不需要存储元素本身,在某些对保密要求非常严格的场合有优势;

    缺点

    准确率:“某样东西一定不存在或者可能存在”,不能保证100%的准确匹配;

    无法删除数据:只能插入和查询元素,一般情况下不能从布隆过滤器中删除元素。我们很容易想到把位列阵变成整数数组,每插入一个元素相应的计数器加1, 这样删除元素时将计数器减掉就可以了。然而要保证安全的删除元素并非如此简单。首先我们必须保证删除的元素的确在布隆过滤器里面. 这一点单凭这个过滤器是无法保证的。另外计数器回绕也会造成问题。

    在降低误算率方面,有不少工作,使得出现了很多布隆过滤器的变种。

    图解

    网上找的图:

     图三:假设集合里面有3个元素{x, y, z},哈希函数的个数为3。首先将位数组进行初始化,将里面每个位都设置位0。对于集合里面的每一个元素,将元素依次通过3个哈希函数进行映射,每次映射都会产生一个哈希值,这个值对应位数组上面的一个点,然后将位数组对应的位置标记为1。查询W元素是否存在集合中的时候,同样的方法将W通过哈希映射到位数组上的3个点。如果3个点的其中有一个点不为1,则可以判断该元素一定不存在集合中。反之,如果3个点都为1,则该元素可能存在集合中。

    java代码

    布隆过滤器添加元素

    • 将要添加的元素给k个哈希函数
    • 得到对应于位数组上的k个位置
    • 将这k个位置设为1

    布隆过滤器查询元素

    • 将要查询的元素给k个哈希函数
    • 得到对应于位数组上的k个位置
    • 如果k个位置有一个为0,则肯定不在集合中
    • 如果k个位置全部为1,则可能在集合中

    使用google的Guava布隆过滤器

    1.引入:

            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>30.1.1-jre</version>
            </dependency>

    2.使用:

    import com.google.common.base.Charsets;
    import com.google.common.hash.BloomFilter;
    import com.google.common.hash.Funnels;
    
    /**
     * 谷歌开源的Guava布隆过滤器
     * @author yangzihe
     * @date 2021/6/3
     */
    public class GuavaBloomFilter {
        public static void main(String[] args) {
            // 总数量
            int total = 1000000;
            // 默认误判率fpp0.03
            BloomFilter<CharSequence> bf = BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), total);
            // 初始化 total 条数据到过滤器中
            for (int i = 0; i < total; i++) {
                bf.put("" + i);
            }
            // 判断值是否存在过滤器中
            int count = 0;
            for (int i = 0; i < total + 10000; i++) {
                if (bf.mightContain("" + i)) {
                    count++;
                }
            }
            System.out.println("已匹配数量 " + count);// (1000309 - 1000000)/(1000000 + 10000) * 100 ≈ 0.030594059405940593
    
            //指定误判率:万分之一,提高匹配精度
            BloomFilter<CharSequence> bfWithFpp = BloomFilter.create(Funnels.stringFunnel(Charsets.UTF_8), total, 0.0001);
            for (int i = 0; i < total; i++) {
                bfWithFpp.put("" + i);
            }
            int countFpp = 0;
            for (int i = 0; i < total + 10000; i++) {
                if (bfWithFpp.mightContain("" + i)) {
                    countFpp++;
                }
            }
            //误判率 fpp 的值越小,匹配的精度越高。当减少误判率 fpp 的值,需要的存储空间也越大,所以在实际使用过程中需要在误判率和存储空间之间做个权衡。
            System.out.println("指定误判率已匹配数量 " + countFpp);// (1000001 - 1000000)/(1000000 + 10000) * 100 ≈ 0.0001
        }
    }

    布隆过滤器的误判率(FPP):

    • n:要添加的元素数量;
    • k:哈希的次数;
    • m:布隆过滤器的长度(如比特数组的大小);

    布隆过滤器的长度 m 可以根据给定的误判率(FFP)的和期望添加的元素个数 n 的通过如下公式计算:

    最优哈希函数数量k,如果m是数组长度,n是插入的元素个数,k是hash函数的个数,k计算公式如下:

    Guava布隆过滤器源码记录

    BloomFilter的4个成员变量:

        /** bit数组:Guava实现的以CAS方式设置每个bit位 */
        private final LockFreeBitArray bits;
        /** hash函数的个数 */
        private final int numHashFunctions;
        /** guava中将对象转换为byte的通道 */
        private final Funnel<? super T> funnel;
        /** 将byte转换为n个bit的策略,也是bloomfilter hash映射的具体实现 */
        private final Strategy strategy;

    LockFreeBitArray:封装了布隆过滤器底层bit数组的操作。
    numHashFunctions:哈希函数的个数。
    Funnel:它和PrimitiveSink配套使用,能将任意类型的对象转化成Java基本数据类型,默认用java.nio.ByteBuffer实现,最终均转化为byte数组。
    Strategy:strategy是布隆过滤器的哈希策略,即数据如何映射到位数组,其具体方法在BloomFilterStrategies枚举中。代码如下,主要有2个方法,put和mightContain。

        interface Strategy extends java.io.Serializable {
            /** 设置元素 */
            <T> boolean put(T object, Funnel<? super T> funnel, int numHashFunctions, BloomFilterStrategies.LockFreeBitArray bits);
            /** 判断元素是否存在 */
            <T> boolean mightContain(T object, Funnel<? super T> funnel, int numHashFunctions, BloomFilterStrategies.LockFreeBitArray bits);
            ...
        }

    构造函数:

    BloomFilter只有一个私有构造函数,对外提供了5个public重载的create方法,在缺省情况下误判率设定为3%,采用BloomFilterStrategies.MURMUR128_MITZ_64的实现。5个重载的create方法最终实现逻辑:

      @VisibleForTesting
      static <T> BloomFilter<T> create(
          Funnel<? super T> funnel, long expectedInsertions, double fpp, Strategy strategy) {
        checkNotNull(funnel);
        checkArgument(
            expectedInsertions >= 0, "Expected insertions (%s) must be >= 0", expectedInsertions);
        checkArgument(fpp > 0.0, "False positive probability (%s) must be > 0.0", fpp);
        checkArgument(fpp < 1.0, "False positive probability (%s) must be < 1.0", fpp);
        checkNotNull(strategy);
    
        if (expectedInsertions == 0) {
          expectedInsertions = 1;
        }
        /*
         * TODO(user): Put a warning in the javadoc about tiny fpp values, since the resulting size
         * is proportional to -log(p), but there is not much of a point after all, e.g.
         * optimalM(1000, 0.0000000000000001) = 76680 which is less than 10kb. Who cares!
         */
        long numBits = optimalNumOfBits(expectedInsertions, fpp);
        int numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, numBits);
        try {
          return new BloomFilter<T>(new LockFreeBitArray(numBits), numHashFunctions, funnel, strategy);
        } catch (IllegalArgumentException e) {
          throw new IllegalArgumentException("Could not create BloomFilter of " + numBits + " bits", e);
        }
      }

    该方法接受4个参数:funnel是插入数据的Funnel,expectedInsertions是期望插入的元素总个数n,fpp即期望误判率p,strategy即哈希策略。

    m:位数组的长度;

    k:哈希函数的个数;

    由上可知,m和k分别通过optimalNumOfBits()方法和optimalNumOfHashFunctions()方法来估计。

      @VisibleForTesting
      static long optimalNumOfBits(long n, double p) {
        if (p == 0) {
          p = Double.MIN_VALUE;
        }
        return (long) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
      }
    
      @VisibleForTesting
      static int optimalNumOfHashFunctions(long n, long m) {
        // (m / n) * log(2), but avoid truncation due to division!
        return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
      }

                                                          

    optimalNumOfHashFunctions()方法的逻辑                         optimalNumOfBits()方法的逻辑

    如果指定期望误判率p,那么最优的m值与期望元素数n呈线性关系。
    最优的k值实际上只与p有关,与m和n都无关,即:

    所以,在创建BloomFilter时,确定合适的p和n值很重要。

    在BloomFilterStrategies枚举中定义了两种哈希策略,都基于著名的MurmurHash算法,分别是MURMUR128_MITZ_32和MURMUR128_MITZ_64。

    参考:https://www.jianshu.com/p/bef2ec1c361f

    Guava 提供的布隆过滤器的实现还是很不错的,但是它有一个重大的缺陷就是只能单机使用(另外,容量扩展也不容易),而现在互联网一般都是分布式的场景。为了解决这个问题,我们就需要用到 Redis 中的布隆过滤器了。然后,为了解决布隆过滤器无法删除数据的问题,引入了counting bloom filter计数式布隆过滤器。redis布隆、counting布隆有缘再续吧。。。

     

    展开全文
  • 计数布隆过滤器(counting bloom filter)Redis实现分析

    Bloom filter简介

    关于布隆过滤器有众多文章做过介绍,这里不作详解,仅贴出简介:Bloom filter 是由 Howard Bloom 在 1970 年提出的二进制向量数据结构,它具有很好的空间和时间效率,被用来检测一个元素是不是集合中的一个成员。如果检测结果为是,该元素不一定在集合中;但如果检测结果为否,该元素一定不在集合中。因此Bloom filter具有100%的召回率。这样每个检测请求返回有“在集合内(可能错误)”和“不在集合内(绝对不在集合内)”两种情况,可见 Bloom filter 是牺牲了正确率和时间以节省空间。
    在这里插入图片描述
    Bloom filter 优点就是它的插入和查询时间都是常数,另外它查询元素却不保存元素本身,具有良好的安全性。它的缺点也是显而易见的,当插入的元素越多,错判“在集合内”的概率就越大了,另外 Bloom filter 也不能删除一个元素,因为多个元素哈希的结果可能在 Bloom filter 结构中占用的是同一个位,如果删除了一个比特位,可能会影响多个元素的检测。

    Counting Bloom filter

    标准Bloom filter对于需要精确检测结果的场景将不再适用,而带计数器的Bloom filter的出现解决了这个问题。Counting Bloom filter实际只是在标准Bloom filter的每一个位上都额外对应得增加了一个计数器,在插入元素时给对应的 k (k 为哈希函数个数)个 Counter 的值分别加 1,删除元素时给对应的 k 个 Counter 的值分别减 1。
    在这里插入图片描述
    Counting Bloom Filter通过多占用几倍的存储空间的代价,给Bloom Filter增加了删除操作。这其中最关键的问题是Counting Bloom filter需要增加多少存储量?在论文中给出了相关计算,假设counter数组的长度为m(对应bloom filter的位数组),Ci表示counter数组中第i个counter的大小,即哈希函数映射到第i位的次数,则每个counter最少位数N为:
    在这里插入图片描述
    SBF(Spectral Bloom Filter)作为Counting Bloom Filter的一种实现,将所有counter排成一个位串,counter之间完全不留空隙,然后通过建立索引结构来访问counter,并达到了只使用O(N) + O(m)位的存储目标,O(m)的构建时间。虽然SBF解决了动态counter的存储问题,但其引入了复杂的索引结构,这让每个counter的访问变得复杂而耗时。

    Dynamic Count Filter

    为改进SBF的缺点,人们又发明了DCF(Dynamic Count Filter),其使用两个数组来存储所有的counter,它们的长度都为m(即bloom filter的位数组长度)。第一个数组是一个基本的CBF(即下图中的CBFV,counting bloom filter vector),counter的长度固定,为x = log(M/n),其中M是集合中所有元素的个数,n为集合中不同元素的个数。第二个数组用来处理counter的溢出(即下图中的OFV,overflow vector),数组每一项的长度并不固定,根据counter的溢出情况动态调整。
    在这里插入图片描述
    在查询一个counter时,DCF要求两次内存访问。假设想查询位置为j的counter的值,我们先读出CBFV和OFV的值,分别为Cj和OFj,那么counter的值就可以表示为Vj = (2x×OFj + Cj)。

    在集合增加元素时,如果OFV的最大值从2x – 1增加到2x,OFV就需要给每一项增加1位,否则就会溢出。对应的,当OFV的最大值从2x减少到2x – 1时,OFV就需要减少1位。每次OFV大小改变的时候都需要重新创建一个OFV数组,然后把旧OFV数组的值拷贝到新建的OFV数组中,最后把旧OFV数组的空间释放掉。对于减少的情况,可以采用一些策略延迟OFV的重建,以避免一些临时性的减少导致OFV反复重建。

    基于Redis的实现

    鉴于单机有内存限制,我们不禁就会想到使用外部存储来实现,其中Redis是较好的选择。Redis有如下优点:1. 性能优异,2.接口功能丰富,3.可靠稳定。

    对于DCF的Redis实现,最简单的就是采用standalone模式,主要是因为其能方便支持Lua script并使用事务,另外还需要在客户端实现Sharding分片算法。但其有个缺点就是需要在开始时规定Redis实例数量,如要横向扩展Redis实例则需要将数据进行重分片,代价很大。
    客户端函数包含 query,add,delete 三种操作,且都先通过mod运算进行分片,对应到具体Redis实例后,执行对应Lua脚本。基本流程图如下:
    在这里插入图片描述

    参考资料

    1. bloom filter
    2. Summary Cache: A Scalable Wide-Area
      Web Cache Sharing Protocol
    3. Counting Bloom Filter
    4. Bloom Filter概念和原理
    5. Dynamic Count Filter
    6. Accurate Counting Bloom Filters for Large-Scale Data Processing
    展开全文
  • 在介绍布隆过滤器之前我们首先引入几个场景。 场景一 在一个高并发的计数系统中,如果一个key没有计数,此时我们应该返回0,但是访问的key不存在,相当于每次访问缓存都不起作用了。那么如何避免频繁访问数量为0的...
  • 布隆过滤器

    2021-03-12 23:53:32
    布隆过滤器 目录布隆过滤器为什么需要布隆过滤器基本概念实现原理优点缺点使用场景假阳性概率的计算 为什么需要布隆过滤器 如果想判断一个元素是不是在一个集合里,一般想到的是将集合中所有元素保存起来,然后通过...

    布隆过滤器

    为什么需要布隆过滤器

    如果想判断一个元素是不是在一个集合里,一般想到的是将集合中所有元素保存起来,然后通过比较确定。链表、树、散列表(又叫哈希表,Hash table)等等数据结构都是这种思路。

    但是随着集合中元素的增加,我们需要的存储空间越来越大。同时检索速度也越来越慢,上述三种结构的检索时间复杂度分别为在这里插入图片描述
    布隆过滤器即可以解决存储空间的问题, 又可以解决时间复杂度的问题.

    布隆过滤器的原理是,当一个元素被加入集合时,通过K个散列函数将这个元素映射成一个位数组中的K个点,把它们置为1。检索时,我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如果这些点有任何一个0,则被检元素一定不在;如果都是1,则被检元素很可能在。这就是布隆过滤器的基本思想。

    基本概念

    布隆过滤器(Bloom Filter,下文简称BF)由Burton Howard Bloom在1970年提出,是一种空间效率高的概率型数据结构。它专门用来检测集合中是否存在特定的元素

    它实际上是一个很长的二进制向量和一系列随机映射函数

    实现原理

    布隆过滤器的原理是,当一个元素被加入集合时,通过K个散列函数将这个元素映射成一个位数组中的K个点,把它们置为1。检索时,我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如果这些点有任何一个0,则被检元素一定不在;如果都是1,则被检元素很可能在。这就是布隆过滤器的基本思想。

    BF是由一个长度为m比特的位数组(bit array)与k个哈希函数(hash function)组成的数据结构。位数组均初始化为0,所有哈希函数都可以分别把输入数据尽量均匀地散列

    当要插入一个元素时,将其数据分别输入k个哈希函数,产生k个哈希值。以哈希值作为位数组中的下标,将所有k个对应的比特置为1。

    当要查询(即判断是否存在)一个元素时,同样将其数据输入哈希函数,然后检查对应的k个比特。如果有任意一个比特为0,表明该元素一定不在集合中。如果所有比特均为1,表明该集合有(较大的)可能性在集合中。为什么不是一定在集合中呢?因为一个比特被置为1有可能会受到其他元素的影响(hash碰撞),这就是所谓“假阳性”(false positive)。相对地,“假阴性”(false negative)在BF中是绝不会出现的。

    下图示出一个m=18, k=3的BF示例。集合中的x、y、z三个元素通过3个不同的哈希函数散列到位数组中。当查询元素w时,因为有一个比特为0,因此w不在该集合中。
    在这里插入图片描述

    优点

    1. 不需要存储数据本身,只用比特表示,因此空间占用相对于传统方式有巨大的优势,并且能够保密数据;
    2. 时间效率也较高,插入和查询的时间复杂度均为, 所以他的时间复杂度实际是
    3. 哈希函数之间相互独立,可以在硬件指令层面并行计算。

    缺点

    1. 存在假阳性的概率,不适用于任何要求100%准确率的情境;
    2. 只能插入和查询元素,不能删除元素,这与产生假阳性的原因是相同的。我们可以简单地想到通过计数(即将一个比特扩展为计数值)来记录元素数,但仍然无法保证删除的元素一定在集合中。

    使用场景

    所以,BF在对查准度要求没有那么苛刻,而对时间、空间效率要求较高的场合非常合适.

    另外,由于它不存在假阴性问题,所以用作“不存在”逻辑的处理时有奇效,比如可以用来作为缓存系统(如Redis)的缓冲,防止缓存穿透。

    假阳性概率的计算

    假阳性的概率其实就是一个不在的元素,被k个函数函数散列到的k个位置全部都是1的概率。可以按照如下的步骤进行计算: p = f(m,n,k)

    其中各个字母的含义:

    1. n :放入BF中的元素的总个数;
    2. m:BF的总长度,也就是bit数组的个数
    3. k:哈希函数的个数;
    4. p:表示BF将一个不在其中的元素错判为在其中的概率,也就是false positive的概率;

    A. BF中的任何一个bit在第一个元素的第一个hash函数执行完之后为 0的概率是:
    在这里插入图片描述

    B. BF中的任何一个bit在第一个元素的k个hash函数执行完之后为 0的概率是:
    在这里插入图片描述

    C.BF中的任何一个bit在所有的n元素都添加完之后为 0的概率是:
    在这里插入图片描述

    D.BF中的任何一个bit在所有的n元素都添加完之后为 1的概率是:
    在这里插入图片描述

    E.一个不存在的元素被k个hash函数映射后k个bit都是1的概率是:
    在这里插入图片描述

    结论:在哈数函数个数k一定的情况下

    1. 比特数组m长度越大, p越小, 表示假阳性率越低
    2. 已插入的元素个数n越大, p越大, 表示假阳性率越大

    经过各种数学推导:

    对于给定的m和n,使得假阳性率(误判率)最小的k通过如下公式定义:
    在这里插入图片描述

    展开全文
  • 布隆过滤器是有效,节省空间的数据结构,用于简洁地表示数据集并支持近似成员资格查询。 传统上,研究人员通常认为,Bloom过滤器有可能返回假阳性,但在行为良好的操作下绝不会返回假阴性。 但是,通过研究主流变体...
  • 1.【基础题】–实现一个简单的布隆过滤器。 如果想要判断一个元素是不是在一个集合里,一般想到的是将所有元素保存起来,然后通过比较确定。链表,树等等数据结构都是这种思路. 但是随着集合中元素的增加,我们...
  • 本文将带你快速了解布隆过滤器的核心思想,并通过Bloom Filter 模拟器带你快速弄懂这大名鼎鼎的布隆过滤器。 操作 基本的bloom过滤器支持两种操作:检测和添加。 检测用于检查给定元素是否在集合中。他只有两个返回...
  • 布隆过滤器学习

    2019-07-04 11:04:24
    布隆过滤器 学习起因,因上课听老师讲有一个数据结构很好用,比学习其他数据结构更有价值,这个数据结构就是布隆过滤器. 具体我并有在项目中使用它,现在是当做一种了解,学习它的原理和应用场景. 什么是布隆过滤器 本质...
  • 布隆过滤器(bloom filter)介绍以及php和redis实现布隆过滤器实现方法 引言 在介绍布隆过滤器之前我们首先引入几个场景。 场景一 在一个高并发的计数系统中,如果一个key没有计数,此时我们应该返回0,但是访问的...
  • 布隆过滤器详解

    2019-10-23 14:55:46
    什么是布隆过滤器 本质上布隆过滤器是一种数据结构,比较巧妙的概率型数据结构(probabilistic data structure),特点是高效地插入和查询,可以用来告诉你 “某样东西一定不存在或者可能存在”。 相比于传统的 List...
  • 主要介绍了Redis 中的布隆过滤器的实现,详细的介绍了什么是布隆过滤器以及如何实现,非常具有实用价值,需要的朋友可以参考下
  • 布隆过滤器提出2. 布隆过滤器概念3. 布隆过滤器的插入4. 布隆过滤器的查找5. 布隆过滤器删除6. 如何选择哈希函数个数和布隆过滤器长度6. 布隆过滤器优点7. 布隆过滤器缺陷 1. 布隆过滤器提出 讲述布隆过滤器的原理...
  • 什么是布隆过滤器 实现原理 HashMap 的问题 布隆过滤器数据结构 支持删除么 如何选择哈希函数个数和布隆过滤器长度 最佳实践 大Value拆分 什么是布隆过滤器  本质上布隆过滤器是一种数据结构,比较巧妙的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,568
精华内容 1,427
关键字:

计数布隆过滤器