2. 程式人生 > >海量數據處理算法—Bloom Filter

海量數據處理算法—Bloom Filter

阿新 • • 發佈：2017-09-26
內存地址空間 核心 全世界 在服務器 i++ func ras get 地址空間

1. Bloom-Filter算法簡介

Bloom-Filter，即布隆過濾器，1970年由Bloom中提出。它可以用於檢索一個元素是否在一個集合中。

Bloom Filter（BF）是一種空間效率很高的隨機數據結構，它利用位數組很簡潔地表示一個集合，並能判斷一個元素是否屬於這個集合。它是一個判斷元素是否存在集合的快速的概率算法。Bloom Filter有可能會出現錯誤判斷，但不會漏掉判斷。也就是Bloom Filter判斷元素不再集合，那肯定不在。如果判斷元素存在集合中，有一定的概率判斷錯誤。因此，Bloom Filter不適合那些“零錯誤”的應用場合。而在能容忍低錯誤率的應用場合下，Bloom Filter比其他常見的算法（如hash，折半查找）極大節省了空間。

它的優點是空間效率和查詢時間都遠遠超過一般的算法，缺點是有一定的誤識別率和刪除困難。

Bloom Filter的詳細介紹：Bloom Filter

2、 Bloom-Filter的基本思想

Bloom-Filter算法的核心思想就是利用多個不同的Hash函數來解決“沖突”。

計算某元素x是否在一個集合中，首先能想到的方法就是將所有的已知元素保存起來構成一個集合R，然後用元素x跟這些R中的元素一一比較來判斷是否存在於集合R中；我們可以采用鏈表等數據結構來實現。但是，隨著集合R中元素的增加，其占用的內存將越來越大。試想，如果有幾千萬個不同網頁需要下載，所需的內存將足以占用掉整個進程的內存地址空間。即使用MD5，UUID這些方法將URL轉成固定的短小的字符串，內存占用也是相當巨大的。

於是，我們會想到用Hash table的數據結構，運用一個足夠好的Hash函數將一個URL映射到二進制位數組（位圖數組）中的某一位。如果該位已經被置為1，那麽表示該URL已經存在。

Hash存在一個沖突（碰撞）的問題，用同一個Hash得到的兩個URL的值有可能相同。為了減少沖突，我們可以多引入幾個Hash，如果通過其中的一個Hash值我們得出某元素不在集合中，那麽該元素肯定不在集合中。只有在所有的Hash函數告訴我們該元素在集合中時，才能確定該元素存在於集合中。這便是Bloom-Filter的基本思想。

原理要點：一是位數組， 而是k個獨立hash函數。

1）位數組：

假設Bloom Filter使用一個m比特的數組來保存信息，初始狀態時，Bloom Filter是一個包含m位的位數組，每一位都置為0，即BF整個數組的元素都設置為0。

技術分享

2）添加元素，k個獨立hash函數

為了表達S={x1, x2,…,xn}這樣一個n個元素的集合，Bloom Filter使用k個相互獨立的哈希函數（Hash Function），它們分別將集合中的每個元素映射到{1,…,m}的範圍中。

當我們往Bloom Filter中增加任意一個元素x時候，我們使用k個哈希函數得到k個哈希值，然後將數組中對應的比特位設置為1。即第i個哈希函數映射的位置hashi(x)就會被置為1（1≤i≤k）。

註意，如果一個位置多次被置為1，那麽只有第一次會起作用，後面幾次將沒有任何效果。在下圖中，k=3，且有兩個哈希函數選中同一個位置（從左邊數第五位，即第二個“1“處）。

技術分享

3）判斷元素是否存在集合

在判斷y是否屬於這個集合時，我們只需要對y使用k個哈希函數得到k個哈希值，如果所有hashi(y)的位置都是1（1≤i≤k），即k個位置都被設置為1了，那麽我們就認為y是集合中的元素，否則就認為y不是集合中的元素。下圖中y1就不是集合中的元素（因為y1有一處指向了“0”位）。y2或者屬於這個集合，或者剛好是一個false positive。

技術分享

顯然這 個判斷並不保證查找的結果是100%正確的。

Bloom Filter的缺點：

1）Bloom Filter無法從Bloom Filter集合中刪除一個元素。因為該元素對應的位會牽動到其他的元素。所以一個簡單的改進就是 counting Bloom filter，用一個counter數組代替位數組，就可以支持刪除了。 此外，Bloom Filter的hash函數選擇會影響算法的效果。

