布隆過濾器課堂代碼

bloom.h

#pragma once
#include "bitmap.h"
#define BloomHashCount 2
typedef uint64_t (*BloomHash)(const char*);

typedef struct BloomFilter{
    Bitmap bm;
    BloomHash bloom_hash[BloomHashCount];
} BloomFilter;

void BloomFilterInit(BloomFilter* bf);

void BloomFilterDestroy(BloomFilter* bf);

void BloomFilterrInsert(BloomFilter* bf, const char* str);

int BloomFilterIsExist(BloomFilter* bf, const char* str);

bloom.c

#include "bloom.h"
#include <stdlib.h>
#include "hash_func.h"

//這裏引入幾種哈希模板函數

void BloomFilterInit(BloomFilter* bf){
    if(bf == NULL){
        return;
    }
    BitmapInit(&bf->bm, 1000);
    bf->bloom_hash[0] = SDBMHash;
    bf->bloom_hash[1] = BKDRHash;
    return;
}

void BloomFilterDestroy(BloomFilter* bf){
    if(bf == NULL){
        return;
    }
    bf->bloom_hash[0] = NULL;
    bf->bloom_hash[1] = NULL;
    BitmapDestroy(&bf->bm);
    return;
}

void BloomFilterrInsert(BloomFilter* bf, const char* str){
    if(bf == NULL || str == NULL){
        return;
    }
    size_t i = 0;
    for(;i < BloomHashCount;++i){
        uint64_t hash = bf->bloom_hash[i](str) % 1000;
        BitmapSet(&bf->bm, hash);
    }
    return;
}

int BloomFilterIsExist(BloomFilter* bf, const char* str){
    if(bf == NULL || str == NULL){
        return 0;
    }
    size_t i = 0;
    for(;i < BloomHashCount;++i){
        uint64_t hash = bf->bloom_hash[i](str) % 1000;
        int ret = BitmapTest(&bf->bm, hash);
        if(ret == 0){
            return 0;
        }
    }
    return 1;
}

hash_func.h

#pragma once
#include <stddef.h>
#include <stdint.h>

uint64_t SDBMHash(const char* str);
uint64_t BKDRHash(const char* str);

hash_func.c

#include "hash_func.h"
#include <stdio.h>

uint64_t SDBMHash(const char* str){
    (void)str;
    //哈希算法
    return 0;
}

uint64_t BKDRHash(const char* str){
    (void)str;
    //哈希算法
    return 0;
}

bitmap.h

#pragma once
#include <stdint.h>

typedef struct Bitmap{
    uint64_t* data;
    uint64_t capacity;
} Bitmap;

int BitmapTest(Bitmap* bm, uint64_t index);

void BitmapInit(Bitmap* bm, uint64_t capacity);

void BitmapDestroy(Bitmap* bm);

void BitmapSet(Bitmap* bm, uint64_t index);

void BitmapUnset(Bitmap* bm, uint64_t index);

void BitmapFill(Bitmap* bm);

void BitmapClear(Bitmap* bm);

bitmap.c

#include "bitmap.h"
#include <stdlib.h>
#include <string.h>

uint64_t GetSize(uint64_t capacity){
    uint64_t size = capacity / (sizeof(uint64_t)*8) + 1;
    return size;
}

void BitmapInit(Bitmap* bm, uint64_t capacity){
    if(bm == NULL){
        return;
    }
    //N/(sizeof(uint64_t)*8)+1
    bm->capacity = capacity;
    uint64_t size = capacity / (sizeof(bm->data[0])*8) + 1;
    bm->data = (uint64_t*)malloc(sizeof(uint64_t)*size);
    memset(bm->data, 0, sizeof(uint64_t)*size);
    return;
}

void BitmapDestroy(Bitmap* bm){
    if(bm == NULL){
        return;
    }
    bm->capacity = 0;
    free(bm->data);
    return;
}

void  GetOffset(uint64_t index, uint64_t* n, uint64_t* offset){
    *n = index / (sizeof(uint64_t)*8);
    *offset = index % (sizeof(uint64_t)*8);
    return;
}

//測試某一位是否爲1
int BitmapTest(Bitmap* bm, uint64_t index){
    if(bm == NULL || index >= bm->capacity){
        return 0;
    }
    uint64_t n, offset;
    GetOffset(index, &n, &offset);
    uint64_t ret = bm->data[n] & (0x1ul << offset);
    return ret > 0 ? 1 : 0;
}

//給某一位設置爲1
void BitmapSet(Bitmap* bm, uint64_t index){
    if( bm == NULL || index >= bm->capacity ){
        return;
    }
    uint64_t n, offset;
    GetOffset(index, &n, &offset);
    bm->data[n] |= (0x1ul << offset);
    return;
}

//給某一位賦值爲0
void BitmapUnset(Bitmap* bm, uint64_t index){
    if( bm == NULL || index >= bm->capacity ){
        return;
    }
    uint64_t n, offset;
    GetOffset(index, &n, &offset);
    bm->data[n] &= ~(0x1ul << offset);
    return;
}

//全1
void BitmapFill(Bitmap* bm){
    if(bm == NULL){
        return;
    }
    uint64_t size = GetSize(bm->capacity);
    memset(bm->data,0xff ,sizeof(uint64_t)*size);
    return;
}

void BitmapClear(Bitmap* bm){
    if(bm == NULL){
        return;
    }
    uint64_t size = GetSize(bm->capacity);
    memset(bm->data,0x0 ,sizeof(uint64_t)*size);
    return;
}