【算法】布隆过滤器

最新推荐文章于 2025-06-18 11:14:44 发布

置顶 shinelord明

最新推荐文章于 2025-06-18 11:14:44 发布

阅读量1.7k

点赞数 11

CC 4.0 BY-SA版权

分类专栏：算法仓数据结构与算法文章标签：算法

本文链接：https://blog.csdn.net/wnm23/article/details/140660880

数据结构与算法同时被 2 个专栏收录

39 篇文章

订阅专栏

算法仓

19 篇文章

订阅专栏

一、引言

在现实世界的计算机科学问题中，我们经常需要判断一个元素是否属于一个集合。传统的做法是使用哈希表或者直接遍历集合，但这些方法在数据量较大时效率低下。布隆过滤器（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
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
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++

// 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;
    }
};

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 - 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 - 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++

// 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 - 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 代码示例
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 代码示例
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);