2）還有一個比較重要的問題，如何根據輸入元素個數n，確定位數組m的大小及hash函數個數，即hash函數選擇會影響算法的效果。當hash函數個數k=(ln2)*(m/n)時錯誤率最小。在錯誤率不大於E的情況 下，m至少要等於n*lg(1/E) 才能表示任意n個元素的集合。但m還應該更大些，因為還要保證bit數組裏至少一半為0，則m應 該>=nlg(1/E)*lge ，大概就是nlg(1/E)1.44倍(lg表示以2為底的對數)。

舉個例子我們假設錯誤率為0.01，則此時m應大概是n的13倍。這樣k大概是8個。

註意：

這裏m與n的單位不同，m是bit為單位，而n則是以元素個數為單位(準確的說是不同元素的個數)。通常單個元素的長度都是有很多bit的。所以使用bloom filter內存上通常都是節省的。

一般BF可以與一些key-value的數據庫一起使用，來加快查詢。由於BF所用的空間非常小，所有BF可以常駐內存。這樣子的話，對於大部分不存在的元素，我們只需要訪問內存中的BF就可以判斷出來了，只有一小部分，我們需要訪問在硬盤上的key-value數據庫。從而大大地提高了效率。

一個Bloom Filter有以下參數：

m bit數組的寬度（bit數）
n 加入其中的key的數量
k 使用的hash函數的個數
f False Positive的比率

Bloom Filter的f滿足下列公式：

技術分享

在給定m和n時，能夠使f最小化的k值為：

技術分享

此時給出的f為：

技術分享

根據以上公式，對於任意給定的f，我們有：

n = m ln(0.6185) / ln(f) [1] 同時，我們需要k個hash來達成這個目標： k = - ln(f) / ln(2) [2] 由於k必須取整數，我們在Bloom Filter的程序實現中，還應該使用上面的公式來求得實際的f： f = (1 – e-kn/m)k [3] 以上3個公式是程序實現Bloom Filter的關鍵公式。

3、 擴展 CounterBloom Filter

CounterBloom Filter

BloomFilter有個缺點，就是不支持刪除操作，因為它不知道某一個位從屬於哪些向量。那我們可以給Bloom Filter加上計數器，添加時增加計數器，刪除時減少計數器。

但這樣的Filter需要考慮附加的計數器大小，假如同個元素多次插入的話，計數器位數較少的情況下，就會出現溢出問題。如果對計數器設置上限值的話，會導致Cache Miss，但對某些應用來說，這並不是什麽問題，如Web Sharing。

Compressed Bloom Filter

為了能在服務器之間更快地通過網絡傳輸Bloom Filter，我們有方法能在已完成Bloom Filter之後，得到一些實際參數的情況下進行壓縮。

將元素全部添加入Bloom Filter後，我們能得到真實的空間使用率，用這個值代入公式計算出一個比m小的值，重新構造Bloom Filter，對原先的哈希值進行求余處理，在誤判率不變的情況下，使得其內存大小更合適。

4、 Bloom-Filter的應用

Bloom-Filter一般用於在大數據量的集合中判定某元素是否存在。例如郵件服務器中的垃圾郵件過濾器。在搜索引擎領域，Bloom-Filter最常用於網絡蜘蛛(Spider)的URL過濾，網絡蜘蛛通常有一個URL列表，保存著將要下載和已經下載的網頁的URL，網絡蜘蛛下載了一個網頁，從網頁中提取到新的URL後，需要判斷該URL是否已經存在於列表中。此時，Bloom-Filter算法是最好的選擇。

1.key-value 加快查詢

一般Bloom-Filter可以與一些key-value的數據庫一起使用，來加快查詢。

一般key-value存儲系統的values存在硬盤，查詢就是件費時的事。將Storage的數據都插入Filter，在Filter中查詢都不存在時，那就不需要去Storage查詢了。當False Position出現時，只是會導致一次多余的Storage查詢。

由於Bloom-Filter所用的空間非常小，所有BF可以常駐內存。這樣子的話，對於大部分不存在的元素，我們只需要訪問內存中的Bloom-Filter就可以判斷出來了，只有一小部分，我們需要訪問在硬盤上的key-value數據庫。從而大大地提高了效率。如圖：

技術分享

2 .Google的BigTable

Google的BigTable也使用了Bloom Filter，以減少不存在的行或列在磁盤上的查詢，大大提高了數據庫的查詢操作的性能。

3. Proxy-Cache

在Internet Cache Protocol中的Proxy-Cache很多都是使用Bloom Filter存儲URLs，除了高效的查詢外，還能很方便得傳輸交換Cache信息。

4.網絡應用

