hash算法及應用

第一部分：Top K 算法詳解

Hash，一般翻譯做“散列”，也有直接音譯爲"哈希"的，就是把任意長度的輸入（又叫做 

預映射， pre-image），通過散列算法，變換成固定長度的輸出，該輸出就是散列值。這 
種轉換是一種壓縮映射，也就是，散列值的空間通常遠小於輸入的空間，不同的輸入可能 
會散列成相同的輸出，而不可能從散列值來唯一的確定輸入值。 

數學表述爲：h = H(M) ，其中H( )--單向散列函數，M--任意長度明文，h--固定長度散列 
值。 

在信息安全領域中應用的Hash算法，還需要滿足其他關鍵特性： 

第一當然是單向性(one-way)，從預映射，能夠簡單迅速的得到散列值，而在計算上不可能 
構造一個預映射，使其散列結果等於某個特定的散列值，即構造相應的M=H-1(h)不可行。 
這樣，散列值就能在統計上唯一的表徵輸入值，因此，密碼學上的 Hash 又被稱爲"消息摘 
要(message digest)"，就是要求能方便的將"消息"進行"摘要"，但在"摘要"中無法得到比 
"摘要"本身更多的關於"消息"的信息。 

第二是抗衝突性(collision-resistant)，即在統計上無法產生2個散列值相同的預映射。 
給定M，計算上無法找到M'，滿足H(M)=H(M') ，此謂弱抗衝突性；計算上也難以尋找一對 
任意的M和M'，使滿足H(M)=H(M') ，此謂強抗衝突性。要求"強抗衝突性"主要是爲了防範 
所謂"生日攻擊(birthday attack)"，在一個10人的團體中，你能找到和你生日相同的人的 
概率是2.4%，而在同一團體中，有2人生日相同的概率是11.7%。類似的，當預映射的空間 
很大的情況下，算法必須有足夠的強度來保證不能輕易找到"相同生日"的人。 

第三是映射分佈均勻性和差分分佈均勻性，散列結果中，爲 0 的 bit 和爲 1 的 bit ， 
其總數應該大致相等；輸入中一個 bit 的變化，散列結果中將有一半以上的 bit 改變， 
這又叫做"雪崩效應(avalanche effect)"；要實現使散列結果中出現 1bit 的變化，則輸 
入中至少有一半以上的 bit 必鬚髮生變化。其實質是必須使輸入中每一個 bit 的信息， 
儘量均勻的反映到輸出的每一個 bit 上去；輸出中的每一個 bit，都是輸入中儘可能多 
bit 的信息一起作用的結果。 


Damgard 和 Merkle 定義了所謂“壓縮函數(compression function)”，就是將一個固定 
長度輸入，變換成較短的固定長度的輸出，這對密碼學實踐上 Hash 函數的設計產生了很 
大的影響。Hash函數就是被設計爲基於通過特定壓縮函數的不斷重複“壓縮”輸入的分組 
和前一次壓縮處理的結果的過程，直到整個消息都被壓縮完畢，最後的輸出作爲整個消息 
的散列值。儘管還缺乏嚴格的證明，但絕大多數業界的研究者都同意，如果壓縮函數是安 
全的，那麼以上述形式散列任意長度的消息也將是安全的。這就是所謂 Damgard/Merkle 
結構： 

在下圖中，任意長度的消息被分拆成符合壓縮函數輸入要求的分組，最後一個分組可能需 
要在末尾添上特定的填充字節，這些分組將被順序處理，除了第一個消息分組將與散列初 
始化值一起作爲壓縮函數的輸入外，當前分組將和前一個分組的壓縮函數輸出一起被作爲 
這一次壓縮的輸入，而其輸出又將被作爲下一個分組壓縮函數輸入的一部分，直到最後一 
個壓縮函數的輸出，將被作爲整個消息散列的結果。 


MD5 和 SHA1 可以說是目前應用最廣泛的Hash算法，而它們都是以 MD4 爲基礎設計的。 


1) MD4 
MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年設計的，MD 是 Message Digest 
的縮寫。它適用在32位字長的處理器上用高速軟件實現--它是基於 32 位操作數的位操作 
來實現的。它的安全性不像RSA那樣基於數學假設，儘管 Den Boer、Bosselaers 和 Dobb 
ertin 很快就用分析和差分成功的攻擊了它3輪變換中的 2 輪，證明了它並不像期望的那 
樣安全，但它的整個算法並沒有真正被破解過，Rivest 也很快進行了改進。 

下面是一些MD4散列結果的例子： 

