布隆过滤器

最新推荐文章于 2024-10-19 22:44:42 发布

mt_09

最新推荐文章于 2024-10-19 22:44:42 发布

阅读量75

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/mt_09/article/details/79541619

版权

数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

大致思路：

布隆过滤器是通过哈希函数使得字符串产生不同的无符号整数，再通过位图，一个字符串每产生一个整数，就将这个整数在位图中的位置由0置1，当一个字符串利用m个哈希函数产生m个整数在位图的位置都为1，我们大致可以认为这个字符串存在，否者不存在。

具体代码如下：

typedef char* KeyValue; 

typedef size_t(*HASH_FUNC)(KeyValue str); //这里使用一个函数指针将字符串进行转换
typedef struct BloomFilter 
{ 
BitMap _bm; 
HASH_FUNC  _hashfunc1; 
HASH_FUNC  _hashfunc2; 
HASH_FUNC  _hashfunc3; 
}BloomFilter; 
size_t BKDRHash(KeyValue str);
size_t DEKHash(KeyValue str);
size_t FNVHash(KeyValue str);



static size_t BKDRHash(KeyValue str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313
    unsigned int hash = 0;
    while (*str )
    {
        hash = hash * seed + (*str++);
    }
    return (hash & 0x7FFFFFFF);
}

size_t DEKHash(KeyValue 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;  
}  

size_t FNVHash(KeyValue str)  
{  
    if(!*str)   // 这是由本人添加，以保证空字符串返回哈希值0  
        return 0;  
    register size_t hash = 2166136261;  
    while (size_t ch = (size_t)*str++)  
    {  
        hash *= 16777619;  
        hash ^= ch;  
    }  
    return hash;  
}  


void BloomFilterInit(BloomFilter* bf, size_t range)
{
	assert(bf);
	BitMapInit(&bf->_bm,range);
	bf->_hashfunc1=BKDRHash;
    bf->_hashfunc2=DEKHash;
	bf->_hashfunc3=FNVHash;

}
void BloomFilterSet(BloomFilter* bf,KeyValue key)//插值
{
  assert(bf);
  size_t range=bf->_bm._range;
  BitMapSet(&bf->_bm,bf->_hashfunc1(key)%range);
  BitMapSet(&bf->_bm,bf->_hashfunc2(key)%range);
  BitMapSet(&bf->_bm,bf->_hashfunc3(key)%range);

}
int BloomFilterTest(BloomFilter* bf,KeyValue key)//测试
{
	if(BitMapTest(&bf->_bm,bf->_hashfunc1(key)%(bf->_bm._range))==1)
	{
		return 1;
	}
	if(BitMapTest(&bf->_bm,bf->_hashfunc2(key)%(bf->_bm._range))==1)
	{
		return 1;
	}
	if(BitMapTest(&bf->_bm,bf->_hashfunc3(key)%(bf->_bm._range))==1)
	{
		return 1;
	}
	
	   return 0;//存在

}
void BloomFilterReset(BloomFilter* bf,KeyValue key)
{
	BitMapReset(&bf->_bm,bf->_hashfunc1(key)%(bf->_bm._range));
	BitMapReset(&bf->_bm,bf->_hashfunc2(key)%(bf->_bm._range));
	BitMapReset(&bf->_bm,bf->_hashfunc3(key)%(bf->_bm._range));

}
void BloomFilterDestory(BloomFilter* bf)
{
	free(&bf->_bm);
}
void test()
{
  BloomFilter bf;
  BloomFilterInit(&bf,-1);
  BloomFilterSet(&bf,"qwe");
  BloomFilterSet(&bf,"asd");
  BloomFilterSet(&bf,"zxc");
  BloomFilterSet(&bf,"xxx");

 if( BloomFilterTest(&bf,"qwe")==0)
 {
	 printf("[qwe] 存在\t");
 }
 else
 {
 printf("[qwe] 不存在\t");
 }
 if(BloomFilterTest(&bf,"asd")==0)
 {
	 printf("[asd] 存在\t");
 }
 else
 {
	 printf("[asd] 不存在\t");
 }
if( BloomFilterTest(&bf,"ert")==0)
{
	printf("[ert] 存在\t");
}
else
{
	printf("[ert] 不存在\t");
}
	if(  BloomFilterTest(&bf,"456")==0)
	{
		printf("[456] 存在\t");
	}
	else
	{
		printf("[456] 不存在\t");
	}
 

}
int main()
{
  test();
  return 0;
}