【算法】布隆过滤器

shinelord明2024-07-31 10:22

一、引言

在现实世界的计算机科学问题中，我们经常需要判断一个元素是否属于一个集合。传统的做法是使用哈希表或者直接遍历集合，但这些方法在数据量较大时效率低下。布隆过滤器（Bloom Filter）是一种空间效率极高的概率型数据结构，用于测试一个元素是否属于集合。本文将详细介绍布隆过滤器的原理、数据结构、使用场景、算法实现，并与其他算法进行对比，最后给出多语言实现及一个实际的服务应用场景代码框架。

二、算法原理

布隆过滤器由一个很长的二进制向量和一系列随机映射函数组成。当我们要添加一个元素时，该元素会被多个哈希函数映射到二进制向量的不同位置，并将这些位置设为1。查询时，通过同样的哈希函数计算位置，如果所有对应的位置都是1，则该元素可能存在于集合中；如果有任何一个位置是0，则该元素一定不存在于集合中。

布隆过滤器由一个比特数组（Bit Array）和多个哈希函数组成。

初始时，所有的比特位都被置为 0。

当元素被加入时，通过多个哈希函数计算出多个哈希值，然后将对应的比特位设置为 1。

当查询一个元素是否存在时，同样通过多个哈希函数计算出哈希值，检查对应的比特位，如果所有对应的比特位都为 1，则该元素可能存在；如果有任何一个比特位为 0，则该元素一定不存在。

三、数据结构

布隆过滤器主要包含以下部分：

一个大的位数组（bit array）。

一组哈希函数。

四、使用场景

布隆过滤器适用于以下场景：

网络爬虫过滤已抓取的URL。

防止缓存穿透，如数据库查询缓存。

查询重复元素，如邮件系统过滤重复邮件。

空间敏感：当元素集合非常大，但只关心是否存在时。

允许误报：当系统可以容忍少量错误判断时。

快速查找：需要快速判断元素是否在集合中时。

五、算法实现

以下是布隆过滤器的简单实现步骤：

初始化一个长度为m的位数组，并设置所有位为0。

选择k个不同的哈希函数，它们将元素映射到位数组的位置。

添加元素：对元素进行k次哈希，将得到的k个位置设为1。

查询元素：对元素进行k次哈希，检查所有对应位置是否为1。

六、其他同类算法对比

**哈希表：**精确匹配，空间占用大。

**位图（Bitmap）：**只能处理整数集合，不支持哈希函数。

**Cuckoo Filter：**支持删除操作，空间利用率更高。

后缀数组：适用于字符串搜索，空间和时间效率较高，但实现复杂。

Trie树：适用于字符串集合，空间效率较高，但存在空间浪费。

七、多语言实现

布隆过滤器的伪代码实现：

java

java 复制代码 
// Java
public class BloomFilter {
    private BitSet bitSet;
    private int bitSetSize;
    private int addedElements;
    private static final int[] SEEDS = new int[]{5, 7, 11, 13, 31};

    public BloomFilter(int bitSetSize) {
        this.bitSetSize = bitSetSize;
        this.bitSet = new BitSet(bitSetSize);
        this.addedElements = 0;
    }

    public void add(String element) {
        for (int seed : SEEDS) {
            int hash = hash(element, seed);
            bitSet.set(hash);
        }
        addedElements++;
    }

    public boolean contains(String element) {
        for (int seed : SEEDS) {
            int hash = hash(element, seed);
            if (!bitSet.get(hash)) {
                return false;
            }
        }
        return true;
    }

    private int hash(String element, int seed) {
        // Implement a simple hash function
    }
}

python

python 复制代码 
# Python
class BloomFilter:
    def __init__(self, bit_array_size, hash_functions):
        self.bit_array = [0] * bit_array_size
        self.hash_functions = hash_functions

    def add(self, element):
        for hash_function in self.hash_functions:
            index = hash_function(element)
            self.bit_array[index] = 1

    def contains(self, element):
        return all(self.bit_array[hash_function(element)] for hash_function in self.hash_functions)

# Example hash functions
def hash_function_1(element):
    # Implement a simple hash function

def hash_function_2(element):
    # Implement another simple hash function

c++