MD4 ("") = 31d6cfe0d16ae931b73c59d7e0c089c0 
MD4 ("a") = bde52cb31de33e46245e05fbdbd6fb24 
MD4 ("abc") = a448017aaf21d8525fc10ae87aa6729d 
MD4 ("message digest") = d9130a8164549fe818874806e1c7014b 
MD4 ("abcdefghijklmnopqrstuvwxyz") = d79e1c308aa5bbcdeea8ed63df412da9 
MD4 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = 043f8
582f241db351ce627e153e7f0e4 
MD4 ("123456789012345678901234567890123456789012345678901234567890123456789012 
34567890") = e33b4ddc9c38f2199c3e7b164fcc0536 


2) MD5 
MD5(RFC 1321)是 Rivest 於1991年對MD4的改進版本。它對輸入仍以512位分組，其輸出是 
4個32位字的級聯，與 MD4 相同。它較MD4所做的改進是： 

1) 加入了第四輪 
2) 每一步都有唯一的加法常數； 
3) 第二輪中的G函數從((X ∧ Y) ∨ (X ∧ Z) ∨ (Y ∧ Z)) 變爲 ((X ∧ Z) ∨ (Y ∧ 
～Z))以減小其對稱性； 
4) 每一步都加入了前一步的結果，以加快"雪崩效應"； 
5) 改變了第2輪和第3輪中訪問輸入子分組的順序，減小了形式的相似程度； 
6) 近似優化了每輪的循環左移位移量，以期加快"雪崩效應"，各輪的循環左移都不同。 

儘管MD5比MD4來得複雜，並且速度較之要慢一點，但更安全，在抗分析和抗差分方面表現 
更好。 

消息首先被拆成若干個512位的分組，其中最後512位一個分組是“消息尾+填充字節(100… 
0)+64 位消息長度”，以確保對於不同長度的消息，該分組不相同。64位消息長度的限制 
導致了MD5安全的輸入長度必須小於264bit，因爲大於64位的長度信息將被忽略。而4個32 
位寄存器字初始化爲A=0x01234567，B=0x89abcdef，C=0xfedcba98，D=0x76543210，它們 
將始終參與運算並形成最終的散列結果。 

接着各個512位消息分組以16個32位字的形式進入算法的主循環，512位消息分組的個數據 
決定了循環的次數。主循環有4輪，每輪分別用到了非線性函數 

F(X, Y, Z) = (X ∧ Y) ∨ (～X ∧ Z) 
G(X, Y, Z) = (X ∧ Z) ∨ (Y ∧ ～Z) 
H(X, Y, Z) =X ⊕ Y ⊕ Z 
I(X, Y, Z) = X ⊕ (Y ∨ ～Z) 
這4輪變換是對進入主循環的512位消息分組的16個32位字分別進行如下操作：將A、B、C、 
D的副本a、b、c、d中的3個經F、G、H、I運算後的結果與第4個相加，再加上32位字和一個 
32位字的加法常數，並將所得之值循環左移若干位，最後將所得結果加上a、b、c、d之一 
，並回送至ABCD，由此完成一次循環。 

所用的加法常數由這樣一張表T[i]來定義，其中i爲1…64，T[i]是i的正弦絕對值之42949 
67296次方的整數部分，這樣做是爲了通過正弦函數和冪函數來進一步消除變換中的線性性 
。 

當所有512位分組都運算完畢後，ABCD的級聯將被輸出爲MD5散列的結果。下面是一些MD5散 
列結果的例子： 

MD5 ("") = d41d8cd98f00b204e9800998ecf8427e 
MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661 
MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72 
MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0 
MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b 
MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f 
MD5 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a 

參考相應RFC文檔可以得到MD4、MD5算法的詳細描述和算法的C源代碼。

3) SHA1 及其他 
SHA1是由NIST NSA設計爲同DSA一起使用的，訪問http://www.itl.nist.gov/fipspubs可以得到它的詳細規範--[/url]"FIPS PUB 180-1 SECURE HASH STANDARD"。它對長度小於264的輸入，產生長度爲160bit的散列值，因此抗窮舉(brute-force)性更好。SHA-1 設計時基於和MD4相同原理,並且模仿了該算法。因爲它將產生160bit的散列值，因此它有5個參與運算的32位寄存器字，消息分組和填充方式與MD5相同，主循環也同樣是4輪，但每輪進行20次操作，非線性運算、移位和加法運算也與MD5類似，但非線性函數、加法常數和循環左移操作的設計有一些區別，可以參考上面提到的規範來了解這些細節。下面是一些SHA1散列結果的例子：