1）P2P網絡中查找資源操作，可以對每條網絡通路保存Bloom Filter，當命中時，則選擇該通路訪問。

2）廣播消息時，可以檢測某個IP是否已發包。

3）檢測廣播消息包的環路，將Bloom Filter保存在包裏，每個節點將自己添加入Bloom Filter。

4）信息隊列管理，使用Counter Bloom Filter管理信息流量。

5. 垃圾郵件地址過濾

像網易，QQ這樣的公眾電子郵件（email）提供商，總是需要過濾來自發送垃圾郵件的人（spamer）的垃圾郵件。

一個辦法就是記錄下那些發垃圾郵件的 email地址。由於那些發送者不停地在註冊新的地址，全世界少說也有幾十億個發垃圾郵件的地址，將他們都存起來則需要大量的網絡服務器。

如果用哈希表，每存儲一億個 email地址，就需要 1.6GB的內存（用哈希表實現的具體辦法是將每一個 email地址對應成一個八字節的信息指紋，然後將這些信息指紋存入哈希表，由於哈希表的存儲效率一般只有 50%，因此一個email地址需要占用十六個字節。一億個地址大約要 1.6GB，即十六億字節的內存）。因此存貯幾十億個郵件地址可能需要上百 GB的內存。

而Bloom Filter只需要哈希表 1/8到 1/4 的大小就能解決同樣的問題。

BloomFilter決不會漏掉任何一個在黑名單中的可疑地址。而至於誤判問題，常見的補救辦法是在建立一個小的白名單，存儲那些可能別誤判的郵件地址。

5、 Bloom-Filter的具體實現

c語言實現：

stdafx.h：

　　[cpp] view plain copy 　　print?
  1. #pragma once
  2. #include <stdio.h>
  3. #include "stdlib.h"
  4. #include <iostream>
  5. #include <time.h>
  6. using namespace std;
