# Bloom Filter

Data Structures: Bloom Filter Data Structure

## The Definition of a Bloom Filter​

A Bloom Filter is a space-efficient probabilistic data structure that is used to test whether an element is a member of a set. It allows for false positives but guarantees no false negatives. This means, if a Bloom filter says an item is in the set, it might be wrong, but if it says an item is not in the set, it's definitely not.

## Instructions for Creating a Bloom Filter Structure​

Here's a step-by-step guide to creating a Bloom Filter:

### 1. Understand the Concept​

• A Bloom filter consists of a bit array and multiple hash functions.
• Each item is hashed by each of the hash functions to get multiple positions in the bit array.
• To add an item, set the bits at these positions.
• To check if an item is in the set, check if all the bits at these positions are set.

### 2. Define the Bloom Filter Data Structure​

Start by defining the data structure with the bit array size and hash functions.

``class BloomFilter {    constructor(size, hashFunctions) {        this.size = size;        this.bitArray = new Array(size).fill(0);        this.hashFunctions = hashFunctions;    }}``

### 3. Implement the `add` Method​

For adding an element to the Bloom Filter, hash the element with each hash function and set the corresponding bits in the bit array.

``// ... Inside BloomFilter classadd(item) {    this.hashFunctions.forEach(func => {        const hashValue = func(item) % this.size;        this.bitArray[hashValue] = 1;    });}``

### 4. Implement the `contains` Method​

To check if an element might be in the set, hash the element with each hash function and check the corresponding bits.

``// ... Inside BloomFilter classcontains(item) {    for (const func of this.hashFunctions) {        const hashValue = func(item) % this.size;        if (this.bitArray[hashValue] === 0) {            return false;  // Definitely not in the set        }    }    return true;  // Might be in the set}``

### 5. Define Hash Functions​

To make the Bloom Filter effective, you should use independent hash functions. For demonstration, let's define two simple hash functions, but in a real-world scenario, you'd need better hash functions:

``function hash1(str) {    let hash = 0;    for (let i = 0; i < str.length; i++) {        hash = (hash << 5) - hash + str.charCodeAt(i);    }    return hash;}function hash2(str) {    let hash = 0;    for (let i = 0; i < str.length; i++) {        hash = (hash << 7) - hash + str.charCodeAt(i);    }    return hash;}``

### 6. Using the Bloom Filter​

``const hashFunctions = [hash1, hash2];const bloom = new BloomFilter(100, hashFunctions);bloom.add("item1");console.log(bloom.contains("item1"));  // trueconsole.log(bloom.contains("item2"));  // false or true (but less likely true)``

### 7. Possible Extensions​

• Dynamic resizing: Resize and rehash when the bit array becomes too filled.
• Counting Bloom Filter: Instead of a bit array, use an array of counts to allow removals.
• More hash functions: The more hash functions, the less likely you'll have a false positive, but each operation will be slower.

Note

Remember, the nature of the Bloom Filter means you'll get a certain probability of false positives. The size of the bit array and the number of hash functions will affect this probability. Adjusting these parameters allows you to tune the time-space tradeoff.

### Complexity​

A Bloom filter is a probabilistic data structure designed to test whether an element is a member of a set. It trades off accuracy for space efficiency, which means it can yield false positives but never false negatives. Here's a table for the time and space complexities for the Bloom filter:

OperationTime ComplexitySpace Complexity
InsertionO(k)O(m)
Query (membership check)O(k)O(1)

Notes:

1. k: The number of hash functions used by the Bloom filter. Both insertion and membership check operations require each of the hash functions to process the given input, which leads to a time complexity of O(k).

2. m: The number of bits in the filter. The space complexity is primarily determined by the size of the underlying bit array, and it's O(m).

It's important to note that the space efficiency and accuracy of a Bloom filter are closely tied. To reduce the probability of false positives, you would need a larger filter (higher m) and more hash functions (higher k). However, increasing k also increases the time taken for insertions and queries. Adjusting these parameters requires balancing space, time, and acceptable error rates based on the specific use case.