SHA1 ("abc") = a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d 
SHA1 ("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e44 1c3bd26e baae4aa1 f95129e5 e54670f1 
其他一些知名的Hash算法還有MD2、N-Hash、RIPE-MD、HAVAL等等。上面提到的這些都屬於"純"Hash算法。還有另2類Hash算法，一類就是基於對稱分組算法的單向散列算法，典型的例子是基於DES的所謂Davies-Meyer算法，另外還有經IDEA改進的Davies-Meyer算法，它們兩者目前都被認爲是安全的算法。另一類是基於模運算/離散對數的，也就是基於公開密鑰算法的，但因爲其運算開銷太大，而缺乏很好的應用前景。

沒有通過分析和差分攻擊考驗的算法，大多都已經夭折在實驗室裏了，因此，如果目前流行的Hash算法能完全符合密碼學意義上的單向性和抗衝突性，就保證了只有窮舉，纔是破壞Hash運算安全特性的唯一方法。爲了對抗弱抗衝突性，我們可能要窮舉個數和散列值空間長度一樣大的輸入，即嘗試2^128或2^160個不同的輸入，目前一臺高檔個人電腦可能需要10^25年才能完成這一艱鉅的工作，即使是最高端的並行系統，這也不是在幾千年裏的幹得完的事。而因爲"生日攻擊"有效的降低了需要窮舉的空間，將其降低爲大約1.2*2^64或1.2*2^80，所以，強抗衝突性是決定Hash算法安全性的關鍵。

在NIST新的 Advanced Encryption Standard (AES)中，使用了長度爲128、192、256bit 的密鑰，因此相應的設計了 SHA256、SHA384、SHA512，它們將提供更好的安全性。

Hash算法在信息安全方面的應用主要體現在以下的3個方面：

1) 文件校驗 
我們比較熟悉的校驗算法有奇偶校驗和CRC校驗，這2種校驗並沒有抗數據篡改的能力，它們一定程度上能檢測並糾正數據傳輸中的信道誤碼，但卻不能防止對數據的惡意破壞。

MD5 Hash算法的"數字指紋"特性，使它成爲目前應用最廣泛的一種文件完整性校驗和(Checksum)算法，不少Unix系統有提供計算md5 checksum的命令。它常被用在下面的2種情況下：

第一是文件傳送後的校驗，將得到的目標文件計算 md5 checksum，與源文件的md5 checksum 比對，由兩者 md5 checksum 的一致性，可以從統計上保證2個文件的每一個碼元也是完全相同的。這可以檢驗文件傳輸過程中是否出現錯誤，更重要的是可以保證文件在傳輸過程中未被惡意篡改。一個很典型的應用是ftp服務，用戶可以用來保證多次斷點續傳，特別是從鏡像站點下載的文件的正確性。

更出色的解決方法是所謂的代碼簽名，文件的提供者在提供文件的同時，提供對文件Hash值用自己的代碼簽名密鑰進行數字簽名的值，及自己的代碼簽名證書。文件的接受者不僅能驗證文件的完整性，還可以依據自己對證書籤發者和證書擁有者的信任程度，決定是否接受該文件。瀏覽器在下載運行插件和java小程序時，使用的就是這樣的模式。

第二是用作保存二進制文件系統的數字指紋，以便檢測文件系統是否未經允許的被修改。不少系統管理/系統安全軟件都提供這一文件系統完整性評估的功能，在系統初始安裝完畢後，建立對文件系統的基礎校驗和數據庫，因爲散列校驗和的長度很小，它們可以方便的被存放在容量很小的存儲介質上。此後，可以定期或根據需要，再次計算文件系統的校驗和，一旦發現與原來保存的值有不匹配，說明該文件已經被非法修改，或者是被病毒感染，或者被木馬程序替代。TripWire就提供了一個此類應用的典型例子。

更完美的方法是使用"MAC"。"MAC" 是一個與Hash密切相關的名詞，即信息鑑權碼(Message Authority Code)。它是與密鑰相關的Hash值，必須擁有該密鑰才能檢驗該Hash值。文件系統的數字指紋也許會被保存在不可信任的介質上，只對擁有該密鑰者提供可鑑別性。並且在文件的數字指紋有可能需要被修改的情況下，只有密鑰的擁有者可以計算出新的散列值，而企圖破壞文件完整性者卻不能得逞。

2) 數字簽名 
Hash 算法也是現代密碼體系中的一個重要組成部分。由於非對稱算法的運算速度較慢，所以在數字簽名協議中，單向散列函數扮演了一個重要的角色。

在這種簽名協議中，雙方必須事先協商好雙方都支持的Hash函數和簽名算法。

簽名方先對該數據文件進行計算其散列值，然後再對很短的散列值結果--如Md5是16個字節，SHA1是20字節，用非對稱算法進行數字簽名操作。對方在驗證簽名時，也是先對該數據文件進行計算其散列值，然後再用非對稱算法驗證數字簽名。

對 Hash 值，又稱"數字摘要"進行數字簽名，在統計上可以認爲與對文件本身進行數字簽名是等效的。而且這樣的協議還有其他的優點：

首先，數據文件本身可以同它的散列值分開保存，簽名驗證也可以脫離數據文件本身的存在而進行。

再者，有些情況下簽名密鑰可能與解密密鑰是同一個，也就是說，如果對一個數據文件簽名，與對其進行非對稱的解密操作是相同的操作，這是相當危險的，惡意的破壞者可能將一個試圖騙你將其解密的文件，充當一個要求你簽名的文件發送給你。因此，在對任何數據文件進行數字簽名時，只有對其Hash值進行簽名纔是安全的。

3) 鑑權協議 
如下的鑑權協議又被稱作"挑戰--認證模式：在傳輸信道是可被偵聽，但不可被篡改的情況下，這是一種簡單而安全的方法。