　　[cpp] view plain copy 　　print?
  1. #include "stdafx.h"
  4. #define ARRAY_SIZE 256 /*we get the 256 chars of each line*/
  5. #define SIZE 48000000 /* size should be 1/8 of max*/
  6. #define MAX 384000000/*the max bit space*/
  8. #define SETBIT(ch,n) ch[n/8]|=1<<(7-n%8)
  9. #define GETBIT(ch,n) (ch[n/8]&1<<(7-n%8))>>(7-n%8)
  11. unsigned int len(char *ch);/* functions to calculate the length of the url*/
  13. unsigned int RSHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  14. unsigned int JSHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  15. unsigned int PJWHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  16. unsigned int ELFHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  17. unsigned int BKDRHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  18. unsigned int SDBMHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  19. unsigned int DJBHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  20. unsigned int DEKHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  21. unsigned int BPHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  22. unsigned int FNVHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  23. unsigned int APHash(char* str, unsigned int len);/* functions to calculate the hash value of the url*/
  24. unsigned int HFLPHash(char* str,unsigned int len);/* functions to calculate the hash value of the url*/
  25. unsigned int HFHash(char* str,unsigned int len);/* functions to calculate the hash value of the url*/
  26. unsigned int StrHash( char* str,unsigned int len);/* functions to calculate the hash value of the url*/
  27. unsigned int TianlHash(char* str,unsigned int len);/* functions to calculate the hash value of the url*/
  30. int main()
  31. {
  32. int i,num,num2=0; /* the number to record the repeated urls and the total of it*/
  33. unsigned int tt=0;
  34. int flag; /*it helps to check weather the url has already existed */
  35. char buf[257]; /*it helps to print the start time of the program */
  36. time_t tmp = time(NULL);
  38. char file1[100],file2[100];
  39. FILE *fp1,*fp2;/*pointer to the file */
  40. char ch[ARRAY_SIZE];
  41. char *vector ;/* the bit space*/
  42. vector = (char *)calloc(SIZE,sizeof(char));
  44. printf("Please enter the file with repeated urls:\n");
  45. scanf("%s",&file1);
  46. if( (fp1 = fopen(file1,"rb")) == NULL) { /* open the goal file*/
  47. printf("Connot open the file %s!\n",file1);
  48. }
  50. printf("Please enter the file you want to save to:\n");
  51. scanf("%s",&file2);
  52. if( (fp2 = fopen(file2,"w")) == NULL) {
  53. printf("Connot open the file %s\n",file2);
  54. }
  55. strftime(buf,32,"%Y-%m-%d %H:%M:%S",localtime(&tmp));
  56. printf("%s\n",buf); /*print the system time*/
  58. for(i=0;i<SIZE;i++) {
  59. vector[i]=0; /*set 0*/
  60. }
  62. while(!feof(fp1)) { /* the check process*/
  64. fgets(ch,ARRAY_SIZE,fp1);
  65. flag=0;
  66. tt++;
  67. if( GETBIT(vector, HFLPHash(ch,len(ch))%MAX) ) {
  68. flag++;
  69. } else {
  70. SETBIT(vector,HFLPHash(ch,len(ch))%MAX );
  71. }
  73. if( GETBIT(vector, StrHash(ch,len(ch))%MAX) ) {
  74. flag++;
  75. } else {
  76. SETBIT(vector,StrHash(ch,len(ch))%MAX );
  77. }
  79. if( GETBIT(vector, HFHash(ch,len(ch))%MAX) ) {
  80. flag++;
  81. } else {
  82. SETBIT(vector,HFHash(ch,len(ch))%MAX );
  83. }
  85. if( GETBIT(vector, DEKHash(ch,len(ch))%MAX) ) {
  86. flag++;
  87. } else {
  88. SETBIT(vector,DEKHash(ch,len(ch))%MAX );
  89. }
  91. if( GETBIT(vector, TianlHash(ch,len(ch))%MAX) ) {
  92. flag++;
  93. } else {
  94. SETBIT(vector,TianlHash(ch,len(ch))%MAX );
  95. }
  97. if( GETBIT(vector, SDBMHash(ch,len(ch))%MAX) ) {
  98. flag++;
  99. } else {
  100. SETBIT(vector,SDBMHash(ch,len(ch))%MAX );
  101. }
  103. if(flag<6)
  104. num2++;
  105. else
  106. fputs(ch,fp2);
  108. /* printf(" %d",flag); */
  109. }
  110. /* the result*/
  111. printf("\nThere are %d urls!\n",tt);
  112. printf("\nThere are %d not repeated urls!\n",num2);
  113. printf("There are %d repeated urls!\n",tt-num2);
  114. fclose(fp1);
  115. fclose(fp2);
  116. return 0;
  117. }
  120. /*functions may be used in the main */
  121. unsigned int len(char *ch)
  122. {
  123. int m=0;
  124. while(ch[m]!=‘\0‘) {
  125. m++;
  126. }
  127. return m;
  128. }
  130. unsigned int RSHash(char* str, unsigned int len) {
  131. unsigned int b = 378551;
  132. unsigned int a = 63689;
  133. unsigned int hash = 0;
  134. unsigned int i = 0;
  136. for(i=0; i<len; str++, i++) {
  137. hash = hash*a + (*str);
  138. a = a*b;
  139. }
  140. return hash;
  141. }
  142. /* End Of RS Hash Function */
  145. unsigned int JSHash(char* str, unsigned int len)
  146. {
  147. unsigned int hash = 1315423911;
  148. unsigned int i = 0;
  150. for(i=0; i<len; str++, i++) {
  151. hash ^= ((hash<<5) + (*str) + (hash>>2));
  152. }
  153. return hash;
  154. }
  155. /* End Of JS Hash Function */
  158. unsigned int PJWHash(char* str, unsigned int len)
  159. {
  160. const unsigned int BitsInUnsignedInt = (unsigned int)(sizeof(unsigned int) * 8);
  161. const unsigned int ThreeQuarters = (unsigned int)((BitsInUnsignedInt * 3) / 4);
  162. const unsigned int OneEighth = (unsigned int)(BitsInUnsignedInt / 8);
  163. const unsigned int HighBits = (unsigned int)(0xFFFFFFFF) << (BitsInUnsignedInt - OneEighth);
  164. unsigned int hash = 0;
  165. unsigned int test = 0;
  166. unsigned int i = 0;
  168. for(i=0;i<len; str++, i++) {
  169. hash = (hash<<OneEighth) + (*str);
  170. if((test = hash & HighBits) != 0) {
  171. hash = ((hash ^(test >> ThreeQuarters)) & (~HighBits));
  172. }
  173. }
  175. return hash;
  176. }
  177. /* End Of P. J. Weinberger Hash Function */
  180. unsigned int ELFHash(char* str, unsigned int len)
  181. {
  182. unsigned int hash = 0;
  183. unsigned int x = 0;
  184. unsigned int i = 0;
  186. for(i = 0; i < len; str++, i++) {
  187. hash = (hash << 4) + (*str);
  188. if((x = hash & 0xF0000000L) != 0) {
  189. hash ^= (x >> 24);
  190. }
  191. hash &= ~x;
  192. }
  193. return hash;
  194. }
  195. /* End Of ELF Hash Function */
  198. unsigned int BKDRHash(char* str, unsigned int len)
  199. {
  200. unsigned int seed = 131; /* 31 131 1313 13131 131313 etc.. */
  201. unsigned int hash = 0;
  202. unsigned int i = 0;
  204. for(i = 0; i < len; str++, i++)
  205. {
  206. hash = (hash * seed) + (*str);
  207. }
  209. return hash;
  210. }
  211. /* End Of BKDR Hash Function */
  214. unsigned int SDBMHash(char* str, unsigned int len)
  215. {
  216. unsigned int hash = 0;
  217. unsigned int i = 0;
  219. for(i = 0; i < len; str++, i++) {
  220. hash = (*str) + (hash << 6) + (hash << 16) - hash;
  221. }
  223. return hash;
  224. }
  225. /* End Of SDBM Hash Function */
  228. unsigned int DJBHash(char* str, unsigned int len)
  229. {
  230. unsigned int hash = 5381;
  231. unsigned int i = 0;
  233. for(i = 0; i < len; str++, i++) {
  234. hash = ((hash << 5) + hash) + (*str);
  235. }
  237. return hash;
  238. }
  239. /* End Of DJB Hash Function */
  242. unsigned int DEKHash(char* str, unsigned int len)
  243. {
  244. unsigned int hash = len;
  245. unsigned int i = 0;
  247. for(i = 0; i < len; str++, i++) {
  248. hash = ((hash << 5) ^ (hash >> 27)) ^ (*str);
  249. }
  250. return hash;
  251. }
  252. /* End Of DEK Hash Function */
  255. unsigned int BPHash(char* str, unsigned int len)
  256. {
  257. unsigned int hash = 0;
  258. unsigned int i = 0;
  259. for(i = 0; i < len; str++, i++) {
  260. hash = hash << 7 ^ (*str);
  261. }
  263. return hash;
  264. }
  265. /* End Of BP Hash Function */
  268. unsigned int FNVHash(char* str, unsigned int len)
  269. {
  270. const unsigned int fnv_prime = 0x811C9DC5;
  271. unsigned int hash = 0;
  272. unsigned int i = 0;
  274. for(i = 0; i < len; str++, i++) {
  275. hash *= fnv_prime;
  276. hash ^= (*str);
  277. }
  279. return hash;
  280. }
  281. /* End Of FNV Hash Function */
  284. unsigned int APHash(char* str, unsigned int len)
  285. {
  286. unsigned int hash = 0xAAAAAAAA;
  287. unsigned int i = 0;
  289. for(i = 0; i < len; str++, i++) {
  290. hash ^= ((i & 1) == 0) ? ( (hash << 7) ^ (*str) * (hash >> 3)) :
  291. (~((hash << 11) + (*str) ^ (hash >> 5)));
  292. }
  294. return hash;
  295. }
  296. /* End Of AP Hash Function */
  297. unsigned int HFLPHash(char *str,unsigned int len)
  298. {
  299. unsigned int n=0;
  300. int i;
  301. char* b=(char *)&n;
  302. for(i=0;i<strlen(str);++i) {
  303. b[i%4]^=str[i];
  304. }
  305. return n%len;
  306. }
  307. /* End Of HFLP Hash Function*/
  308. unsigned int HFHash(char* str,unsigned int len)
  309. {
  310. int result=0;
  311. char* ptr=str;
  312. int c;
  313. int i=0;
  314. for (i=1;c=*ptr++;i++)
  315. result += c*3*i;
  316. if (result<0)
  317. result = -result;
  318. return result%len;
  319. }
  320. /*End Of HKHash Function */
  322. unsigned int StrHash( char *str,unsigned int len)
  323. {
  324. register unsigned int h;
  325. register unsigned char *p;
  326. for(h=0,p=(unsigned char *)str;*p;p++) {
  327. h=31*h+*p;
  328. }
  330. return h;
  332. }
  333. /*End Of StrHash Function*/
  335. unsigned int TianlHash(char *str,unsigned int len)
  336. {
  337. unsigned long urlHashValue=0;
  338. int ilength=strlen(str);
  339. int i;
  340. unsigned char ucChar;
  341. if(!ilength) {
  342. return 0;
  343. }
  344. if(ilength<=256) {
  345. urlHashValue=16777216*(ilength-1);
  346. } else {
  347. urlHashValue = 42781900080;
  348. }
  349. if(ilength<=96) {
  350. for(i=1;i<=ilength;i++) {
  351. ucChar=str[i-1];
  352. if(ucChar<=‘Z‘&&ucChar>=‘A‘) {
  353. ucChar=ucChar+32;
  354. }
  355. urlHashValue+=(3*i*ucChar*ucChar+5*i*ucChar+7*i+11*ucChar)%1677216;
  356. }
  357. } else {
  358. for(i=1;i<=96;i++)
  359. {
  360. ucChar=str[i+ilength-96-1];
  361. if(ucChar<=‘Z‘&&ucChar>=‘A‘)
  362. {
  363. ucChar=ucChar+32;
  364. }
  365. urlHashValue+=(3*i*ucChar*ucChar+5*i*ucChar+7*i+11*ucChar)%1677216;
  366. }
  367. }
  368. return urlHashValue;
  370. }
  371. /*End Of Tianl Hash Function*/

