数据结构与算法：Bloom Filter(布隆过滤器)解决大数据查重问题

已于 2022-09-23 22:18:50 修改
阅读量1.2k 收藏 4
点赞数 1
分类专栏： 算法与数据结构
于 2022-09-23 21:58:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56257585/article/details/127005054
版权

前言

在内存有所限制的情况下（如上面的面试问题），快速判断一个元素是否在一个集合（容器）当
中，还可以使用布隆过滤器。
布隆过滤器到底是个什么东西呢？
通俗来讲，在使用哈希表比较占内存的情况下，它是一种更高级的“位图法”解决方案，之所以说它更高级，是因为它没有位图法所说的缺陷。

文章目录

BloomFilter

1.Bloom Filter是通过一个位数组+k个哈希函数构成的。

图示：首先给出一个位数组，再给出三个哈希函数
在这里插入图片描述
在这里插入图片描述

三个哈希函数通过关键字的计算，得到三个位置，这里比如0， 4， 6
那么在位数组上就将对应的位置置为1.

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

增加一个元素：

  1. 经过K个哈希函数计算，得到bitmap位数组里面的一组位序号。
  2. 把相应的位置置为1。

搜索一个元素：

  1. 经过K个哈希函数计算，得到bitmap位数组里面的一组位序号。
  2. 判断上面几个位置的值，如果全是1，证明相应的key存在，如果有一个以上是0，则证明key不在Bloom Filter中。

删除元素？
Bloom Filter不能提供删除操作，因为同一个位置可能是由多个key共用的，就像上面的示例。

Bloom Filter查询一个key值是否存在，如果查出来key经过k个哈希函数处理后，对应的位都是1，能说明这个key存在吗？

其实数据并不一定在，因为映射到的k个位可能被其他数据已经置为1了，所以会存在误判！！！

相反的，如果Bloom Filter说数据不在，那么数据肯定是不存在的！！！

只要能接受一定的误判率，那么这个方法还是很好用的。

场景1：过滤非法网站

提示过滤一些非法的网站，或者钓鱼网站等等

Bloom Filter：把所有可能怀疑有问题的网站的URL添加到布隆过滤器当中，查找当前访问的URL是否在黑名单内，如果存在，会进行提示当前网站有风险，禁止访问。如果URL不存在，那肯定是白名单上的合法网站，可以直接访问。

场景2：Redis缓存中的应用

如图：
有客户端请求进入网络层 ⇒ 业务层，然后是先去redis的缓存层查询，如果key存在，则直接返回，如果不存在，才进入数据库层来找到key，并将value在缓存层缓存，然后返回。
redis缓存是内存IO，数据库是磁盘IO，磁盘IO是比内存IO要慢几十上百万倍，

在这里插入图片描述
场景：
查key到底存不存在，而且效率要求高，最好还省内存；
那么Bloom Filter首先使用 setBit(key)，将key存放起来；
通过getBit(key)来查找，如果不存在，则去DB层，然后缓存到redis，再返回；getBit(key)如果存在，则redis中找到key，直接返回。

BloomFilter黑名单网址示例

在这里先实现一个Bloom Filter，提供增加和查询两个接口，然后再实现一个黑名单，将黑名单类提供给客户，提供add()和query()方法，底层也是一个Bloom Filter类型的变量。

#include <iostream>
#include <vector>
#include <string>

#include "stringhash.h"

using namespace std;

// 布隆过滤器
class BloomFilter
{
public:
	BloomFilter(int bitSize = 1471)
		: bitSize_(bitSize)
	{
		bitMap_.resize(bitSize_ / 32 + 1);
	}

public:
	// 添加元素
	void setBit(const char* str)
	{
		// 计算k组哈希函数的值
		int idx1 = BKDRHash(str) % bitSize_;
		int idx2 = RSHash(str) % bitSize_;
		int idx3 = APHash(str) % bitSize_;

		// 把相应的idx1 idx2 idx3这几个位置为1
		int index = 0;
		int offset = 0;

		index = idx1 / 32;
		offset = idx1 % 32;
		bitMap_[index] |= (1 << offset);

		index = idx2 / 32;
		offset = idx2 % 32;
		bitMap_[index] |= (1 << offset);

		index = idx3 / 32;
		offset = idx3 % 32;
		bitMap_[index] |= (1 << offset);
	}