需要鑑權的一方，向將被鑑權的一方發送隨機串（“挑戰”），被鑑權方將該隨機串和自己的鑑權口令字一起進行 Hash 運算後，返還鑑權方，鑑權方將收到的Hash值與在己端用該隨機串和對方的鑑權口令字進行 Hash 運算的結果相比較（“認證”），如相同，則可在統計上認爲對方擁有該口令字，即通過鑑權。

POP3協議中就有這一應用的典型例子：

S: +OK POP3 server ready <[email protected]> 
C: APOP mrose c4c9334bac560ecc979e58001b3e22fb 
S: +OK maildrop has 1 message (369 octets) 
在上面的一段POP3協議會話中，雙方都共享的對稱密鑰（鑑權口令字）是tanstaaf，服務器發出的挑戰是<[email protected]>，客戶端對挑戰的應答是MD5("<[email protected]>tanstaaf") = c4c9334bac560ecc979e58001b3e22fb，這個正確的應答使其通過了認證。

散列算法長期以來一直在計算機科學中大量應用，隨着現代密碼學的發展，單向散列函數已經成爲信息安全領域中一個重要的結構模塊，我們有理由深入研究其設計理論和應用方法。

第一部分：Top K 算法詳解
問題描述
百度面試題：
    搜索引擎會通過日誌文件把用戶每次檢索使用的所有檢索串都記錄下來，每個查詢串的長度爲1-255字節。
    假設目前有一千萬個記錄（這些查詢串的重複度比較高，雖然總數是1千萬，但如果除去重複後，不超過3百萬個。一個查詢串的重複度越高，說明查詢它的用戶越多，也就是越熱門。），請你統計最熱門的10個查詢串，要求使用的內存不能超過1G。

必備知識：
    什麼是哈希表？
    哈希表（Hash table，也叫散列表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構。也就是說，它通過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫做散列函數，存放記錄的數組叫做散列表。

    哈希表的做法其實很簡單，就是把Key通過一個固定的算法函數既所謂的哈希函數轉換成一個整型數字，然後就將該數字對數組長度進行取餘，取餘結果就當作數組的下標，將value存儲在以該數字爲下標的數組空間裏。
    而當使用哈希表進行查詢的時候，就是再次使用哈希函數將key轉換爲對應的數組下標，並定位到該空間獲取value，如此一來，就可以充分利用到數組的定位性能進行數據定位（文章第二、三部分，會針對Hash表詳細闡述）。

問題解析：
    要統計最熱門查詢，首先就是要統計每個Query出現的次數，然後根據統計結果，找出Top 10。所以我們可以基於這個思路分兩步來設計該算法。
    即，此問題的解決分爲以下倆個步驟：

第一步：Query統計
    Query統計有以下倆個方法，可供選擇：
    1、直接排序法
    首先我們最先想到的的算法就是排序了，首先對這個日誌裏面的所有Query都進行排序，然後再遍歷排好序的Query，統計每個Query出現的次數了。

    但是題目中有明確要求，那就是內存不能超過1G，一千萬條記錄，每條記錄是255Byte，很顯然要佔據2.375G內存，這個條件就不滿足要求了。

    讓我們回憶一下數據結構課程上的內容，當數據量比較大而且內存無法裝下的時候，我們可以採用外排序的方法來進行排序，這裏我們可以採用歸併排序，因爲歸併排序有一個比較好的時間複雜度O(NlgN)。

    排完序之後我們再對已經有序的Query文件進行遍歷，統計每個Query出現的次數，再次寫入文件中。

    綜合分析一下，排序的時間複雜度是O(NlgN)，而遍歷的時間複雜度是O(N)，因此該算法的總體時間複雜度就是O(N+NlgN)=O（NlgN）。

    2、Hash Table法
    在第1個方法中，我們採用了排序的辦法來統計每個Query出現的次數，時間複雜度是NlgN，那麼能不能有更好的方法來存儲，而時間複雜度更低呢？

    題目中說明了，雖然有一千萬個Query，但是由於重複度比較高，因此事實上只有300萬的Query，每個Query255Byte，因此我們可以考慮把他們都放進內存中去，而現在只是需要一個合適的數據結構，在這裏，Hash Table絕對是我們優先的選擇，因爲Hash Table的查詢速度非常的快，幾乎是O(1)的時間複雜度。

    那麼，我們的算法就有了：維護一個Key爲Query字串，Value爲該Query出現次數的HashTable，每次讀取一個Query，如果該字串不在Table中，那麼加入該字串，並且將Value值設爲1；如果該字串在Table中，那麼將該字串的計數加一即可。最終我們在O(N)的時間複雜度內完成了對該海量數據的處理。

    本方法相比算法1：在時間複雜度上提高了一個數量級，爲O（N），但不僅僅是時間複雜度上的優化，該方法只需要IO數據文件一次，而算法1的IO次數較多的，因此該算法2比算法1在工程上有更好的可操作性。