網上找到的php簡單實現：

　　[cpp] view plain copy 　　 print?
  1. <?php
  3. /**
  4. * Implements a Bloom Filter
  5. */
  6. class BloomFilter {
  7. /**
  8. * Size of the bit array
  9. *
  10. * @var int
  11. */
  12. protected $m;
  14. /**
  15. * Number of hash functions
  16. *
  17. * @var int
  18. */
  19. protected $k;
  21. /**
  22. * Number of elements in the filter
  23. *
  24. * @var int
  25. */
  26. protected $n;
  28. /**
  29. * The bitset holding the filter information
  30. *
  31. * @var array
  32. */
  33. protected $bitset;
  35. /**
  36. * 計算最優的hash函數個數：當hash函數個數k=(ln2)*(m/n)時錯誤率最小
  37. *
  38. * @param int $m bit數組的寬度（bit數）
  39. * @param int $n 加入布隆過濾器的key的數量
  40. * @return int
  41. */
  42. public static function getHashCount($m, $n) {
  43. return ceil(($m / $n) * log(2));
  44. }
  46. /**
  47. * Construct an instance of the Bloom filter
  48. *
  49. * @param int $m bit數組的寬度（bit數） Size of the bit array
  50. * @param int $k hash函數的個數 Number of different hash functions to use
  51. */
  52. public function __construct($m, $k) {
  53. $this->m = $m;
  54. $this->k = $k;
  55. $this->n = 0;
  57. /* Initialize the bit set */
  58. $this->bitset = array_fill(0, $this->m - 1, false);
  59. }
  61. /**
  62. * False Positive的比率：f = (1 – e-kn/m)k
  63. * Returns the probability for a false positive to occur, given the current number of items in the filter
  64. *
  65. * @return double
  66. */
  67. public function getFalsePositiveProbability() {
  68. $exp = (-1 * $this->k * $this->n) / $this->m;
  70. return pow(1 - exp($exp), $this->k);
  71. }
  73. /**
  74. * Adds a new item to the filter
  75. *
  76. * @param mixed Either a string holding a single item or an array of
  77. * string holding multiple items. In the latter case, all
  78. * items are added one by one internally.
  79. */
  80. public function add($key) {
  81. if (is_array($key)) {
  82. foreach ($key as $k) {
  83. $this->add($k);
  84. }
  85. return;
  86. }
  88. $this->n++;
  90. foreach ($this->getSlots($key) as $slot) {
  91. $this->bitset[$slot] = true;
  92. }
  93. }
  95. /**
  96. * Queries the Bloom filter for an element
  97. *
  98. * If this method return FALSE, it is 100% certain that the element has
  99. * not been added to the filter before. In contrast, if TRUE is returned,
  100. * the element *may* have been added to the filter previously. However with
  101. * a probability indicated by getFalsePositiveProbability() the element has
  102. * not been added to the filter with contains() still returning TRUE.
  103. *
  104. * @param mixed Either a string holding a single item or an array of
  105. * strings holding multiple items. In the latter case the
  106. * method returns TRUE if the filter contains all items.
  107. * @return boolean
  108. */
  109. public function contains($key) {
  110. if (is_array($key)) {
  111. foreach ($key as $k) {
  112. if ($this->contains($k) == false) {
  113. return false;
  114. }
  115. }
  117. return true;
  118. }
  120. foreach ($this->getSlots($key) as $slot) {
  121. if ($this->bitset[$slot] == false) {
  122. return false;
  123. }
  124. }
  126. return true;
  127. }
  129. /**
  130. * Hashes the argument to a number of positions in the bit set and returns the positions
  131. *
  132. * @param string Item
  133. * @return array Positions
  134. */
  135. protected function getSlots($key) {
  136. $slots = array();
  137. $hash = self::getHashCode($key);
  138. mt_srand($hash);
  140. for ($i = 0; $i < $this->k; $i++) {
  141. $slots[] = mt_rand(0, $this->m - 1);
  142. }
  144. return $slots;
  145. }
  147. /**
  148. * 使用CRC32產生一個32bit（位）的校驗值。
  149. * 由於CRC32產生校驗值時源數據塊的每一bit（位）都會被計算，所以數據塊中即使只有一位發生了變化，也會得到不同的CRC32值。
  150. * Generates a numeric hash for the given string
  151. *
  152. * Right now the CRC-32 algorithm is used. Alternatively one could e.g.
  153. * use Adler digests or mimick the behaviour of Java‘s hashCode() method.
  154. *
  155. * @param string Input for which the hash should be created
  156. * @return int Numeric hash
  157. */
  158. protected static function getHashCode($string) {
  159. return crc32($string);
  160. }
  162. }
  166. $items = array("first item", "second item", "third item");
  168. /* Add all items with one call to add() and make sure contains() finds
  169. * them all.
  170. */
  171. $filter = new BloomFilter(100, BloomFilter::getHashCount(100, 3));
  172. $filter->add($items);
  174. //var_dump($filter); exit;
  175. $items = array("firsttem", "seconditem", "thirditem");
  176. foreach ($items as $item) {
  177. var_dump(($filter->contains($item)));
  178. }
  181. /* Add all items with multiple calls to add() and make sure contains()
  182. * finds them all.
  183. */
  184. $filter = new BloomFilter(100, BloomFilter::getHashCount(100, 3));
  185. foreach ($items as $item) {
  186. $filter->add($item);
  187. }
  188. $items = array("fir sttem", "secondit em", "thir ditem");
  189. foreach ($items as $item) {
  190. var_dump(($filter->contains($item)));
  191. }