	// 查询元素
	bool getBit(const char* str)
	{
		// 计算k组哈希函数的值
		int idx1 = BKDRHash(str) % bitSize_;
		int idx2 = RSHash(str) % bitSize_;
		int idx3 = APHash(str) % bitSize_;

		int index = 0;
		int offset = 0;

		index = idx1 / 32;
		offset = idx1 % 32;
		if (0 == (bitMap_[index] & (1 << offset)))
		{
			// 具体业务，根据需求更改
			cout << "该网址安全，是否继续？" << endl;
			return false;
		}

		index = idx2 / 32;
		offset = idx2 % 32;
		if (0 == (bitMap_[index] & (1 << offset)))
		{
			// 具体业务，根据需求更改
			cout << "该网址安全，是否继续？" << endl;
			return false;
		}

		index = idx3 / 32;
		offset = idx3 % 32;
		if (0 == (bitMap_[index] & (1 << offset)))
		{
			// 具体业务，根据需求更改
			cout << "该网址安全，是否继续？" << endl;
			return false;
		}

		// 根据业务需求更改
		cout << "该网址非法访问！" << endl;
		return true;
	}
private:
	int bitSize_;	// 位图的长度
	vector<int> bitMap_;	// 位图数组
};

class BlackList
{
public:
	// 添加非法URL
	void add(string url)
	{
		blackList_.setBit(url.c_str());
	}

	// 查询
	bool query(string url)
	{
		return blackList_.getBit(url.c_str());
	}
private:
	BloomFilter blackList_;
};

int main(void)
{
	BlackList list_;
	list_.add("https://www.baidu.com");
	list_.add("https://www.tmall.com");
	list_.add("https://www.360.com");
	list_.add("https://tencent.com");

	list_.query("https://www.tmall.com");
	list_.query("https://www.alibaba.com");

	return 0;
}

在这里插入图片描述

总结

这里总结一下Bloom Filter的注意事项：

  1. Bloom Filter是通过一个位数组 + k个哈希函数构成的。
  2. Bloom Filter的空间和时间利用率都很高，但是它有一定的错误率，虽然错误率很低，Bloom
    Filter判断某个元素不在一个集合中，那该元素肯定不在集合里面；Bloom Filter判断某个元素在一
    个集合中，那该元素有可能在，有可能不在集合当中。
  3. Bloom Filter的查找错误率，当然和位数组的大小，以及哈希函数的个数有关系，具体的错误率
    计算有相应的公式（错误率公式的掌握看个人理解，不做要求）。
  4. Bloom Filter默认只支持add增加和query查询操作，不支持delete删除操作（因为存储的状态位
    有可能也是其它数据的状态位，删除后导致其它元素查找判断出错）。
    Bloom Filter增加元素的过程：把元素的值通过k个哈希函数进行计算，得到k个值，然后把k当作
    位数组的下标，在位数组中把相应k个值修改成1。
    Bloom Filter查询元素的过程：把元素的值通过k个哈希函数进行计算，得到k个值，然后把k当作
    位数组的下标，看看相应位数组下标标识的值是否全部是1，如果有一个为0，表示元素不存在
    （判断不存在绝对正确）；如果都为1，表示元素存在（判断存在有错误率）。

很显然，过小的布隆过滤器很快所有的bit位均为1，那么查询任何值都会返回“可能存在”，起不到
过滤的目的。布隆过滤器的长度会直接影响误报率，布隆过滤器越长其误报率越小。另外，哈希函
数的个数也需要权衡，个数越多则布隆过滤器bit位置为1的速度越快，且布隆过滤器的效率越低；
但是如果太少的话，那误报率就会变高。

end

关于上面示例的这些哈希函数，在此附一个头文件。。

#pragma once