第二步：找出Top 10
    算法一：普通排序
    我想對於排序算法大家都已經不陌生了，這裏不在贅述，我們要注意的是排序算法的時間複雜度是NlgN，在本題目中，三百萬條記錄，用1G內存是可以存下的。

    算法二：部分排序
    題目要求是求出Top 10，因此我們沒有必要對所有的Query都進行排序，我們只需要維護一個10個大小的數組，初始化放入10個Query，按照每個Query的統計次數由大到小排序，然後遍歷這300萬條記錄，每讀一條記錄就和數組最後一個Query對比，如果小於這個Query，那麼繼續遍歷，否則，將數組中最後一條數據淘汰，加入當前的Query。最後當所有的數據都遍歷完畢之後，那麼這個數組中的10個Query便是我們要找的Top10了。

    不難分析出，這樣，算法的最壞時間複雜度是N*K， 其中K是指top多少。

    算法三：堆
    在算法二中，我們已經將時間複雜度由NlogN優化到NK，不得不說這是一個比較大的改進了，可是有沒有更好的辦法呢？

    分析一下，在算法二中，每次比較完成之後，需要的操作複雜度都是K，因爲要把元素插入到一個線性表之中，而且採用的是順序比較。這裏我們注意一下，該數組是有序的，一次我們每次查找的時候可以採用二分的方法查找，這樣操作的複雜度就降到了logK，可是，隨之而來的問題就是數據移動，因爲移動數據次數增多了。不過，這個算法還是比算法二有了改進。

    基於以上的分析，我們想想，有沒有一種既能快速查找，又能快速移動元素的數據結構呢？回答是肯定的，那就是堆。
    藉助堆結構，我們可以在log量級的時間內查找和調整/移動。因此到這裏，我們的算法可以改進爲這樣，維護一個K(該題目中是10)大小的小根堆，然後遍歷300萬的Query，分別和根元素進行對比。

    思想與上述算法二一致，只是算法在算法三，我們採用了最小堆這種數據結構代替數組，把查找目標元素的時間複雜度有O（K）降到了O（logK）。
    那麼這樣，採用堆數據結構，算法三，最終的時間複雜度就降到了N‘logK，和算法二相比，又有了比較大的改進。

總結：
    至此，算法就完全結束了，經過上述第一步、先用Hash表統計每個Query出現的次數，O（N）；然後第二步、採用堆數據結構找出Top 10，N*O（logK）。所以，我們最終的時間複雜度是：O（N） + N'*O（logK）。（N爲1000萬，N’爲300萬）。如果各位有什麼更好的算法，歡迎留言評論。第一部分，完。

 

第二部分、Hash表 算法的詳細解析

什麼是Hash
     Hash，一般翻譯做“散列”，也有直接音譯爲“哈希”的，就是把任意長度的輸入（又叫做預映射， pre-image），通過散列算法，變換成固定長度的輸出，該輸出就是散列值。這種轉換是一種壓縮映射，也就是，散列值的空間通常遠小於輸入的空間，不同的輸入可能會散列成相同的輸出，而不可能從散列值來唯一的確定輸入值。簡單的說就是一種將任意長度的消息壓縮到某一固定長度的消息摘要的函數。

    HASH主要用於信息安全領域中加密算法，它把一些不同長度的信息轉化成雜亂的128位的編碼,這些編碼值叫做HASH值. 也可以說，hash就是找到一種數據內容和數據存放地址之間的映射關係。

    數組的特點是：尋址容易，插入和刪除困難；而鏈表的特點是：尋址困難，插入和刪除容易。那麼我們能不能綜合兩者的特性，做出一種尋址容易，插入刪除也容易的數據結構？答案是肯定的，這就是我們要提起的哈希表，哈希表有多種不同的實現方法，我接下來解釋的是最常用的一種方法——拉鍊法，我們可以理解爲“鏈表的數組”，如圖：

左邊很明顯是個數組，數組的每個成員包括一個指針，指向一個鏈表的頭，當然這個鏈表可能爲空，也可能元素很多。我們根據元素的一些特徵把元素分配到不同的鏈表中去，也是根據這些特徵，找到正確的鏈表，再從鏈表中找出這個元素。

    元素特徵轉變爲數組下標的方法就是散列法。散列法當然不止一種，下面列出三種比較常用的：

1，除法散列法 
最直觀的一種，上圖使用的就是這種散列法，公式： 
      index = value % 16 
學過彙編的都知道，求模數其實是通過一個除法運算得到的，所以叫“除法散列法”。

2，平方散列法 
求index是非常頻繁的操作，而乘法的運算要比除法來得省時（對現在的CPU來說，估計我們感覺不出來），所以我們考慮把除法換成乘法和一個位移操作。公式： 
      index = (value * value) >> 28   （右移，除以2^28。記法：左移變大，是乘。右移變小，是除。）