問題實例】 給你A,B兩個文件，各存放50億條URL，每條URL占用64字節，內存限制是4G，讓你找出A,B文件共同的URL。如果是三個乃至n個文件呢？

根據這個問題我們來計算下內存的占用，4G=2^32大概是40億*8大概是340億bit，n=50億，如果按出錯率0.01算需要的大概是650億個bit。 現在可用的是340億，相差並不多，這樣可能會使出錯率上升些。另外如果這些urlip是一一對應的，就可以轉換成ip，則大大簡單了。

海量數據處理算法—Bloom Filter

相關推薦

海量數據處理算法—Bloom Filter

內存地址空間 核心 全世界 在服務器 i++ func ras get 地址空間 1. Bloom-Filter算法簡介 Bloom-Filter，即布隆過濾器，1970年由Bloom中提出。它可以用於檢索一個元素是否在一個集合中。 Bloom

海量數據處理算法與面試題

大數 font span view big ons 海量數據 log 12px http://www.jiuzhang.com/tutorial/big-data-interview-questions/163 1.最高頻 K 項問題 2.布隆過濾器 3.外排序算法 4

海量數據處理算法（top K問題）

一行 歸並排序 註意 top 返回 詞語 top k 其中 hash 舉例 有一個1G大小的一個文件，裏面每一行是一個詞，詞的大小不超過16字節，內存限制大小是1M。返回頻數最高的100個詞。 思路 首先把文件分開 針對每個文件hash遍歷，統計每個詞語的頻率 使用堆進行