/// @brief BKDR Hash Function  
/// @detail 本 算法由于在Brian Kernighan与Dennis Ritchie的《The C Programming Language》一书被展示而得 名，是一种简单快捷的hash算法，也是Java目前采用的字符串的Hash算法（累乘因子为31）。  
template<class T>
size_t BKDRHash(const T* str)
{
    register size_t hash = 0;
    while (size_t ch = (size_t)*str++)
    {
        hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..  
        // 有人说将乘法分解为位运算及加减法可以提高效率，如将上式表达为：hash = hash << 7 + hash << 1 + hash + ch;  
        // 但其实在Intel平台上，CPU内部对二者的处理效率都是差不多的，  
        // 我分别进行了100亿次的上述两种运算，发现二者时间差距基本为0（如果是Debug版，分解成位运算后的耗时还要高1/3）；  
        // 在ARM这类RISC系统上没有测试过，由于ARM内部使用Booth's Algorithm来模拟32位整数乘法运算，它的效率与乘数有关：  
        // 当乘数8-31位都为1或0时，需要1个时钟周期  
        // 当乘数16-31位都为1或0时，需要2个时钟周期  
        // 当乘数24-31位都为1或0时，需要3个时钟周期  
        // 否则，需要4个时钟周期  
        // 因此，虽然我没有实际测试，但是我依然认为二者效率上差别不大          
    }
    return hash;
}
/// @brief SDBM Hash Function  
/// @detail 本算法是由于在开源项目SDBM（一种简单的数据库引擎）中被应用而得名，它与BKDRHash思想一致，只是种子不同而已。  
template<class T>
size_t SDBMHash(const T* 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;
}
/// @brief RS Hash Function  
/// @detail 因Robert Sedgwicks在其《Algorithms in C》一书中展示而得名。  
template<class T>
size_t RSHash(const T* 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;
}
/// @brief AP Hash Function  
/// @detail 由Arash Partow发明的一种hash算法。  
template<class T>
size_t APHash(const T* 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;
}
/// @brief JS Hash Function  
/// 由Justin Sobel发明的一种hash算法。  
template<class T>
size_t JSHash(const T* 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;
}
/// @brief DEK Function  
/// @detail 本算法是由于Donald E. Knuth在《Art Of Computer Programming Volume 3》中展示而得名。  
template<class T>
size_t DEKHash(const T* str)
{
    if (!*str)        // 这是由本人添加，以保证空字符串返回哈希值0  
        return 0;
    register size_t hash = 1315423911;
    while (size_t ch = (size_t)*str++)
    {
        hash = ((hash << 5) ^ (hash >> 27)) ^ ch;
    }
    return hash;
}
/// @brief FNV Hash Function  
/// @detail Unix system系统中使用的一种著名hash算法，后来微软也在其hash_map中实现。  
template<class T>
size_t FNVHash(const T* str)
{
    if (!*str)   // 这是由本人添加，以保证空字符串返回哈希值0  
        return 0;
    register size_t hash = 2166136261;
    while (size_t ch = (size_t)*str++)
    {
        hash *= 16777619;
        hash ^= ch;
    }
    return hash;
}
/// @brief DJB Hash Function  
/// @detail 由Daniel J. Bernstein教授发明的一种hash算法。  
template<class T>
size_t DJBHash(const T* str)
{
    if (!*str)   // 这是由本人添加，以保证空字符串返回哈希值0  
        return 0;
    register size_t hash = 5381;
    while (size_t ch = (size_t)*str++)
    {
        hash += (hash << 5) + ch;
    }
    return hash;
}
/// @brief DJB Hash Function 2  
/// @detail 由Daniel J. Bernstein 发明的另一种hash算法。  
template<class T>
size_t DJB2Hash(const T* str)
{
    if (!*str)   // 这是由本人添加，以保证空字符串返回哈希值0  
        return 0;
    register size_t hash = 5381;
    while (size_t ch = (size_t)*str++)
    {
        hash = hash * 33 ^ ch;
    }
    return hash;
}
/// @brief PJW Hash Function  
/// @detail 本算法是基于AT&T贝尔实验室的Peter J. Weinberger的论文而发明的一种hash算法。  
template<class T>
size_t PJWHash(const T* str)
{
    static const size_t TotalBits = sizeof(size_t) * 8;
    static const size_t ThreeQuarters = (TotalBits * 3) / 4;
    static const size_t OneEighth = TotalBits / 8;
    static const size_t HighBits = ((size_t)-1) << (TotalBits - OneEighth);

    register size_t hash = 0;
    size_t magic = 0;
    while (size_t ch = (size_t)*str++)
    {
        hash = (hash << OneEighth) + ch;
        if ((magic = hash & HighBits) != 0)
        {
            hash = ((hash ^ (magic >> ThreeQuarters)) & (~HighBits));
        }
    }
    return hash;
}
/// @brief ELF Hash Function  
/// @detail 由于在Unix的Extended Library Function被附带而得名的一种hash算法，它其实就是PJW Hash的变形。  
template<class T>
size_t ELFHash(const T* str)
{
    static const size_t TotalBits = sizeof(size_t) * 8;
    static const size_t ThreeQuarters = (TotalBits * 3) / 4;
    static const size_t OneEighth = TotalBits / 8;
    static const size_t HighBits = ((size_t)-1) << (TotalBits - OneEighth);
    register size_t hash = 0;
    size_t magic = 0;
    while (size_t ch = (size_t)*str++)
    {
        hash = (hash << OneEighth) + ch;
        if ((magic = hash & HighBits) != 0)
        {
            hash ^= (magic >> ThreeQuarters);
            hash &= ~magic;
        }
    }
    return hash;
}
_索伦
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 数据结构之布隆过滤器
08-30
C++ 数据结构之布隆过滤器 ...布隆过滤器是一种非常有用的数据结构，可以用于解决大规模数据集合中的元素检索问题。它的优点是空间效率和查询时间都远远超过一般的算法，但缺点是有一定的误识别率和删除错误。
java实现的布隆过滤器算法
07-27
布隆过滤器（Bloom Filter）是一种空间效率极高的概率型数据结构，用于判断一个元素是否在一个集合中。它可能会误判，但不会漏判，即如果它说一个元素在集合中，那可能是错误的，但如果它说一个元素不在集合中，那么...
hash，bloomfilter，分布式一致性hash
Linuxhus的博客
04-12 355
场景 使用word 文档时，判断某个单词是否拼写正确 垃圾邮件过滤算法 Redis缓存穿透 bitcoin core中交易校验 需求 从海量数据中查询某个字符串是否存在？ 平衡二叉搜索树 增删改查时间复杂度是O(log2n) 平衡的目的是保证操作的时间复杂度稳定，保证下次搜索能够稳定排除一半的数据。 O(log2n)的直观理解：100万个节点，最多比较20次；10亿个节点，最多比较30次。 总结：通过比较保证有序，使用二分查找，通过每次排除一般的元素达到快
海量数据处理之Bloom Filter详解
jinghuainfo
08-14 924
海量数据处理之Bloom Filter详解 前言 本博客内曾已经整理过十道海量数据处理面试题与十个方法大总结。接下来，本博客内会重点分析那些海量数据处理的方法，并重写十道海量数据处理的面试题。如果有任何问题，欢迎不吝指正。谢谢。 一、什么是Bloom Filter Bloom Filter是一种空间效率很高的随机数据结构，它利用位数组很简洁地表示一个集合，并能判断一个元素是否属...
程序员的算法课（14）-Hash算法-对海量url判重
十步杀一人-千里不留行
08-25 2264
前面给大家讲了哈希表（散列）这种数据结构，那么使用哈希表来解决实际问题，那就是Hash算法了，我们一起来看看。 一、Hash算法的概念 Hash算法（Hash Algorithm），简称散列算法，也成哈希算法（英译），是将一个大文件映射成一个小串字符。与指纹一样，就是以较短的信息来保证文件的唯一性的标志，这种标志与文件的每一个字节都相关，而且难以找到逆向规律。 举个列子： 服务器存了1...
海量数据去重的hash与BloomFilter
m0_63668614的博客
07-16 578
本文总结了hash的相关应用，仅供参考
海量数据去重的Hash与BloomFilter学习笔记
qq_42120843的博客
09-12 505
海量数据去重的Hash与BloomFilter，bitmap
海量数据处理利器之Hash——在线邮件地址过滤
夜风
08-13 1844
标题用了了海量数据（Massive datasets）而不用大数据（Big data）。感觉大数据还是略微有点虚，来点实际的。 一、需求 现在我们需要设计一个在线过滤垃圾邮件地址的方案，我们的数据库里面已经有10亿个合法的邮件地址（称为合法地址集S），当有新的邮件发过来时，要检查这个邮件地址是不是在我们的数据库里面，如果在，我们接收邮件，如果不在，我们就把它当做垃圾邮件过滤掉。
Hash和Bloom Filter
weixin_30786617的博客
05-04 156
这几天的“科研”中涉及到了一个概念，Bloom Filter（有的中文翻译为布隆过滤器，不知道正确否），今天看了下相关的资料，发现这东西和Hash还挺有关系的，在这里一并讲下。 Hash（函数/表） Hash （中译为哈希，或者散列）函数在计算机领域，尤其是数据快速查找领域，加密领域用的极广。其作用是将一个大的数据集映射到一个小的数据集上面（这些小的数据集叫做哈希值，或者散列值）。...
InverseBloomFilter:并发逆布隆过滤器
06-27
逆布隆过滤器逆布隆过滤器，或“布隆过滤器的反面”，是一种并发的概率数据结构，用于测试一个项目是否被观察到。 这是一个 Go 实现，，它用非加密 FNV-1a 函数代替了 MD5 散列的使用。 反向过滤器可能会报告误报，...
algorithm_coding:推荐算法、相似度算法、布隆过滤器、均值算法、一致性Hash、数据结构、leetcode练习
05-29
bloom_filter_code [布隆过滤器] 1: bloom 布隆过滤器 consistent_hash_code [一致性Hash算法] 1: consistent 一致性Hash算法 leet_code [leet_code刷题] 1: leet_code刷题 heap [堆] 1: max_heap_test 大顶推 ...
hash与BloomFilter以及bitmap学习总结
carlgood的专栏
07-17 208
hash、散列表、布隆过滤器
Hash（哈希/散列）和Bloom Filter(布隆过滤器)
coderge's CSDN Blog.
10-25 1200
布隆过滤器背后的数学原理在于两个完全随机的数字冲突的概率很小，因此，可以在很小的误识别率条件下，用很少的空间存储大量信息。常见的补救误识别的办法是再在建立一个小的白名单，存储那些可能被误判的信息。由于布隆过滤器中只有简单的算术运算,因此它的速度很快，使用方便。
布隆过滤器（Bloom Filter）原理以及应用
10-25 8728
布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。 hash原理 Hash （哈希，或者散列）函数在计算机领域，尤其是数据快速查找领域，加密领域用的极广。 其作用是将一个大的数据集
算法——布隆过滤器
2551的博客
08-16 301
对于爬虫去重问题，或者黑名单过滤问题，在允许有失误率的情况下，布隆过滤器是一个不错的选择
大数查重（哈希表&位图&Bloom Filter）
qq_41721746的博客
10-26 568
一、哈希表 1. 哈希表理论知识 2. 线性探测哈希表 3. 链式哈希表 4. 哈希表应用 （1）找出第一个重复出现的数字 （2）找出所有重复的数字 （3）统计重复出现的数字以及出现的次数 （4）一组数据有些数字是重复的，把重复的数字过滤掉，每个数字只出现一次 （5）找出第一个没有重复出现的字符 二、 位图算法 三、 布隆过滤器Bloom Filter
Redis布隆过滤器实现检索亿级数据存在
最新发布
weixin_47969982的博客
11-30 184
想要实现10亿的数据中快速判断某一个数据是否存在，使用sql查询会造成数据库性能、负载的问题，如若将数据存到缓存中，一个数据假设是20字节，10亿数据就是20G内存，这个方案内存占用过大。相比之下0.001容错率的布隆过滤器的内存占用为1.67G，既解决了内存问题，又解决了数据库资源使用问题。
Redis系列--布隆过滤器（Bloom Filter）
weixin_42972832的博客
06-16 6489
无论使用谷歌版本的布隆过滤器还是自己编写的，都会存在两个问题，1、因为不同元素经过hash函数计算后可能会出现相同的hash值（hash碰撞），就会出现一个误判率的问题2、因为有hash碰撞，导致同一个位置可能存放不同的数据，这对于删除操作是很不友好的。对于这些情况可查看另一种布隆过滤器，布谷鸟过滤器。
一道有难度的经典大厂面试题：如何快速判断某 URL 是否在 20 亿的网址 URL 集合中？...
禅与计算机程序设计艺术
04-14 9065
问题 问题描述：一个网站有 20 亿 url 存在一个黑名单中，这个黑名单要怎么存？若此时随便输入一个 url，你如何快速判断该 url 是否在这个黑名单中？并且需在给定内存空间（比如：500M）内快速判断出。 分析 可能很多人首先想到的会是使用 HashSet，因为 HashSet基于 HashMap，理论上时间复杂度为：O(1)。达到了快速的目的，但是空间复杂度呢？URL字...
数据结构与算法面试精华：字典树、线段树、布隆过滤器解析
文档中提到了几种重要的数据结构及其应用场景，包括字典树、线段树、布隆过滤器和位图。 1. 字典树（Trie） 字典树是一种用于快速查找字符串的数据结构，它以高效查询和字符串共享前缀为特点。每个节点代表一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_索伦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值