如果數值分配比較均勻的話這種方法能得到不錯的結果，但我上面畫的那個圖的各個元素的值算出來的index都是0——非常失敗。也許你還有個問題，value如果很大，value * value不會溢出嗎？答案是會的，但我們這個乘法不關心溢出，因爲我們根本不是爲了獲取相乘結果，而是爲了獲取index。

3，斐波那契（Fibonacci）散列法

平方散列法的缺點是顯而易見的，所以我們能不能找出一個理想的乘數，而不是拿value本身當作乘數呢？答案是肯定的。

1，對於16位整數而言，這個乘數是40503 
2，對於32位整數而言，這個乘數是2654435769 
3，對於64位整數而言，這個乘數是11400714819323198485

    這幾個“理想乘數”是如何得出來的呢？這跟一個法則有關，叫黃金分割法則，而描述黃金分割法則的最經典表達式無疑就是著名的斐波那契數列，即如此形式的序列：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,233, 377, 610， 987, 1597, 2584, 4181, 6765, 10946，…。另外，斐波那契數列的值和太陽系八大行星的軌道半徑的比例出奇吻合。

    對我們常見的32位整數而言，公式： 
            index = (value * 2654435769) >> 28

    如果用這種斐波那契散列法的話，那上面的圖就變成這樣了：

很明顯，用斐波那契散列法調整之後要比原來的取摸散列法好很多。 

適用範圍
    快速查找，刪除的基本數據結構，通常需要總數據量可以放入內存。

基本原理及要點
    hash函數選擇，針對字符串，整數，排列，具體相應的hash方法。 
碰撞處理，一種是open hashing，也稱爲拉鍊法；另一種就是closed hashing，也稱開地址法，opened addressing。

擴展 
    d-left hashing中的d是多個的意思，我們先簡化這個問題，看一看2-left hashing。2-left hashing指的是將一個哈希表分成長度相等的兩半，分別叫做T1和T2，給T1和T2分別配備一個哈希函數，h1和h2。在存儲一個新的key時，同 時用兩個哈希函數進行計算，得出兩個地址h1[key]和h2[key]。這時需要檢查T1中的h1[key]位置和T2中的h2[key]位置，哪一個 位置已經存儲的（有碰撞的）key比較多，然後將新key存儲在負載少的位置。如果兩邊一樣多，比如兩個位置都爲空或者都存儲了一個key，就把新key 存儲在左邊的T1子表中，2-left也由此而來。在查找一個key時，必須進行兩次hash，同時查找兩個位置。

問題實例（海量數據處理） 
    我們知道hash 表在海量數據處理中有着廣泛的應用，下面，請看另一道百度面試題：
題目：海量日誌數據，提取出某日訪問百度次數最多的那個IP。
方案：IP的數目還是有限的，最多2^32個，所以可以考慮使用hash將ip直接存入內存，然後進行統計。

 

第三部分、最快的Hash表算法

    接下來，咱們來具體分析一下一個最快的Hasb表算法。
    我們由一個簡單的問題逐步入手：有一個龐大的字符串數組，然後給你一個單獨的字符串，讓你從這個數組中查找是否有這個字符串並找到它，你會怎麼做？有一個方法最簡單，老老實實從頭查到尾，一個一個比較，直到找到爲止，我想只要學過程序設計的人都能把這樣一個程序作出來，但要是有程序員把這樣的程序交給用戶，我只能用無語來評價，或許它真的能工作，但...也只能如此了。

    最合適的算法自然是使用HashTable（哈希表），先介紹介紹其中的基本知識，所謂Hash，一般是一個整數，通過某種算法，可以把一個字符串"壓縮" 成一個整數。當然，無論如何，一個32位整數是無法對應回一個字符串的，但在程序中，兩個字符串計算出的Hash值相等的可能非常小，下面看看在MPQ中的Hash算法：

函數一、以下的函數生成一個長度爲0x500（合10進制數：1280）的cryptTable[0x500]

void prepareCryptTable()
{ 
    unsigned long seed = 0x00100001, index1 = 0, index2 = 0, i;
 
    for( index1 = 0; index1 < 0x100; index1++ )
    { 
        for( index2 = index1, i = 0; i < 5; i++, index2 += 0x100 )
        { 
            unsigned long temp1, temp2;
 
            seed = (seed * 125 + 3) % 0x2AAAAB;
            temp1 = (seed & 0xFFFF) << 0x10;
 
            seed = (seed * 125 + 3) % 0x2AAAAB;
            temp2 = (seed & 0xFFFF);
 
            cryptTable[index2] = ( temp1 | temp2 ); 
       } 
   } 
} 

函數二、以下函數計算lpszFileName 字符串的hash值，其中dwHashType 爲hash的類型，在下面的函數三、GetHashTablePos函數中調用此函數二，其可以取的值爲0、1、2；該函數返回lpszFileName 字符串的hash值： 

