Hash算法的講解
散列表,又叫哈希表，它是基於快速存取的角度設計的，也是一種典型的「空間換時間」的作法。顧名思義，該數據結構能夠理解爲一個線性表，可是其中的元素不是緊密排列的，而是可能存在空隙。java
散列表（Hash table，也叫哈希表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構。也就是說，它經過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫作散列函數，存放記錄的數組叫作散列表。好比咱們存儲70個元素，但咱們可能爲這70個元素申請了100個元素的空間。70/100=0.7，這個數字稱爲負載因子。咱們之因此這樣作，也 是爲了「快速存取」的目的。咱們基於一種結果儘量隨機平均分佈的固定函數H爲每一個元素安排存儲位置，這樣就能夠避免遍歷性質的線性搜索，以達到快速存取。可是因爲此隨機性，也必然致使一個問題就是衝突。所謂衝突，即兩個元素經過散列函數H獲得的地址相同，那麼這兩個元素稱爲「同義詞」。這相似於70我的去一個有100個椅子的飯店吃飯。散列函數的計算結果是一個存儲單位地址，每一個存儲單位稱爲「桶」。設一個散列表有m個桶，則散列函數的值域應爲[0,m-1]。 程序員
解決衝突是一個複雜問題。衝突主要取決於：面試
（1）散列函數，一個好的散列函數的值應儘量平均分佈。算法
（2）處理衝突方法。數組
（3）負載因子的大小。太大不必定就好，並且浪費空間嚴重，負載因子和散列函數是聯動的。 安全
解決衝突的辦法： 數據結構
（1）線性探查法：衝突後，線性向前試探，找到最近的一個空位置。缺點是會出現堆積現象。存取時，可能不是同義詞的詞也位於探查序列，影響效率。 函數
（2）雙散列函數法：在位置d衝突後，再次使用另外一個散列函數產生一個與散列表桶容量m互質的數c，依次試探(d+n*c)%m，使探查序列跳躍式分佈。性能
經常使用的構造散列函數的方法測試
散列函數能使對一個數據序列的訪問過程更加迅速有效，經過散列函數，數據元素將被更快地定位：
1. 直接尋址法：取關鍵字或關鍵字的某個線性函數值爲散列地址。即H(key)=key或H(key) = a?key + b，其中a和b爲常數（這種散列函數叫作自身函數）
2. 數字分析法：分析一組數據，好比一組員工的出生年月日，這時咱們發現出生年月日的前幾位數字大致相 同，這樣的話，出現衝突的概率就會很大，可是咱們發現年月日的後幾位表示月份和具體日期的數字差異很大，若是用後面的數字來構成散列地址，則衝突的概率會 明顯下降。所以數字分析法就是找出數字的規律，儘量利用這些數據來構造衝突概率較低的散列地址。
3. 平方取中法：取關鍵字平方後的中間幾位做爲散列地址。
4. 摺疊法：將關鍵字分割成位數相同的幾部分，最後一部分位數能夠不一樣，而後取這幾部分的疊加和（去除進位）做爲散列地址。
5. 隨機數法：選擇一隨機函數，取關鍵字的隨機值做爲散列地址，一般用於關鍵字長度不一樣的場合。
6. 除留餘數法：取關鍵字被某個不大於散列表表長m的數p除後所得的餘數爲散列地址。即 H(key) = key MOD p, p<=m。不只能夠對關鍵字直接取模，也可在摺疊、平方取中等運算以後取模。對p的選擇很重要，通常取素數或m，若p選的很差，容易產生同義詞。 查找的性能分析
散列表的查找過程基本上和造表過程相同。一些關鍵碼可經過散列函數轉換的地址直接找到，另外一些關鍵碼在散列函數獲得的地址上產生了衝突，須要按 處理衝突的方法進行查找。在介紹的三種處理衝突的方法中，產生衝突後的查找仍然是給定值與關鍵碼進行比較的過程。因此，對散列表查找效率的量度，依然用平 均查找長度來衡量。
查找過程當中，關鍵碼的比較次數，取決於產生衝突的多少，產生的衝突少，查找效率就高，產生的衝突多，查找效率就低。所以，影響產生衝突多少的因素，也就是影響查找效率的因素。影響產生衝突多少有如下三個因素：
1. 散列函數是否均勻；
2. 處理衝突的方法；
3. 散列表的裝填因子。
散列表的裝填因子定義爲：α= 填入表中的元素個數 / 散列表的長度
α是散列表裝滿程度的標誌因子。因爲表長是定值，α與「填入表中的元素個數」成正比，因此，α越大，填入表中的元素較多，產生衝突的可能性就越大；α越小，填入表中的元素較少，產生衝突的可能性就越小。
實際上，散列表的平均查找長度是裝填因子α的函數，只是不一樣處理衝突的方法有不一樣的函數。
瞭解了hash基本定義，就不能不提到一些著名的hash算法，MD5 和 SHA-1 能夠說是目前應用最普遍的Hash算法，而它們都是以 MD4 爲基礎設計的。那麼他們都是什麼意思呢?
這裏簡單說一下：
（1) MD4
MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年設計的，MD 是 Message Digest 的縮寫。它適用在32位字長的處理器上用高速軟件實現--它是基於 32 位操做數的位操做來實現的。
（2) MD5
MD5(RFC 1321)是 Rivest 於1991年對MD4的改進版本。它對輸入仍以512位分組，其輸出是4個32位字的級聯，與 MD4 相同。MD5比MD4來得複雜，而且速度較之要慢一點，但更安全，在抗分析和抗差分方面表現更好
（3) SHA-1 及其餘
SHA1是由NIST NSA設計爲同DSA一塊兒使用的，它對長度小於264的輸入，產生長度爲160bit的散列值，所以抗窮舉(brute-force)性更好。SHA-1 設計時基於和MD4相同原理,而且模仿了該算法。
哈希表不可避免衝突(collision)現象：對不一樣的關鍵字可能獲得同一哈希地址 即key1≠key2，而hash(key1)=hash(key2)。所以，在建造哈希表時不只要設定一個好的哈希函數，並且要設定一種處理衝突的方法。可以下描述哈希表：根據設定的哈希函數H(key)和所選中的處理衝突的方法，將一組關鍵字映象到一個有限的、地址連續的地址集(區間)上並以關鍵字在地址集中的「象」做爲相應記錄在表中的存儲位置，這種表被稱爲哈希表。
對於動態查找表而言，1) 表長不肯定；2)在設計查找表時，只知道關鍵字所屬範圍，而不知道確切的關鍵字。所以，通常狀況需創建一個函數關係，以f(key)做爲關鍵字爲key的 錄在表中的位置，一般稱這個函數f(key)爲哈希函數。(注意：這個函數並不必定是數學函數)
哈希函數是一個映象，即：將關鍵字的集合映射到某個地址集合上，它的設置很靈活，只要這個地址集合的大小不超出容許範圍便可。
現實中哈希函數是須要構造的，而且構造的好才能使用的好。
那麼這些Hash算法到底有什麼用呢?
Hash算法在信息安全方面的應用主要體如今如下的3個方面：
（1) 文件校驗
咱們比較熟悉的校驗算法有奇偶校驗和CRC校驗，這2種校驗並無抗數據篡改的能力，它們必定程度上能檢測並糾正數據傳輸中的信道誤碼，但卻不能防止對數據的惡意破壞。
MD5 Hash算法的"數字指紋"特性，使它成爲目前應用最普遍的一種文件完整性校驗和(Checksum)算法，很多Unix系統有提供計算md5 checksum的命令。
（2) 數字簽名
Hash 算法也是現代密碼體系中的一個重要組成部分。因爲非對稱算法的運算速度較慢，因此在數字簽名協議中，單向散列函數扮演了一個重要的角色。 對 Hash 值，又稱"數字摘要"進行數字簽名，在統計上能夠認爲與對文件自己進行數字簽名是等效的。並且這樣的協議還有其餘的優勢。
（3) 鑑權協議
以下的鑑權協議又被稱做挑戰--認證模式：在傳輸信道是可被偵聽，但不可被篡改的狀況下，這是一種簡單而安全的方法。
文件hash值
MD5-Hash-文件的數字文摘經過Hash函數計算獲得。無論文件長度如何，它的Hash函數計算結果是一個固定長度的數字。與加密算法不 同，這一個Hash算法是一個不可逆的單向函數。採用安全性高的Hash算法，如MD五、SHA時，兩個不一樣的文件幾乎不可能獲得相同的Hash結果。因 此，一旦文件被修改，就可檢測出來。
Hash函數還有另外的含義。實際中的Hash函數是指把一個大範圍映射到一個小範圍。把大範圍映射到一個小範圍的目的每每是爲了節省空間，使得數據容易保存。除此之外，Hash函數每每應用於查找上。因此，在考慮使用Hash函數以前，須要明白它的幾個限制：
1. Hash的主要原理就是把大範圍映射到小範圍；因此，你輸入的實際值的個數必須和小範圍至關或者比它更小。否則衝突就會不少。
2. 因爲Hash逼近單向函數；因此，你能夠用它來對數據進行加密。
3. 不一樣的應用對Hash函數有着不一樣的要求；好比，用於加密的Hash函數主要考慮它和單項函數的差距，而用於查找的Hash函數主要考慮它映射到小範圍的衝突率。 應用於加密的Hash函數已經探討過太多了，在做者的博客裏面有更詳細的介紹。因此，本文只探討用於查找的Hash函數。 Hash函數應用的主要對象是數組（好比，字符串），而其目標通常是一個int類型。
如下咱們都按照這種方式來講明。 通常的說，Hash函數能夠簡單的劃分爲以下幾類：
1. 加法Hash； 2. 位運算Hash； 3. 乘法Hash； 4. 除法Hash； 5. 查表Hash； 6. 混合Hash；
下面詳細的介紹以上各類方式在實際中的運用。
一 加法Hash
所謂的加法Hash就是把輸入元素一個一個的加起來構成最後的結果。標準的加法Hash的構造以下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
static
int
additiveHash(String key,
int
prime)
{
int
hash, i;
for
(hash = key.length(), i =
0
; i < key.length(); i++)
hash += key.charAt(i);
return
(hash % prime);
}
|
這裏的prime是任意的質數，看得出，結果的值域爲[0,prime-1]。
二 位運算Hash
這類型Hash函數經過利用各類位運算（常見的是移位和異或）來充分的混合輸入元素。好比，標準的旋轉Hash的構造以下：
|
1
2
3
4
5
6
7
8
9
|
static
int
rotatingHash(String key,
int
prime) {
int
hash, i;
for
(hash=key.length(), i=
0
; i hash = (hash<<
4
>>
28
)^key.charAt(i);
return
(hash % prime);
}
|
先移位，而後再進行各類位運算是這種類型Hash函數的主要特色。好比，以上的那段計算hash的代碼還能夠有以下幾種變形：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
hash = (hash<<
5
>>
27
)^key.charAt(i);
hash += key.charAt(i);
hash += (hash <<
10
);
hash ^= (hash >>
6
);
if
((i&
1
) ==
0
) {
hash ^= (hash<<
7
>>
3
);
}
else
{
hash ^= ~((hash<<
11
>>
5
));
} hash += (hash<<
5
> hash = key.charAt(i) + (hash<<
6
>>
16
) ? hash; hash ^= ((hash<<
5
>>
2
));
|
三 乘法Hash
這種類型的Hash函數利用了乘法的不相關性（乘法的這種性質，最有名的莫過於平方取頭尾的隨機數生成算法，雖然這種算法效果並很差）。好比，
|
1
2
3
4
5
6
7
|
static
int
bernstein(String key) {
int
hash =
0
;
int
i;
for
(i=
0
; i
return
hash;
}
|
jdk5.0裏面的String類的hashCode()方法也使用乘法Hash。不過，它使用的乘數是31。推薦的乘數還有：131, 1313, 13131, 131313等等。 使用這種方式的著名Hash函數還有：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
// 32位FNV算法 int M_SHIFT = 0;
public
int
FNVHash(
byte
[] data) {
int
hash = (
int
)2166136261L;
for
(
byte
b : data)
hash = (hash *
16777619
) ^ b;
if
(M_SHIFT ==
0
)
return
hash;
return
(hash ^ (hash >> M_SHIFT)) & M_MASK;
}
|
以及改進的FNV算法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public
static
int
FNVHash1(String data) {
final
int
p =
16777619
;
int
hash = (
int
)2166136261L;
for
(
int
i=
0
;i
hash = (hash ^ data.charAt(i)) * p;
hash += hash <<
13
;
hash ^= hash >>
7
;
hash += hash <<
3
;
hash ^= hash >>
17
;
hash += hash <<
5
;
return
hash;
}
|
除了乘以一個固定的數，常見的還有乘以一個不斷改變的數，好比：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
static
int
RSHash(String str) {
int
b =
378551
;
int
a =
63689
;
int
hash =
0
;
for
(
int
i =
0
; i < str.length(); i++) {
hash = hash * a + str.charAt(i);
a = a * b; }
return
(hash &
0x7FFFFFFF
);
}
|
雖然Adler32算法的應用沒有CRC32普遍，不過，它多是乘法Hash裏面最有名的一個了。關於它的介紹，你們能夠去看RFC 1950規範。
四 除法Hash
除法和乘法同樣，一樣具備表面上看起來的不相關性。不過，由於除法太慢，這種方式幾乎找不到真正的應用。須要注意的是，咱們在前面看到的hash的 結果除以一個prime的目的只是爲了保證結果的範圍。若是你不須要它限制一個範圍的話，可使用以下的代碼替代」hash%prime」： hash = hash ^ (hash>>10) ^ (hash>>20)。
五 查表Hash
查表Hash最有名的例子莫過於CRC系列算法。雖然CRC系列算法自己並非查表，可是，查表是它的一種最快的實現方式。下面是CRC32的實現：
查表Hash中有名的例子有：Universal Hashing和Zobrist Hashing。他們的表格都是隨機生成的。
六 混合Hash
混合Hash算法利用了以上各類方式。各類常見的Hash算法，好比MD五、Tiger都屬於這個範圍。它們通常不多在面向查找的Hash函數裏面使用
做者：July、wuliming、pkuoliver
說明：本文分爲三部份內容， 第一部分爲一道百度面試題Top K算法的詳解；第二部分爲關於Hash表算法的詳細闡述；第三部分爲打造一個最快的Hash表算法。
第一部分：Top K 算法詳解
問題描述（百度面試題）：
搜索引擎會經過日誌文件把用戶每次檢索使用的全部檢索串都記錄下來，每一個查詢串的長度爲1-255字節。假設目前有一千萬個記錄（這些查詢串的重複度比較高，雖然總數是1千萬，但若是除去重複後，不超過3百萬個。一個查詢串的重複度越高，說明查詢它的用戶越多，也就是越熱門。），請你統計最熱門的10個查詢串，要求使用的內存不能超過1G。
必備知識：
什麼是哈希表？
哈希表（Hash table，也叫散列表），是根據key而直接進行訪問的數據結構。也就是說，它經過把key映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫作散列函數，存放記錄的數組叫作散列表。
哈希表的作法其實很簡單，就是把key經過一個固定的算法函數即所謂的哈希函數轉換成一個整型數字，而後就將該數字對數組長度進行取餘，取餘結果就看成數組的下標，將value存儲在以該數字爲下標的數組空間裏。
而當使用哈希表進行查詢的時候，就是再次使用哈希函數將key轉換爲對應的數組下標，並定位到該空間獲取value，如此一來，就能夠充分利用到數組的定位性能進行數據定位（文章第2、三部分，會針對Hash表詳細闡述）。
問題解析：
要統計最熱門查詢，首先就是要統計每一個Query出現的次數，而後根據統計結果，找出Top 10。因此咱們能夠基於這個思路分兩步來設計該算法。
即，此問題的解決分爲如下兩個步驟：
第一步：Query統計
Query統計有如下倆個方法，可供選擇：
一、直接排序法
首先咱們最早想到的的算法就是排序了，首先對這個日誌裏面的全部Query都進行排序，而後再遍歷排好序的Query，統計每一個Query出現的次數了。
可是題目中有明確要求，那就是內存不能超過1G，一千萬條記錄，每條記錄是255Byte，很顯然要佔據2.375G內存，這個條件就不知足要求了。
讓咱們回憶一下數據結構課程上的內容，當數據量比較大並且內存沒法裝下的時候，咱們能夠採用外排序的方法來進行排序，這裏咱們能夠採用歸併排序，由於歸併排序有一個比較好的時間複雜度O(nlogn)。
排完序以後咱們再對已經有序的Query文件進行遍歷，統計每一個Query出現的次數，再次寫入文件中。
綜合分析一下，排序的時間複雜度是O(nlogn)，而遍歷的時間複雜度是O(n)，所以該算法的整體時間複雜度就是O(n+nlogn)=O(nlogn)。
二、Hash Table法
在第1個方法中，咱們採用了排序的辦法來統計每一個Query出現的次數，時間複雜度是O(nlogn)，那麼能不能有更好的方法來存儲，而時間複雜度更低呢？
題目中說明了，雖然有一千萬個Query，可是因爲重複度比較高，所以事實上只有300萬的Query，每一個Query 255Byte，所以咱們能夠考慮把他們都放進內存中去，而如今只是須要一個合適的數據結構，在這裏，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
算法一：普通排序
我想對於排序算法你們都已經不陌生了，這裏不在贅述，咱們要注意的是排序算法的時間複雜度是O(nlogn)，在本題目中，三百萬條記錄，用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表算法
接下來，我們來具體分析一下一個最快的Hash表算法。
咱們由一個簡單的問題逐步入手：有一個龐大的字符串數組，而後給你一個單獨的字符串，讓你從這個數組中查找是否有這個字符串並找到它，你會怎麼作？有一個方法最簡單，老老實實從頭查到尾，一個一個比較，直到找到爲止，我想只要學過程序設計的人都能把這樣一個程序做出來，但要是有程序員把這樣的程序交給用戶，我只能用無語來評價，或許它真的能工做，但...也只能如此了。
最合適的算法天然是使用HashTable（哈希表），先介紹介紹其中的基本知識，所謂Hash，通常是一個整數，經過某種算法，能夠把一個字符串"壓縮" 成一個整數。固然，不管如何，一個32位整數是沒法對應回一個字符串的，但在程序中，兩個字符串計算出的Hash值相等的可能很是小，下面看看在MPQ中的Hash算法：
函數1、如下的函數生成一個長度爲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 );
}
}
}
函數2、如下函數計算lpszFileName字符串的hash值，其中dwHashType爲hash的類型（在下面的函數三GetHashTablePos函數中調用此函數二），其能夠取的值爲0、一、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;
一種可能的結構體定義？
函數3、下述函數爲在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使用的哈希表沒有使用鏈表，而採用"順延"的方式來解決問題，看看這個算法：
函數4、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。歡迎，各位批評指正。
--------------------------------------------
補充一、一個簡單的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倍時，咱們就須要擴大哈希表尺寸，通常是擴大一倍。
下面是哈希表尺寸大小的可能取值：
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、一、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;
}
- 1. Hash算法的講解
- 2. Hash算法詳解
- 3. hash表、hash算法
- 4. Hash算法和一致性Hash算法
- 5. Hash算法解決衝突的方法
- 6. 加密解密算法與Hash算法
- 7. 【算法】Hash一致性算法詳解
- 8. hash算法原理詳解
- 9. 左神算法講堂筆記 06 Hash算法
- 10. hash值和hash算法
- 更多相關文章...
- • MySQL常用運算符詳解 - MySQL教程
- • ARP協議的工作機制詳解 - TCP/IP教程
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
- • 算法總結-廣度優先算法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Hash算法的講解
- 2. Hash算法詳解
- 3. hash表、hash算法
- 4. Hash算法和一致性Hash算法
- 5. Hash算法解決衝突的方法
- 6. 加密解密算法與Hash算法
- 7. 【算法】Hash一致性算法詳解
- 8. hash算法原理詳解
- 9. 左神算法講堂筆記 06 Hash算法
- 10. hash值和hash算法