海量數據處理：Hash映射 + Hash_map統計 + 堆/快速/歸並排序

針對 內存 value 快速 round div ack 數據處理 訪問 海量日誌數據，提取出某日訪問百度次數最多的那個IP。 既然是海量數據處理，那麽可想而知，給我們的數據那就一定是海量的。 針對這個數據的海量，我們如何著手呢?對的，無非就是分而治之/hash映射 +

數據結構——算法之（031）（將字符串中全部小寫字母排在大寫字母的前面）

函數 返回 mod ont content 內容 print har -h 【申明：本文僅限於自我歸納總結和相互交流，有紕漏還望各位指出。 聯系郵箱：[email protected]/* */ 題目： 函數將字符串中的字符‘*‘移到串的前部分。前面的

數據挖掘 - 算法 - ID3 - 轉自 http://www.cnblogs.com/dztgc/archive/2013/04/22/3036529.html

str htm bar c++代碼 度量 進行 初始化 ++ 預測 1 簡介 　　決策樹學習是一種逼近離散值目標函數的方法，在這種學習到的函數被表示為一棵決策樹。 2 決策樹表示 　 決策樹通過把實例從根節點排列到某個葉子結點來分類實例，葉子結點即為實例所屬的分類。樹上的

基本數據結構(算法導論)與python