cpp 复制代码 
// C++
#include <vector>
#include <functional>

class BloomFilter {
private:
    std::vector<bool> bit_array;
    std::vector<std::function<size_t(const std::string&)>> hash_functions;

public:
    BloomFilter(size_t size, const std::vector<std::function<size_t(const std::string&)>>& funcs)
        : bit_array(size, false), hash_functions(funcs) {}

    void add(const std::string& element) {
        for (const auto& func : hash_functions) {
            size_t index = func(element) % bit_array.size();
            bit_array[index] = true;
        }
    }

    bool contains(const std::string& element) const {
        for (const auto& func : hash_functions) {
            size_t index = func(element) % bit_array.size();
            if (!bit_array[index]) {
                return false;
            }
        }
        return true;
    }
};

Go

Go 复制代码 
package main

import (
    "fmt"
    "github.com/willf/bloom"
)

func main() {
    filter := bloom.New(1000, 5) // 1000 items, 5 hash functions

    // Add items to the filter
    filter.Add([]byte("hello"))
    filter.Add([]byte("world"))

    // Test if items are in the filter
    if filter.Test([]byte("hello")) {
        fmt.Println("hello is in the filter")
    }
    if !filter.Test([]byte("missing")) {
        fmt.Println("missing is not in the filter")
    }
}

八、实际服务应用场景代码框架

使用布隆过滤器来防止缓存穿透的简单服务应用场景代码框架：

java

java 复制代码 
// Java - Cache Service with Bloom Filter
public class CacheService {
    private final BloomFilter<String> bloomFilter;
    private final Map<String, String> cache;

    public CacheService(int cacheSize, int bloomFilterSize) {
        this.cache = new HashMap<>(cacheSize);
        this.bloomFilter = new BloomFilter<>(bloomFilterSize);
    }

    public String get(String key) {
        if (!bloomFilter.contains(key)) {
            // The key is definitely not in the cache
            return null;
        }

        // The key might be in the cache, check the actual cache
        return cache.get(key);
    }

    public void put(String key, String value) {
        bloomFilter.add(key);
        cache.put(key, value);
    }
}

python

python 复制代码 
# Python - Cache Service with Bloom Filter
class CacheService:
    def __init__(self, cache_size, bloom_filter_size):
        self.cache = {}
        self.bloom_filter = BloomFilter(bloom_filter_size, [hash_function_1, hash_function_2])

    def get(self, key):
        if not self.bloom_filter.contains(key):
            # The key is definitely not in the cache
            return None
        # The key might be in the cache, check the actual cache
        return self.cache.get(key)

    def put(self, key, value):
        self.bloom_filter.add(key)
        self.cache[key] = value

# Define hash functions
def hash_function_1(element):
    # Implement a simple hash function

def hash_function_2(element):
    # Implement another simple hash function

c++

cpp 复制代码 
// C++ - Cache Service with Bloom Filter
#include <unordered_map>
#include <string>

class CacheService {
private:
    BloomFilter bloomFilter;
    std::unordered_map<std::string, std::string> cache;

public:
    CacheService(size_t bloomFilterSize, const std::vector<std::function<size_t(const std::string&)>>& hashFuncs)
        : bloomFilter(bloomFilterSize, hashFuncs) {}

    std::string get(const std::string& key) {
        if (!bloomFilter.contains(key)) {
            // The key is definitely not in the cache
            return "";
        }
        // The key might be in the cache, check the actual cache
        return cache[key];
    }

    void put(const std::string& key, const std::string& value) {
        bloomFilter.add(key);
        cache[key] = value;
    }
};

go

Go 复制代码 
// Go - Cache Service with Bloom Filter
package main

import (
	"fmt"
	"github.com/willf/bloom"
)

type CacheService struct {
	bloomFilter *bloom.BloomFilter
	cache       map[string]string
}

func NewCacheService(bloomFilterSize int, cacheSize int) *CacheService {
	return &CacheService{
		bloomFilter: bloom.New(bloomFilterSize, 5),
		cache:       make(map[string]string, cacheSize),
	}
}

func (s *CacheService) Get(key string) (string, bool) {
	if !s.bloomFilter.Test([]byte(key)) {
		// The key is definitely not in the cache
		return "", false
	}
	// The key might be in the cache, check the actual cache
	value, exists := s.cache[key]
	return value, exists
}

