内容概述
(win10激活0xc004f074永久解决)文本代码下载地址：Github：一、什么是布隆过滤器布隆过滤器（BloomFilter）是1970年由布隆提出的它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中优点：可以高效地进行查询，可以用来告诉你“某样东西一定不存在或者可能存在”可以高效
(win10激活0xc004f074永久 解决 )
文本 代码 下载地址：Github：https://github测试数据/dongyusheng/csdn-code/tree/master/BloomFilter
一、什么是布隆过滤器 布隆过滤器（Bloom Filter）是1970年由布隆提出的
它实际上是 一个 很长的二进制向量和一系列 随机 映射 函数 。布隆过滤器可以用于检索 一个 元素是否在 一个 集合中
优点：
可以高效地进行 查询 ，可以用来告诉你“某样东西一定不存在或者可能存在”可以高效的进行插入相比于传统的List、Set、Map等数据结构，它占用空间更少，因为其本身并不存储任何数据（重点） 缺点：
其返回的结果是概率性（存在误差）的一般不提供 删除 操作布隆过滤器一般使用在数据量特别大的场景下，一般不会使用
用的使用场景：
使用word文档时，判断某个单词是否拼写正确。例如我们在编写word时，某个单词 错误 那么就会在单词下面 显示 红色波浪线网络爬虫程序，不去爬相同的url 页面 垃圾 邮件 的过滤算法缓存崩溃后造成的缓存击穿集合重复元素的判别 查询 加速（比如基于key-value的存储系统，如re dis 等） 二、什么时候选择布隆过滤器，而不使用其他数据结构 如果想要判断 一个 元素是不是在 一个 集合里，一般想到的是将所有元素保存起来，然后通过比较确定。链表，树、哈希表等数据结构都是这种思路（如下图所示）
上面这些数据结构面对数据量特别大的时候显现的缺点：
存储容量占比高，考虑到 负载 因子的存在，通常空间是不能被用满的当数据量特别大时，会占用大量的内存空间。如果存储了类似于URL这样的key，那么内存消费太严重如果使用hashmap，如果已有元素超过了总容量的一半之后，一般就需要考虑扩容了，因为元素多了之后哈希冲突就会 增加 ，退化为链表存储的效率了 下面是两个测试程序，分别测试hashmap和红黑树 ，当元素特别多时，其 查询 和占用的内存会非常大
测试map（内部使用红黑树）
#include <iostream>#include <map>#include <string>#include <sys/time.h>#include <utility>#include <iomanip> #define MAP_ITEMS 100000 using namespace std; int main(){std::map<std::string,bool> mp;timeval startTime,endTime;//1.插入MAP_ITEMS个元素到map中gettimeofday(&startTime,NULL);std::string key = "https://blog.csdn.net/qq_41453285";for(int i = 0; i < MAP_ITEMS; ++i){string sub_key = to_string(i);mp.insert(std::make_pair(key + sub_key,1));}gettimeofday(&endTime,NULL);long insert_time = (endTime.tv_sec - startTime.tv_sec)*1000 + (endTime.tv_usec-startTime.tv_usec)/1000;//2.在map中查找 一个 元素gettimeofday(&startTime,NULL);if( mp.find(key + "10000") == mp.end())std::cout << "not found!" << std::endl;gettimeofday(&endTime,NULL);long find_time = endTime.tv_usec - startTime.tv_usec;//3.估算当前key的平均大小double key_size = key.size() + to_string(MAP_ITEMS).size()/2;//4.打印相关信息std::cout << "Number of members " << "key size " << "insert time(ms) " << "find time(us) " << std::endl;std::cout << left << setw(19) << MAP_ITEMS;std::cout << left << setw(10) << key_size;std::cout << left << setw(17) << insert_time;std::cout << left << setw(15) << find_time << std::endl;}
代码 中的MAP_ITEMS常量代表当前map中存储的元素的个数
当MAP_ITEMS为100000时，结果如下：
?当MAP_ITEMS为1000000时，结果如下：
?当MAP_ITEMS为10000000时，结果如下：
? 相关视频推荐
re dis 、布隆过滤器、分布式一致性hash中hash的妙用
5种红黑树的用途，从应用到内核场景的优缺点
学习地址：C/C++Linux鏈嶅姟鍣ㄥ紑鍙?/鍚庡彴鏋舵瀯甯堛愰浂澹版暀鑲层?-瀛︿範瑙嗛鏁欑▼-鑵捐璇惧爞
需要C/C++ Linux服务器架构师学习资料加qun 812855908 获取 （资料 包括 C/C++，Linux，golang技术， Nginx ，ZeroMQ， MysqL ，Re dis ，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker， TCP/IP ，协程，DPDK，ffmpeg 等），免费 分享
? 测试u nor dered_map（内部使用hashmap）
#include <iostream>#include <u nor dered_map>#include <string>#include <sys/time.h>#include <utility>#include <iomanip> #define MAP_ITEMS 100000 using namespace std; int main(){u nor dered_map<string,bool> u nor dermp;timeval startTime,NULL);std::string key = "https://blog.csdn.net/qq_41453285";for(int i = 0; i < MAP_ITEMS; ++i){string sub_key = to_string(i);u nor dermp.insert(std::make_pair(key + sub_key,NULL);if( u nor dermp.find(key + "10000") == u nor dermp.end())std::cout << "not found!" << std::endl;gettimeofday(&endTime,NULL);long find_time = endTime.tv_usec - startTime.tv_usec;//3.估算当前key的平均大小double key_size = key.size() + to_string(MAP_ITEMS).size()/2;//4.打印相关信息std::cout << "Number of members " << "key size " << "insert time(ms) " << "find time(us) " << std::endl;std::cout << left << setw(19) << MAP_ITEMS;std::cout << left << setw(10) << key_size;std::cout << left << setw(17) << insert_time;std::cout << left << setw(15) << find_time << std::endl;}
代码 中的MAP_ITEMS常量代表当前u nor dered_map中存储的元素的个数
当MAP_ITEMS为100000时，结果如下：
?当MAP_ITEMS为1000000时，结果如下：
?当MAP_ITEMS为10000000时，结果如下：
三、布隆过滤器的数据结构与实现原理 数据结构 布隆过滤器是 一个 bit向量或者说是 一个 bit数组（下面的数字为索引） 。如下所示：
? 其最小单位为bit，初始化时全部置为0
添加 、 查询 原理
布隆过滤器 添加 原理：利用K个Hash 函数 ，将元素传入到这K个Hash 函数 中，并且映射到bit向量的K个点中，并且将映射到的K个点置为1
布隆过滤器 查询 原理：
利用K个Hash 函数 ，将元素传入到这K个Hash 函数 中，并且映射到bit向量的K个点中如果这些点中有任何 一个 为0，则被检测的元素一定不存在如果这些点都返回1，则被检测的元素很可能（因为布隆过滤器存在误差）存在，但是不一定百分百存在上面 添加 、 查询 使用的Hash 函数 一般都是相同的，实现设计好的
为什么布隆过滤器要使用多个Hash 函数 ？
Hash面临的问题就是冲突。假设Hash 函数 是良好的，如果我们的位阵列长度为m个点，那么如果我们想将冲突率降低到例如 1%，这个散列表就只能容纳 m/100个元素 解决方法 较简单，使用K>1的布隆过滤器，即K个 函数 将每个元素改为对应于K个bits，因为误判度会降低很多，并且如果参数k和m选取得好，一半的m可被置为1 一个 重要的概念： 针对于 一个 特定的哈希 函数 和 一个 特定的值，那么该哈希 函数 返回的值每次都是固定的，不可能出现多次 调用 之间出现哈希 函数 返回值不同的情况
演示说明 假设我们的布隆过滤器有三个哈希 函数 ，分别名为hash1、hash2、hash3
① 添加 元素： 针对于“baidu”这个元素，我们 调用 三个哈希 函数 ，将其映射到bit向量的三个位置（分别为1、4、7），并且将对应的位置置为1
? ② 添加 元素： 现在针对于“tencent”这个元素，我们也 调用 三个哈希 函数 ，将其映射到bit向量的三个位置（分别为3、4、8），并且将对应的位置置为1
③此时，整个bit向量的1、3、4、7、8这几个位置被置为1了。其中4这个索引被覆盖了，因为“baidu”和“tencent”都将其置为1，覆盖的索引与误判率有关，详情见下面的介绍
④去 查询 一个 不存在的元素，并且确定其肯定不存在：例如现在我们去 查询 “dongshao”这个元素，假设 调用 上面的三个哈希 函数 返回的索引是1、5、8，通过上图我们知道5这个索引处为0，因此“dongshao”这个元素一定不存在，因为如果存在的话，那么5这个位置应该被置为1才对（见上面的“ 一个 重要概念”）
⑤去 查询 “baidu”这个元素，不能判断其百分百存在：我们将“baidu”传入上面的三个哈希 函数 中，哈希返回的对应索引值为1、4、7，发现1、4、7这几个索引处都为1，因此我们判断“baidu”这个元素可能存在。为什么不是百分百确定呢？见下面的误判率介绍
误判率 布隆过滤器允许存在一定的误判断，误判率也称为“假阳”
误判率一般是出现在 查询 的时候
例如上面我们去 查询 “baidu”的时候，由于“baidu”之前被我们插入过，为什么还不能百分百确定它一定存在呢？
因为“tencent”这个元素在插入的时候，将4这个索引置为1了假设我们 查询 “baidu”的时候实际返回的是1、7索引为1，4索引为0。而4索引又被tencent覆盖为1，所以最终“baidu”最终看到的是1、4、7索引都为1，我们不能百分百确定“baidu”这个元素存在因此，当随着 增加 的值越来越多时，bit向量被置为1的 数量 也就会越来越多，因此误判率会越来越大。例如，当 查询 “taobao”时，万一所有的哈希 函数 返回的对应bit都为1，那么布隆过滤器可能也认为“taobao”这个元素存在
布隆过滤器一般不拥有 删除 的 功能 我们一般不能从布隆过滤器中 删除 元素。考虑下面几种情况：
因为要 删除 该元素，我们必须百分百确保该元素存在于布隆过滤器中，而布隆过滤器由于存在误判率，无法确定该元素百分百存在于布隆过滤器内另外计数器回绕也会造成问题如果我们因为某 一个 元素而将其对应的bit位 删除 变为0，那么如果这些bit位也是其他元素正在使用的，那么其他元素在 查询 时就会返回0，从而认为元素不存在而造成误判 四、误判概率的相关证明和计算 证明①（哈希 函数 越多、插入元素越少，误判率越低）
假设布隆过滤器中的hash 函数 满足simple uniform hashing(简单一致散列)假设：每个元素都等概率地hash到m个slot中的任何 一个 ，与其它元素被hash到哪个slot无关
若m为bit数（向量表的长度）， 则对某一特定bit位在 一个 元素由某特定hash 函数 插入时没有被置位为1的概率为：
?则k个hash 函数 中没有 一个 对其置位的概率为，随着k的 增加 ，概率会变小：
?如果插入了n个元素，但都没有将其置位的概率为：
?现在考虑 查询 阶段，若对应某个待 查询 元素的k bits全部置位为1，则可判定其在集合中。 因此将某元素误判的概率p为：
?现在考虑 查询 阶段，若对应某个待query元素的k bits全部置位为1，则可判定其在集合中。 因此将某元素误判的概率p为：
?由于
?当x→0时，并且
?当m很大时趋近于0，所以：
?从上式中可以看出，当m增大或n减小时，都会使得误判率减小
证明②（何时误判率最低？） 现在计算对于给定的m和n，k为何值时可以使得误判率最低。设误判率为k的 函数 为：
下面求最值，即是误差趋近于0
因此，即当
?时误判率最低，此时误判率为：
?可以看出若要使得误判率≤1/2，则：
?这说明了若想保持某固定误判率不变，布隆过滤器的bit数m与被 增加 的元素数n应该是线性同步 增加 的
五、Hash 函数 的选择 常见的应用比较广的hash 函数 有MD5， SHA1， SHA256， 一般用于信息安全方面，比如签名认证和加密等。比如我们传输 文件 时习惯用对原 文件 内容 计算它的MD5值， 生成 128 bit的整数，通 常我们说的32位MD5值，是转换为HEX格式后的32个字符
MurmurHash：
MurmurHash是2008年发明的，相比较MD5， MurMurhash不太安全（当然MD5也被破译了， sha也可以被破译），但是 性能 是MD5的几十倍MurmurHash有很多个版本， MurmurHash3修复了MurmurHash2的一些缺陷同时速度还要快一些，因此很多开源项目有用，比如 Nginx 、 re dis 、 memcashed、 Hadoop等，比如用于计算一致性hash等MurmurHash被比较好的测试过了，测试 方法 见https://github测试数据/aappleby/smhasherMurMurhash的实现也可以参考smhasher，或者参考https://sites.google测试数据/site/murmurhash我们演示的布隆过滤器中的hash 函数 选择MurmurHash2算法 补充：双重散列
双重散列是线性开型寻址散列（开放寻址法）中的冲突 解决 技术。双重散列使用在发生冲突时将第二个散列 函数 应用于键的想法
此算法使用下面的公式来进行双哈希处理。hash1() 和 hash2() 是哈希 函数 ，而 TABLE_SIZE 是哈希表的大小。 当发生碰撞时，我们通过重复 增加 步长i 来寻找键
六、布隆过滤器的实现 布隆过滤器在实现时一般设计考虑下面几样东西：
n：布隆过滤器最大处理的元素的个数P：希望的误差率m：布隆过滤器的bit位数目k：哈希 函数 的个数应用时首先要先由 用户 决定要 增加 的最多元素个数n和希望的误差率P。这也是 一个 设计完整的布隆过滤器需要 用户 输入的仅有的两个参数（加入hash种子则为3个），之后的所有参数将由系 统计 算，并由此建立布隆过滤器
①首先根据传入的n和p计算需要的内存大小m bits:
? ②再由m，n得到hash function的个数：
?至此系统所需的参数已经备齐，后面就可以 添加 n个元素到布隆过滤器中，进行 查询
布隆过滤器空间利用率问题 根据公式，当k最优时：
?因此可验证当P=1%时，存储每个元素需要9.6 bits：
?而每当想将误判率降低为原来的1/10，则存储每个元素需要 增加 4.8 bits：
布隆过滤器误判率对比表 如果方便知道需要使用多少位才能降低 错误 概率，可以从下表所示的存储项目和位数 比率估计布隆过滤器的误判率
为每个URL分配两个字节就可以达到千分之几的冲突。比较保守的实现是，为每个URL 分配4个字节，项目和位数比是1∶32，误判率是0.00000021167340。对于5000万 数量 级的URL，布隆过滤器只占用200MB的空间
七、在线验证公式 测试网址： https://hur.st/bloomfilter/
下面是 一个 测试网址，可以根据你输入的数值返回对应的数据：
n：布隆过滤器最大处理的元素的个数P：希望的误差率m：布隆过滤器的bit位数目k：哈希 函数 的个数
八、编码实现 bloomfilter.h 这个 代码 是布隆过滤器的实现 代码
#ifndef __MICRO_BLOOMFILTER_H__#define __MICRO_BLOOMFILTER_H__ /** * * 仿照Cassandra中的BloomFilter实现，Hash选用MurmurHash2，通过双重散列公式 生成 散列 函数 ，参考：http://hur.st/bloomfilter * Hash(key,i) = (H1(key) + i * H2(key)) % m ***/ #include <st dio .h>#include <stdlib.h>#include <stdint.h>#include <string.h>#include <math.h> #define __BLOOMFILTER_VERSION__ "1.1"#define __MGAIC_CODE__ (0x01464C42) /** * BloomFilter使用例子： * static BaseBloomFilter stBloomFilter = {0}; * * 初始化BloomFilter(最大100000元素，不超过0.00001的 错误 率)： * InitBloomFilter(&stBloomFilter,100000,0.00001); * 重置BloomFilter： * ResetBloomFilter(&stBloomFilter); * 释放BloomFilter: * FreeBloomFilter(&stBloomFilter); * * 向BloomFilter中新增 一个 数值（0-正常，1-加入数值过多）： * uint32_t dwValue; * iRet = BloomFilter_Add(&stBloomFilter,&dwValue,sizeof(uint32_t)); * 检查数值是否在BloomFilter内（0-存在，1-不存在）： * iRet = BloomFilter_Check(&stBloomFilter,sizeof(uint32_t)); * * (1.1新增) 将 生成 好的BloomFilter写入 文件 : * iRet = SaveBloomFilterToFile(&stBloomFilter,"dump.bin") * (1.1新增) 从 文件 读取 生成 好的BloomFilter: * iRet = LoadBloomFilterFromFile(&stBloomFilter,"dump.bin")**/ // 注意，要让Add/Check 函数 内联，必须使用 -O2 或以上的优化等级#define FORCE_INLINE __attribute__((always_inline)) #define BYTE_BITS (8)#define MIX_UINT64(v) ((uint32_t)((v>>32)^(v))) #define SETBIT(filter,n) (filter->pstFilter[n/BYTE_BITS] |= (1 << (n%BYTE_BITS)))#define GETBIT(filter,n) (filter->pstFilter[n/BYTE_BITS] & (1 << (n%BYTE_BITS))) #pragma pack(1) // BloomFilter结构定义typedef struct{ uint8_t cInitFlag; // 初始化标志，为0时的第一次Add()会对stFilter[]做初始化 uint8_t cResv[3]; uint32_t dwMaxItems; // n - BloomFilter中最大元素个数 (输入量) double dProbFalse; // p - 假阳概率(误判率) (输入量，比如万分之一：0.00001) uint32_t dwFilterBits; // m = ; - BloomFilter的比特数 uint32_t dwHashFuncs; // k = round(log(2.0) * m / n); - 哈希 函数 个数 uint32_t dwSeed; // MurmurHash的种子偏移量 uint32_t dwCount; // Add()的计数，超过MAX_BLOOMFILTER_N则返回失败 uint32_t dwFilterSize; // dwFilterBits / BYTE_BITS unsigned char *pstFilter; // BloomFilter存储指针，使用malloc分配 uint32_t *pdwHashPos; // 存储上次hash得到的K个bit位置数组(由bloom_hash填充)} BaseBloomFilter; // BloomFilter 文件 头部定义typedef struct{ uint32_t dwMagicCode; // 文件 头部标识，填充 __MGAIC_CODE__ uint32_t dwSeed; uint32_t dwCount; uint32_t dwMaxItems; // n - BloomFilter中最大元素个数 (输入量) double dProbFalse; // p - 假阳概率 (输入量，比如万分之一：0.00001) uint32_t dwFilterBits; // m = ceil((n * log(p)) / log(1.0 / (pow(2.0,log(2.0))))); - BloomFilter的比特数 uint32_t dwHashFuncs; // k = round(log(2.0) * m / n); - 哈希 函数 个数 uint32_t dwResv[6]; uint32_t dwFileCrc; // (未使用)整个 文件 的校验和 uint32_t dwFilterSize; // 后面Filter的Buffer长度} BloomFileHead; #pragma pack() // 计算BloomFilter的参数m,kstatic inline void _CalcBloomFilterP ara m(uint32_t n,double p,uint32_t *pm,uint32_t *pk){ /** * n - Number of items in the filter * p - Probability of false positives,float between 0 and 1 or a number indicating 1-in-p * m - Number of bits in the filter * k - Number of hash functions * * f = ln(2) × ln(1/2) × m / n = (0.6185) ^ (m/n) * m = -1 * ln(p) × n / 0.6185,这里有 错误 * k = ln(2) × m / n = 0.6931 * m / n * darren修正： * m = -1*n*ln(p)/((ln(2))^2) = -1*n*ln(p)/(ln(2)*ln(2)) = -1*n*ln(p)/(0.69314718055995*0.69314718055995)) * = -1*n*ln(p)/0.4804530139182079271955440025 * k = ln(2)*m/n **/ uint32_t m,k,m2; // printf("ln(2):%lf,ln(p):%lfn",log(2),log(p)); // 用来验证 函数 正确性 // 计算指定假阳(误差)概率下需要的比特数 m =(uint32_t) ceil(-1.0 * n * log(p) / 0.480453); //darren 修正//m2 =(uint32_t) ceil(-1 * n * log(p) / 0.480453); // 错误 写法 m = (m - m % 64) + 64; // 8字节对齐 // 计算哈希 函数 个数 double double_k = (0.69314 * m / n); // ln(2)*m/n // 这里只是为了debug出来看看具体的浮点数值 k = round(double_k); // 返回x的四舍五入整数值。 printf("orig_k:%lf,k:%un",double_k,k); *pm = m; *pk = k; return;} // 根据目标精度和数据个数，初始化BloomFilter结构/** * @brief 初始化布隆过滤器 * @p ara m pstBloomfilter 布隆过滤器实例 * @p ara m dwSeed hash种子 * @p ara m dwMaxItems 存储容量 * @p ara m dProbFalse 允许的误判率 * @return 返回值 * -1 传入的布隆过滤器为空 * -2 hash种子 错误 或误差>=1 */inline int InitBloomFilter(BaseBloomFilter *pstBloomfilter,uint32_t dwSeed,uint32_t dwMaxItems,double dProbFalse){ if (pstBloomfilter == NULL) return -1; if ((dProbFalse <= 0) || (dProbFalse >= 1)) return -2; // 先检查是否重复Init，释放内存 if (pstBloomfilter->pstFilter != NULL) free(pstBloomfilter->pstFilter); if (pstBloomfilter->pdwHashPos != NULL) free(pstBloomfilter->pdwHashPos); memset(pstBloomfilter,sizeof(BaseBloomFilter)); // 初始化内存结构，并计算BloomFilter需要的空间 pstBloomfilter->dwMaxItems = dwMaxItems; // 最大存储 pstBloomfilter->dProbFalse = dProbFalse; // 误差 pstBloomfilter->dwSeed = dwSeed; // hash种子 // 计算 m,k _CalcBloomFilterP ara m(pstBloomfilter->dwMaxItems,pstBloomfilter->dProbFalse,&pstBloomfilter->dwFilterBits,&pstBloomfilter->dwHashFuncs); // 分配BloomFilter的存储空间 pstBloomfilter->dwFilterSize = pstBloomfilter->dwFilterBits / BYTE_BITS; pstBloomfilter->pstFilter = (unsigned char *) malloc(pstBloomfilter->dwFilterSize); if (NULL == pstBloomfilter->pstFilter) return -100; // 哈希结果数组，每个哈希 函数 一个 pstBloomfilter->pdwHashPos = (uint32_t*) malloc(pstBloomfilter->dwHashFuncs * sizeof(uint32_t)); if (NULL == pstBloomfilter->pdwHashPos) return -200; printf(">>> Init BloomFilter(n=%u,p=%e,m=%u,k=%d),malloc() size=%.6fMB,items:bits=1:%0.1lfn",pstBloomfilter->dwMaxItems,pstBloomfilter->dwFilterBits,pstBloomfilter->dwHashFuncs,(double)pstBloomfilter->dwFilterSize/1024/1024,pstBloomfilter->dwFilterBits*1.0/pstBloomfilter->dwMaxItems); // 初始化BloomFilter的内存 memset(pstBloomfilter->pstFilter,pstBloomfilter->dwFilterSize); pstBloomfilter->cInitFlag = 1; return 0;} // 释放BloomFilterinline int FreeBloomFilter(BaseBloomFilter *pstBloomfilter){ if (pstBloomfilter == NULL) return -1; pstBloomfilter->cInitFlag = 0; pstBloomfilter->dwCount = 0; free(pstBloomfilter->pstFilter); pstBloomfilter->pstFilter = NULL; free(pstBloomfilter->pdwHashPos); pstBloomfilter->pdwHashPos = NULL; return 0;} // 重置BloomFilter// 注意: Reset() 函数 不会立即初始化stFilter，而是当一次Add()时去memsetinline int ResetBloomFilter(BaseBloomFilter *pstBloomfilter){ if (pstBloomfilter == NULL) return -1; pstBloomfilter->cInitFlag = 0; pstBloomfilter->dwCount = 0; return 0;} // 和ResetBloomFilter不同， 调用 后立即memset内存inline int RealResetBloomFilter(BaseBloomFilter *pstBloomfilter){ if (pstBloomfilter == NULL) return -1; memset(pstBloomfilter->pstFilter,pstBloomfilter->dwFilterSize); pstBloomfilter->cInitFlag = 1; pstBloomfilter->dwCount = 0; return 0;} ////// 函数 FORCE_INLINE，加速执行///// MurmurHash2,64-bit versions,by Austin Appleby// https://sites.google测试数据/site/murmurhash/FORCE_INLINE uint64_t MurmurHash2_x64 ( const void * key,int len,uint32_t seed ){ const uint64_t m = 0xc6a4a7935bd1e995; const int r = 47; uint64_t h = seed ^ (len * m); const uint64_t * data = (const uint64_t *)key; const uint64_t * end = data + (len/8); while(data != end) { uint64_t k = *data++; k *= m; k ^= k >> r; k *= m; h ^= k; h *= m; } const uint8_t * data2 = (const uint8_t*)data; switch(len & 7) { case 7: h ^= ((uint64_t)data2[6]) << 48; case 6: h ^= ((uint64_t)data2[5]) << 40; case 5: h ^= ((uint64_t)data2[4]) << 32; case 4: h ^= ((uint64_t)data2[3]) << 24; case 3: h ^= ((uint64_t)data2[2]) << 16; case 2: h ^= ((uint64_t)data2[1]) << 8; case 1: h ^= ((uint64_t)data2[0]); h *= m; }; h ^= h >> r; h *= m; h ^= h >> r; return h;} // 双重散列封装，k个 函数 函数 ,比如要20个FORCE_INLINE void bloom_hash(BaseBloomFilter *pstBloomfilter,const void * key,int len){ //if (pstBloomfilter == NULL) return; int i; uint32_t dwFilterBits = pstBloomfilter->dwFilterBits; uint64_t hash1 = MurmurHash2_x64(key,len,pstBloomfilter->dwSeed); uint64_t hash2 = MurmurHash2_x6电脑4(key,MIX_UINT64(hash1)); for (i = 0; i < (int)pstBloomfilter->dwHashFuncs; i++) { // k0 = (hash1 + 0*hash2) % dwFilterBits; // dwFilterBits bit向量的长度 // k1 = (hash1 + 1*hash2) % dwFilterBits; pstBloomfilter->pdwHashPos[i] = (hash1 + i*hash2) % dwFilterBits; } return;} // 向BloomFilter中新增 一个 元素// 成功返回0，当 添加 数据超过限制值时返回1 提示 用户 FORCE_INLINE int BloomFilter_Add(BaseBloomFilter *pstBloomfilter,int len){ if ((pstBloomfilter == NULL) || (key == NULL) || (len <= 0)) return -1; int i; if (pstBloomfilter->cInitFlag != 1) { // Reset后没有初始化，使用前需要memset memset(pstBloomfilter->pstFilter,pstBloomfilter->dwFilterSize); pstBloomfilter->cInitFlag = 1; } // hash key到bloomfilter中,为了计算不同hash命中的位置，保存pdwHashPos数组 bloom_hash(pstBloomfilter,key,len); for (i = 0; i < (int)pstBloomfilter->dwHashFuncs; i++) { // dwHashFuncs[0] = hash0(key) // dwHashFuncs[1] = hash1(key) // dwHashFuncs[k-1] = hashk-1(key) SETBIT(pstBloomfilter,电脑 pstBloomfilter->pdwHashPos[i]); } // 增加 count数 pstBloomfilter->dwCount++; if (pstBloomfilter->dwCount <= pstBloomfilter->dwMaxItems) return 0; else return 1; // 超过N最大值，可能出现准确率下降等情况} // 检查 一个 元素是否在bloomfilter中// 返回：0-存在，1-不存在，负数表示失败FORCE_INLINE int BloomFilter_Check(BaseBloomFilter *pstBloomfilter,int len){ if ((pstBloomfilter == NULL) || (key == NULL) || (len <= 0)) return -1; int i; bloom_hash(pstBloomfilter,len); for (i = 0; i < (int)pstBloomfilter->dwHashFuncs; i++) { // 如果有任意bit不为1，说明key不在bloomfilter中 // 注意: GETBIT()返回不是0|1，高位可能出现128之类的情况 if (GETBIT(pstBloomfilter,pstBloomfilter->pdwHashPos[i]) == 0) return 1; } return 0;} /* 文件 相关封装 */// 将 生成 好的BloomFilter写入 文件 inline int SaveBloomFilterToFile(BaseBloomFilter *pstBloomfilter,char *szFileName){ if ((pstBloomfilter == NULL) || (szFileName == NULL)) return -1; int iRet; FILE *pFile; static BloomFileHead stFileHeader = {0}; pFile = fopen(szFileName,"wb"); if (pFile == NULL) { perror("fopen"); 电脑 return -11; } // 先写入 文件 头 stFileHeader.dwMagicCode = __MGAIC_CODE__; stFileHeader.dwSeed = pstBloomfilter->dwSeed; stFileHeader.dwCount = pstBloomfilter->dwCount; stFileHeader.dwMaxItems = pstBloomfilter->dwMaxItems; stFileHeader.dProbFalse = pstBloomfilter->dProbFalse; stFileHeader.dwFilterBits = pstBloomfilter->dwFilterBits; stFileHeader.dwHashFuncs = pstBloomfilter->dwHashFuncs; stFileHeader.dwFilterSize = pstBloomfilter->dwFilterSize; iRet = fwrite((const void*)&stFileHeader,sizeof(stFileHeader),1,pFile); if (iRet != 1) { perror("fwrite(head)"); return -21; } // 接着写入BloomFilter的 内容 iRet = fwrite(pstBloomfilter->pstFilter,pstBloomfilter->dwFilterSize,pFile); if ((uint32_t)iRet != pstBloomfilter->dwFilterSize) { perror("fwrite(data)"); return -31; } fclose(pFile); return 0;} // 从 文件 读取 生成 好的BloomFilterinline int LoadBloomFilterFromFile(BaseBloomFilter *pstBloomfilter,char *szFileName){ if ((pstBloomfilter == NULL) || (szFileName == NULL)) return -1; int iRet; FILE *pFile; static BloomFileHead stFileHeader = {0}; if (pstBloomfilter->pstFilter != NULL) free(pstBloomfilter->pstFilter); if (pstBloomfilter->pdwHashPos != NULL) free(pstBloomfilter->pdwHashPos); // pFile = fopen(szFileName,"rb"); if (pFile == NULL) { perror("fopen"); return -11; } // 读取并 检查文件 头 iRet = fread((void*)&stFileHeader,pFile); if (iRet != 1) { perror("fread(head)"); return -21; } if ((stFileHeader.dwMagicCode != __MGAIC_CODE__) || (stFileHeader.dwFilterBits != stFileHeader.dwFilterSize*BYTE_BITS)) return -50; // 初始化传入的 BaseBloomFilter 结构 pstBloomfilter->dwMaxItems = stFileHeader.dwMaxItems; pstBloomfilter->dProbFalse = stFileHeader.dProbFalse; pstBloomfilter->dwFilterBits = stFileHeader.dwFilterBits; pstBloomfilter->dwHashFuncs = stFileHeader.dwHashFuncs; pstBloomfilter->dwSeed = stFileHeader.dwSeed; pstBloomfilter->dwCount = stFileHeader.dwCount; pstBloomfilter->dwFilterSize = stFileHeader.dwFilterSize; pstBloomfilter->pstFilter = (unsigned char *) malloc(pstBloomfilter->dwFilterSize); if (NULL == pstBloomfilter->pstFilter) return -100; pstBloomfilter->pdwHashPos = (uint32_t*) malloc(pstBloomfilter->dwHashFuncs * sizeof(uint32_t)); if (NULL == pstBloomfilter->pdwHashPos) return -200; // 将后面的Data部分读入 pstFilter iRet = fread((void*)(pstBloomfilter->pstFilter),pFile); if ((uint32_t)iRet != pstBloomfilter->dwFilterSize) { perror("fread(data)"); return -31; } pstBloomfilter->cInitFlag = 1; printf(">>> Load BloomFilter(n=%u,p=%f,malloc() size=%.2fMBn",(double)pstBloomfilter->dwFilterSize/1024/1024); fclose(pFile); return 0;} #endif bloomfilter.cpp
这个是布隆过滤器的测试 代码
#include "bloomfilter.h"#include <st dio .h> #define MAX_ITEMS 6000000 // 设置最大元素个数#define ADD_ITEMS 1000 // 添加 测试元素#define P_ERROR 0.0001// 设置误差 //int main(int argc,char** argv){ printf(" test bloomfiltern"); // 1. 定义BaseBloomFilter static BaseBloomFilter stBloomFilter = {0}; // 2. 初始化stBloomFilter， 调用 时传入hash种子，存储容量，以及允许的误判率 InitBloomFilter(&stBloomFilter,MAX_ITEMS,P_ERROR); // 3. 向BloomFilter中新增数值 char url[128] = {0}; for(int i = 0; i < ADD_ITEMS; i++){ sprintf(url,"https://blog.csdn.net/qq_41453285/%d.html",i); if(0 == BloomFilter_Add(&stBloomFilter,(const void*)url,strlen(url))){ // printf("add %s success",url); }else{ printf("add %s Failed ",url); } memset(url,sizeof(url)); } // 4. check url exist or not char* str = "https://blog.csdn.net/qq_41453285/0.html"; if (0 == BloomFilter_Check(&stBloomFilter,(const void*)str,strlen(str)) ){ printf("https://blog.csdn.net/qq_41453285/0.html existn"); } char* str2 = "https://blog.csdn.net/qq_41453285/10001.html"; if (0 != BloomFilter_Check(&stBloomFilter,(const void*)str2,strlen(str2)) ){ printf("https://blog.csdn.net/qq_41453285/10001.html not existn"); } // 5. free bloomfilter FreeBloomFilter(&stBloomFilter); getchar(); return 0;}
结果图下图所示：
n：布隆过滤器最大处理的元素的个数P：希望的误差率m：布隆过滤器的bit位数目k：哈希 函数 的个数
?
电脑
总结
以上是 为你收集整理的 win10激活0xc004f014-(win10激活0xc004f074永久解决) 全部内容。
如果觉得 网站内容还不错，欢迎将 网站 推荐给好友。
Win10系统搜不到airpods怎么办？Win10配对不了airpods的解决方法
Airpods是苹果品牌的蓝牙无线耳机，有些用户想将airpods连接电脑，但是遇到Win10系统搜不到airpods的情况，导致没办法配对，这是怎么回事呢？可能是电脑蓝牙没有打开被可发现的设置，本篇整理了详细的解决方法，接下来和小编一起看下去吧。
win10提示任务管理器被管理员停用怎么解决？
任务管理器能够实时的反馈软件的状态已经CPU的使用情况，最近有部分使用win10系统的小伙伴反映说打开被提示任务管理器被管理员停用，面对这个情况不知道要如何解决，那么本期的win10教程就来为大伙进行解答，有需要的用户欢迎来下载使用。
win10系统wifi不能输入怎么办？win10无法输入wifi密码解决方法
现在很多台式和笔记本电脑都是使用了win10系统，也安装了无线网卡，可以通过wifi连接进行使用，但是有些小伙伴发现无法输入密码，导致连接失败，面对这个问题，大伙都不知道怎么解决，那么本期就为大伙带来三种解决方法，一起来了解看看吧。
Win10电脑任务栏图标重叠怎么分开？Win10任务栏图标重叠的解决方法
有些用户在使用电脑的时候，会一次性打开多个窗口进行操作，发现此时的任务栏图标会重叠，导致看不清楚，很影响操作，那么应该怎么设置不重叠呢？其实将窗口设置为平铺显示即可，就此，本篇整理了详细的教程，分享给大家，一起看看吧。
Win10应用商店打不开提示无法加载页面请重试怎么办？
电脑中的应用商店可以帮助用户下载应用程序，非常的方便实用，遇到应用商店打不开的情况是怎么回事呢？最近就有Win10系统的用户反映这个问题，其实造成这个问题的原因有多种，本篇带来了三种不同的解决方法，分享给大家，感兴趣的一起看下去吧。
Win10不能连续输入字符怎么办？Win10不能连续输入字符的解决方法
Win10系统是现在的主流系统，在使用的过程中难免会遇到各种故障问题，最近就有一些用户向小编询问，使用电脑打字的时候发现没办法按同一个键进行连续输入，遇到这种情况怎么处理呢？就此，本篇带来了详细的教程，分享给大家，一起看看吧。
Win10怎么退出已有的管理员账号？Win10退出本地管理员账户方法
最近有用户向小编询问关于如何退出账户的问题，在使用Win10系统的时候，想要登陆一个新的账号，就想把之前的管理员账号退出，会不会很麻烦呢？其实不会，操作简单易上手，就此，本篇整理了详细的教程，分享给大家，感兴趣的一起看看吧。
Win10系统如何禁用Chrome清理功能？
现在大部分用户的电脑都在使用Win10系统，在使用谷歌浏览器浏览的时候，想要禁止使用谷歌浏览器的清理功能，但是不知道具体怎么设置操作，其实方法很简单，针对这一问题，本篇整理了详细的教程，操作简单易上手，分享给大家，一起来看看吧。
查看更多关于win10激活0xc004f014-(win10激活0xc004f074永久解决)的详细内容...