多重 down begin 既然 string app lis 類型 elif 原文鏈接 Stack, Queue Stack是後進先出, LIFO, 隊列為先進先出, FIFO在Python中兩者, 都可以簡單的用list實現,進, 用append()出, Stack

工具類：關於如何找到兩個List數組中不同的數據的算法！

開發人員 uri print clas 數據結構 blank _id integer public 找到兩個List數組中不同的數據的算法！ import java.util.ArrayList;import java.util.HashMap;import java.ut

系統學習數據結構算法

dcs das tps wot names ava logs enter href 決定在 上開始補習基礎， 先加入： https://www.coursera.org/learn/algorithms-part1 其中 Welcome 給出了 BooKSite

day40 數據結構-算法（二）

圍墻 dea maxsize 由於 image closed images 哈希函數 鏈表 什麽是數據結構？ 簡單來說，數據結構就是設計數據以何種方式組織並存儲在計算機中。 比如：列表、集合與字典等都是一種數據結構。 N.Wirth: “程序=數據結構+算法” 列表

數據挖掘算法：關聯分析一（基本概念）

latin ron 來看 關聯 row 集中 items 多個 可能性 一.基本概念 　　我們來看上面的事務庫，如同上表所示的二維數據集就是一個購物籃事務庫。該事物庫記錄的是顧客購買商品的行為。這裏的TID表示一次購買行為的編號，items表示顧客購買了哪些商品。 　　事

編程語言：數據＋算法；

結構 clas 函數式編程 gpo 內存管理 編程 基本 架構 管理 數據、類型：基本數據類型、復合數據類型、面向對象數據類型； 算法：控制結構、函數；數據的存取和處理； 數據與算法之上是範式：面向對象、函數式編程； 語言之上是功能（系統使用）： 基本的系統使用：內

關於海量數據處理分析的經驗總結

建立 我們 網絡日誌 性能 結構 領域 要花 腳本 實施 對海量的數據進行處理是一項艱巨而復雜的任務。原因有以下幾個方面： 一、數據量過大，數據中什麽情況都可能存在。如果說有10條數據，那麽大不了每條去逐一檢查，人為處理，如果有上百條數據，也可以考

服務器Raid數據恢復成功案例和raid 5數據恢復算法原理

服務器數據恢復 raid數據恢復 磁盤陣列數據恢復 北亞數據恢復中心 服務器Raid 5數據恢復案例本次分享的案例是一臺服務器中的raid磁盤陣列，磁盤陣列中有12塊磁盤，單盤容量500G，ext3文件系統，系統平臺為Linux平臺。Raid中2號盤和6號盤兩塊硬盤報黃燈，管理人員檢查後對6號

[算法與數據結構]算法學習計劃

jpg 簡單 循環 概念 clas ont 結構 bubuko 知識 為什麽要開始學習算法 工作剛開始幾年越來越意識到了算法和數據結構的重要性，好的結構和算法可以讓我們的程序性能更好。設計不好的算法，會讓程序的性能變得很差，尤其是在面對大量數據的時候，非常明顯。所以重新拾

海量數據處理常用方法有哪些？

大數據開發 大數據 Hadoop 海量數據 處理海量數據是大數據工程師必備技能，通過對PB級別的數據進行挖掘與分析發掘出有價值的信息，為企業或政府做出正確決策提供依據，是十分必要的一項工作，以下是常用的海量數據處理方法！1. Bloom filter Bloom filter是一種二進制

十道海量數據處理面試題與十個方法大總結

面試題 線性 set TE 連續子序列 文本文 過程 現在 動態規劃 1. 給定a、b兩個文件，各存放50億個url，每個url各占64字節，內存限制是4G，讓你找出a、b文件共同的url？ 方案1：可以估計每個文件安的大小為50G×64=320G，遠遠大於內存限制的4G。

數據結構算法之求中位數

app num pen 數組元素 組元 整形轉換 end 整形 div 給定兩個有序數組，求其中位數的算法 中位數定義：如果元素個數為奇數，則中位數為數組中間的那個數;如果數組元素個數為偶數，則中位數為中間兩個數的平均數 求解方法一（歸並求解）： def findmids

數據壓縮算法---LZ77算法 的分析與實現

發現 如何 存儲 sse 而已 以及 turn 集合 alt LZ77簡介 Ziv和Lempel於1977年發表題為“順序數據壓縮的一個通用算法（A Universal Algorithm for Sequential Data Compression ）”的論文，論文中描

JAVA數據結構算法

數據 tro tid images mod .com 51cto term sha 下載地址：百度網盤JAVA數據結構算法