func (s *CacheService) Put(key, value string) {
	s.bloomFilter.Add([]byte(key))
	s.cache[key] = value
}

func main() {
	service := NewCacheService(1000, 100)
	service.Put("hello", "world")

	if value, exists := service.Get("hello"); exists {
		fmt.Println("Found in cache:", value)
	}
}

布隆过滤器在 HBase 中的使用：

在 HBase 中，布隆过滤器主要用于以下两个场景：

行键查找（Get 操作） ：当客户端发起一个 Get 操作来查询特定的行键时，布隆过滤器可以快速判断该行键是否存在于某个 HFile 中，从而避免不必要的磁盘 I/O。

范围扫描（Scan 操作） ：当客户端执行一个 Scan 操作来检索一定范围内的行键时，布隆过滤器可以帮助跳过那些肯定不包含目标行键的 HFile，减少扫描的数据量。

HBase 支持以下几种布隆过滤器：

  • NONE：不使用布隆过滤器。
  • ROW：对行键使用布隆过滤器。
  • ROWCOL：对行键加列族:列限定符的组合使用布隆过滤器。
  • PREFIX：对行键的前缀使用布隆过滤器。

在 HBase 中配置布隆过滤器、布隆过滤器的配置可以在表级别进行，具体操作如下：

创建表时配置：

java 复制代码 
// Java 代码示例
Configuration config = HBaseConfiguration.create();
HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));
HColumnDescriptor columnDescriptor = new HColumnDescriptor(familyName);

// 设置布隆过滤器类型为 ROW
columnDescriptor.setBloomFilterType(BloomType.ROW);

// 设置布隆过滤器的误报率，例如 0.01 表示 1% 的误报率
columnDescriptor.setBloomFilterFalsePositiveChance(0.01f);
tableDescriptor.addFamily(columnDescriptor);
admin.createTable(tableDescriptor);

修改现有表的配置：

java 复制代码 
// Java 代码示例
Configuration config = HBaseConfiguration.create();
Admin admin = ConnectionFactory.createConnection(config).getAdmin();
TableName tableName = TableName.valueOf(tableName);
HColumnDescriptor columnDescriptor = new HColumnDescriptor(familyName);

// 获取表的描述符
HTableDescriptor tableDescriptor = admin.getTableDescriptor(tableName);

// 设置布隆过滤器类型为 ROW
columnDescriptor.setBloomFilterType(BloomType.ROW);

// 更新列族描述符
tableDescriptor.modifyFamily(columnDescriptor);
admin.modifyTable(tableName, tableDescriptor);
相关推荐
小沈熬夜秃头中୧⍤⃝8 分钟前
【贪心算法】No.1---贪心算法（1)
算法·贪心算法
木向40 分钟前
leetcode92:反转链表||
数据结构·c++·算法·leetcode·链表
阿阿越42 分钟前
算法每日练 -- 双指针篇（持续更新中）
数据结构·c++·算法
skaiuijing1 小时前
Sparrow系列拓展篇：对调度层进行抽象并引入IPC机制信号量
c语言·算法·操作系统·调度算法·操作系统内核
Star Patrick1 小时前
算法训练（leetcode）二刷第十九天 | *39. 组合总和、*40. 组合总和 II、*131. 分割回文串
python·算法·leetcode
武子康2 小时前
大数据-214 数据挖掘 机器学习理论 - KMeans Python 实现 算法验证 sklearn n_clusters labels
大数据·人工智能·python·深度学习·算法·机器学习·数据挖掘
pianmian17 小时前
python数据结构基础(7)
数据结构·算法
好奇龙猫9 小时前
【学习AI-相关路程-mnist手写数字分类-win-硬件：windows-自我学习AI-实验步骤-全连接神经网络（BPnetwork）-操作流程（3） 】
人工智能·算法
sp_fyf_202410 小时前
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01
人工智能·深度学习·神经网络·算法·机器学习·语言模型·数据挖掘
香菜大丸10 小时前
链表的归并排序
数据结构·算法·链表
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07文件或文件夹名称中有空格如何批量去除08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10Macbook pro M1 安装Ubuntu教程