unsigned long HashString( char *lpszFileName, unsigned long dwHashType )
{ 
    unsigned char *key  = (unsigned char *)lpszFileName;
unsigned long seed1 = 0x7FED7FED;
unsigned long seed2 = 0xEEEEEEEE;
    int ch;
 
    while( *key != 0 )
    { 
        ch = toupper(*key++);
 
        seed1 = cryptTable[(dwHashType << 8) + ch] ^ (seed1 + seed2);
        seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3; 
    }
    return seed1; 
}

    Blizzard的這個算法是非常高效的，被稱爲"One-Way Hash"( A one-way hash is a an algorithm that is constructed in such a way that deriving the original string (set of strings, actually) is virtually impossible)。舉個例子，字符串"unitneutralacritter.grp"通過這個算法得到的結果是0xA26067F3。

　　是不是把第一個算法改進一下，改成逐個比較字符串的Hash值就可以了呢，答案是，遠遠不夠，要想得到最快的算法，就不能進行逐個的比較，通常是構造一個哈希表(Hash Table)來解決問題，哈希表是一個大數組，這個數組的容量根據程序的要求來定義，例如1024，每一個Hash值通過取模運算 (mod) 對應到數組中的一個位置，這樣，只要比較這個字符串的哈希值對應的位置有沒有被佔用，就可以得到最後的結果了，想想這是什麼速度？是的，是最快的O(1)，現在仔細看看這個算法吧：

typedef struct
{
    int nHashA;
    int nHashB;
    char bExists;
   ......
} SOMESTRUCTRUE;
一種可能的結構體定義？

函數三、下述函數爲在Hash表中查找是否存在目標字符串，有則返回要查找字符串的Hash值，無則，return -1.

int GetHashTablePos( har *lpszString, SOMESTRUCTURE *lpTable ) 
//lpszString要在Hash表中查找的字符串，lpTable爲存儲字符串Hash值的Hash表。
{ 
    int nHash = HashString(lpszString);  //調用上述函數二，返回要查找字符串lpszString的Hash值。
    int nHashPos = nHash % nTableSize;
 
    if ( lpTable[nHashPos].bExists  &&  !strcmp( lpTable[nHashPos].pString, lpszString ) ) 
    {  //如果找到的Hash值在表中存在，且要查找的字符串與表中對應位置的字符串相同，
        return nHashPos;    //則返回上述調用函數二後，找到的Hash值
    } 
    else
    {
        return -1;  
    } 
}

 
    看到此，我想大家都在想一個很嚴重的問題：“如果兩個字符串在哈希表中對應的位置相同怎麼辦？”,畢竟一個數組容量是有限的，這種可能性很大。解決該問題的方法很多，我首先想到的就是用“鏈表”,感謝大學裏學的數據結構教會了這個百試百靈的法寶，我遇到的很多算法都可以轉化成鏈表來解決，只要在哈希表的每個入口掛一個鏈表，保存所有對應的字符串就OK了。事情到此似乎有了完美的結局，如果是把問題獨自交給我解決，此時我可能就要開始定義數據結構然後寫代碼了。

    然而Blizzard的程序員使用的方法則是更精妙的方法。基本原理就是：他們在哈希表中不是用一個哈希值而是用三個哈希值來校驗字符串。

 

    MPQ使用文件名哈希表來跟蹤內部的所有文件。但是這個表的格式與正常的哈希表有一些不同。首先，它沒有使用哈希作爲下標，把實際的文件名存儲在表中用於驗證，實際上它根本就沒有存儲文件名。而是使用了3種不同的哈希：一個用於哈希表的下標，兩個用於驗證。這兩個驗證哈希替代了實際文件名。
    當然了，這樣仍然會出現2個不同的文件名哈希到3個同樣的哈希。但是這種情況發生的概率平均是：1:18889465931478580854784，這個概率對於任何人來說應該都是足夠小的。現在再回到數據結構上，Blizzard使用的哈希表沒有使用鏈表，而採用"順延"的方式來解決問題，看看這個算法：

函數四、lpszString 爲要在hash表中查找的字符串；lpTable 爲存儲字符串hash值的hash表；nTableSize 爲hash表的長度： 

int GetHashTablePos( char *lpszString, MPQHASHTABLE *lpTable, int nTableSize )
{
    const int  HASH_OFFSET = 0, HASH_A = 1, HASH_B = 2;
 
    int  nHash = HashString( lpszString, HASH_OFFSET );
    int  nHashA = HashString( lpszString, HASH_A );
    int  nHashB = HashString( lpszString, HASH_B );
    int  nHashStart = nHash % nTableSize;
    int  nHashPos = nHashStart;
 
    while ( lpTable[nHashPos].bExists )
   {
     /*如果僅僅是判斷在該表中時候存在這個字符串，就比較這兩個hash值就可以了，不用對
     *結構體中的字符串進行比較。這樣會加快運行的速度？減少hash表佔用的空間？這種
      *方法一般應用在什麼場合？*/
        if ( 　 lpTable[nHashPos].nHashA == nHashA
        &&  lpTable[nHashPos].nHashB == nHashB )
       {
            return nHashPos;
       }
       else
       {
            nHashPos = (nHashPos + 1) % nTableSize;
       }
 
        if (nHashPos == nHashStart)
              break;
    }
     return -1;
}

上述程序解釋：

1.計算出字符串的三個哈希值（一個用來確定位置，另外兩個用來校驗)
2. 察看哈希表中的這個位置
3. 哈希表中這個位置爲空嗎？如果爲空，則肯定該字符串不存在，返回-1。
4. 如果存在，則檢查其他兩個哈希值是否也匹配，如果匹配，則表示找到了該字符串，返回其Hash值。
5. 移到下一個位置，如果已經移到了表的末尾，則反繞到表的開始位置起繼續查詢　
6. 看看是不是又回到了原來的位置，如果是，則返回沒找到
7. 回到3

ok，這就是本文中所說的最快的Hash表算法。什麼?不夠快?:D。歡迎，各位批評指正。

--------------------------------------------
補充1、一個簡單的hash函數：

/*key爲一個字符串，nTableLength爲哈希表的長度
*該函數得到的hash值分佈比較均勻*/
unsigned long getHashIndex( const char *key, int nTableLength )
{
    unsigned long nHash = 0;
   
    while (*key)
    {
        nHash = (nHash<<5) + nHash + *key++;
    }
        
    return ( nHash % nTableLength );
}

 

補充2、一個完整測試程序：  
    哈希表的數組是定長的，如果太大，則浪費，如果太小，體現不出效率。合適的數組大小是哈希表的性能的關鍵。哈希表的尺寸最好是一個質數。當然，根據不同的數據量，會有不同的哈希表的大小。對於數據量時多時少的應用，最好的設計是使用動態可變尺寸的哈希表，那麼如果你發現哈希表尺寸太小了，比如其中的元素是哈希表尺寸的2倍時，我們就需要擴大哈希表尺寸，一般是擴大一倍。

    下面是哈希表尺寸大小的可能取值：

     17,            37,          79,        163,          331,  
    673,           1361,        2729,       5471,         10949,        
   21911,          43853,      87719,      175447,      350899,
  701819,         1403641,    2807303,     5614657,     11229331,   
 22458671,       44917381,    89834777,    179669557,   359339171,  
718678369,      1437356741,  2147483647

 

以下爲該程序的完整源碼，已在linux下測試通過：

#include <stdio.h>
#include <ctype.h>     //多謝citylove指正。
//crytTable[]裏面保存的是HashString函數裏面將會用到的一些數據，在prepareCryptTable
//函數裏面初始化
unsigned long cryptTable[0x500];

//以下的函數生成一個長度爲0x500（合10進制數：1280）的cryptTable[0x500]
void prepareCryptTable()
{
    unsigned long seed = 0x00100001, index1 = 0, index2 = 0, i;

    for( index1 = 0; index1 < 0x100; index1++ )
    {
        for( index2 = index1, i = 0; i < 5; i++, index2 += 0x100 )
        {
            unsigned long temp1, temp2;

            seed = (seed * 125 + 3) % 0x2AAAAB;
            temp1 = (seed & 0xFFFF) << 0x10;

            seed = (seed * 125 + 3) % 0x2AAAAB;
            temp2 = (seed & 0xFFFF);

            cryptTable[index2] = ( temp1 | temp2 );
       }
   }
}

//以下函數計算lpszFileName 字符串的hash值，其中dwHashType 爲hash的類型，
//在下面GetHashTablePos函數裏面調用本函數，其可以取的值爲0、1、2；該函數
//返回lpszFileName 字符串的hash值；
unsigned long HashString( char *lpszFileName, unsigned long dwHashType )
{
    unsigned char *key  = (unsigned char *)lpszFileName;
unsigned long seed1 = 0x7FED7FED;
unsigned long seed2 = 0xEEEEEEEE;
    int ch;

    while( *key != 0 )
    {
        ch = toupper(*key++);

        seed1 = cryptTable[(dwHashType << 8) + ch] ^ (seed1 + seed2);
        seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3;
    }
    return seed1;
}

//在main中測試argv[1]的三個hash值：
//./hash  "arr/units.dat"
//./hash  "unit/neutral/acritter.grp"
int main( int argc, char **argv )
{
    unsigned long ulHashValue;
    int i = 0;

    if ( argc != 2 )
    {
        printf("please input two arguments/n");
        return -1;
    }

     /*初始化數組：crytTable[0x500]*/
     prepareCryptTable();

     /*打印數組crytTable[0x500]裏面的值*/
     for ( ; i < 0x500; i++ )
     {
         if ( i % 10 == 0 )
         {
             printf("/n");
         }

         printf("%-12X", cryptTable[i] );
     }

     ulHashValue = HashString( argv[1], 0 );
     printf("/n----%X ----/n", ulHashValue );

     ulHashValue = HashString( argv[1], 1 );
     printf("----%X ----/n", ulHashValue );

     ulHashValue = HashString( argv[1], 2 );
     printf("----%X ----/n", ulHashValue );

     return 0;
}