1. 前言

哈希表或稱為散列表，是一種常見的、使用頻率非常高的數(shù)據(jù)存儲方案。

哈希表屬于抽象數(shù)據(jù)結構，需要開發(fā)者按哈希表數(shù)據(jù)結構的存儲要求進行API定制，對于大部分高級語言而言，都會提供已經(jīng)實現(xiàn)好的、可直接使用的API，如JAVA中有MAP集合、C++中的MAP容器，Python中的字典……

使用者可以使用API中的方法完成對哈希表的增、刪、改、查……一系列操作。

如何學習哈希表？

可以從2個角度開始：

• 使用者角度：只需要知道哈希表是基于鍵、值對存儲的解決方案，另需要熟悉不同計算機語言提供的基于哈希表數(shù)據(jù)結構的 API實現(xiàn)，學會使用 API中的方法。
• 開發(fā)者的角度：則需要知道哈希表底層實現(xiàn)原理，以及實現(xiàn)過程中需要解決的各種問題。本文將站在開發(fā)者的角度，帶著大家一起探究哈希的世界。

2. 哈希表

什么是哈希表？

哈希表是基于鍵、值對存儲的數(shù)據(jù)結構，底層一般采用的是列表(數(shù)組)。

大家都知道，基于列表（數(shù)組）的查詢速度非常快，時間復雜度是O（1），常量級別的。

列表的底層存儲結構是連續(xù)的內(nèi)存區(qū)域，只要給定數(shù)據(jù)在列表（數(shù)組）中的位置，就能直接查詢到數(shù)據(jù)。理論上是這么回事，但在實際操作過程，查詢數(shù)據(jù)的時間復雜度卻不一定是常量級別的。

如存儲下面的學生信息，學生信息包括學生的姓名和學號。在存儲學生數(shù)據(jù)時，如果把學號為0的學生存儲在列表0位置，學號為1的學生存儲在列表1位置……

這里把學生的學號和列表的索引號進行關聯(lián)，查詢某一個學生時，知道了學生的學號也就知道了學生數(shù)據(jù)存儲在列表中的位置，可以認為查詢的時間復雜度為O(1)。

之所以可以達到常量級，是因為這里有信息關聯(lián)（學生學號關聯(lián)到數(shù)據(jù)的存儲位置）。

還有一點，學生的學號是公開信息也是常用信息，很容易獲取。

但是，不是存儲任何數(shù)據(jù)時，都可以找到與列表位置相關聯(lián)的信息。比如存儲所有的英文單詞，不可能為每一個英文單詞編號，即使編號了，編號在這里也僅僅是流水號，沒有數(shù)據(jù)含義的數(shù)據(jù)對于使用者來講是不友好，誰也無法記住哪個英文單詞對應哪個編號。

所以使用列表存儲英文單詞后需要詢時，因沒有單詞的存儲位置。還是需要使用如線性、二分……之類的查詢算法，這時的時間復雜度由使用的查詢算法的時間復雜度決定。

如果對上述存儲在列表的學生信息進行了插入、刪除……等操作，改變了數(shù)據(jù)原來的位置后，因破壞了學號與位置關聯(lián)信息，再查詢時也只能使用其它查詢算法，不可能達到常量級。

是否存在一種方案，能最大化地優(yōu)化數(shù)據(jù)的存儲和查詢？

通過上述的分析，可以得出一個結論，要提高查詢的速度，得想辦法把數(shù)據(jù)與位置進行關聯(lián)。而哈希表的核心思想便是如此。

2.1 哈希函數(shù)

哈希表引入了關鍵字概念，關鍵字可以認為是數(shù)據(jù)的別名。如上表，可以給每一個學生起一個別名，這個就是關鍵字。

Tip： 這里的關鍵字是姓名的拼音縮寫，關鍵字和數(shù)據(jù)的關聯(lián)性較強，方便記憶和查詢。

有了關鍵字后，再把關鍵字映射成列表中的一個有效位置，映射方法就是哈希表中最重要的概念哈希函數(shù)。

關鍵字是一個橋梁，即關聯(lián)到真正數(shù)據(jù)又關聯(lián)到哈希表中的位置。

關鍵字也可以是需要保存的數(shù)據(jù)本身。

哈希函數(shù)的功能：提供把關鍵字映射到列表中的位置算法，是哈希表存儲數(shù)據(jù)的核心所在。如下圖，演示數(shù)據(jù)、哈希函數(shù)、哈希表之間的關系，可以說哈希函數(shù)是數(shù)據(jù)進入哈希表的入口。

數(shù)據(jù)最終會存儲在列表中的哪一個位置，完全由哈希算法決定。

當需要查詢學生數(shù)據(jù)時，同樣需要調(diào)用哈希函數(shù)對關鍵字進行換算，計算出數(shù)據(jù)在列表中的位置后就能很容易查詢到數(shù)據(jù)。

如果忽視哈希函數(shù)的時間復雜度，基于哈希表的數(shù)據(jù)存儲和查詢時間復雜度是 O(1)。

如此說來哈希函數(shù)算法設計的優(yōu)劣是影響哈希表性能的關鍵所在。

2.2 哈希算法

哈希算法決定了數(shù)據(jù)的最終存儲位置，不同的哈希算法設計方案，也關乎哈希表的整體性能，所以，哈希算法就變得的尤為重要。

下文將介紹并縱橫比較幾種常見的 哈希算法的設計方案。

Tip：無論使用何種哈希算法，都有一個根本，哈希后的結果一定是一個數(shù)字，表示列表（哈希表）中的一個有效位置。也稱為哈希值。

使用哈希表存儲數(shù)據(jù)時，關鍵字可以是數(shù)字類型也可以是非數(shù)字類型，其實，關鍵字可以是任何一種類型。這里先討論當關鍵字為非數(shù)字類型時設計哈希算法的基本思路。

如前所述，已經(jīng)為每一個學生提供了一個以姓名的拼音縮寫的關鍵字。

現(xiàn)在如何把關鍵字映射到列表的一個有效位置？

這里可以簡單地把拼音看成英文中的字母，先分別計算每一個字母在字母表中的位置，然后相加，得到的一個數(shù)字。

使用上面的哈希思想對每一個學生的關鍵字進行哈希：

• zjl的哈希值為 26+10+12=48。
• llj的哈希值為 12+12+10=34。
• cl 的哈希值為 3+12=15。
• zxy的哈希值為 26+25+24=75。

前文說過哈希值是表示數(shù)據(jù)在列表中的存儲位置，現(xiàn)在假設一種理想化狀態(tài)，學生的姓名都是3個漢字，意味著關鍵字也是3個字母，采用上面的的哈希算法，最大的哈希值應該是zzz=26+26+26=78，意味著至少應該提供一個長度為78的列表 。

如果，現(xiàn)在僅僅只保存4名學生，雖然只有4名學生，因無法保證學生的關鍵字不出現(xiàn)zzz，所以列表長度還是需要78。如下圖所示。

采用這種哈希算法會導致列表的空間浪費嚴重，最直觀想法是對哈希值再做約束，如除以4再取余數(shù)，把哈希值限制在4之內(nèi)，4個數(shù)據(jù)對應4個哈希值。我們稱這種取余數(shù)方案為取余數(shù)算法。

取余數(shù)法中，被除數(shù)一般選擇小于哈希表長度的素數(shù)。本文介紹其它哈希算法時，也會使用取余數(shù)法對哈希值進行適當范圍的收縮。

重新對 4 名學生的關鍵字進行哈希。

• zjl的哈希值為 26+10+12=48，48 除以 4 取余數(shù)，結果是0。
• llj的哈希值為 12+12+10=34，34 除以 4 取余數(shù)，結果是2。
• cl 的哈希值為 3+12=15，15 除以 4 取余數(shù)，結果是3。
• zzz的哈希值為 26+26+26=78，78 除以 4 取余數(shù)，結果是2。

演示圖上出現(xiàn)了一個很奇怪的現(xiàn)象，沒有看到李連杰的存儲信息。

4個存儲位置存儲4學生，應該是剛剛好，但是，只存儲了3名學生。且還有1個位置是空閑的?，F(xiàn)在編碼驗證一下，看是不是人為因素引起的。

'''
哈希函數(shù)
'''
def hash_code(key):
    # 設置字母 A 的在字母表中的位置是 1
    pos = 0
    for i in key:
        i = i.lower()
        res = ord(i) - ord('a') + 1
        pos += res
    return pos % 4

測試代碼：

# 哈希表
hash_table = [None] * 4
# 計算關鍵字的哈希值
idx = hash_code('zjl')
# 根據(jù)關鍵字換算出來的位置存儲數(shù)據(jù)
hash_table[idx] = '周杰倫'
idx = hash_code('llj')
hash_table[idx] = '李連杰'
idx = hash_code('cl')
hash_table[idx] = '成龍'
idx = hash_code('zzz')
hash_table[idx] = '張志忠'
print('哈希表中的數(shù)據(jù)：', hash_table)
'''
輸出結果：
哈希表中的數(shù)據(jù)： ['周杰倫', None, '張志忠', '成龍']
'''

執(zhí)行代碼，輸出結果，依然還是沒有看到李連杰的信息。

原因何在？

這是因為李連杰和張志忠的哈希值都是2 ，導致在存儲時，后面存儲的數(shù)據(jù)會覆蓋前面存儲的數(shù)據(jù)，這就是哈希中的典型問題，哈希沖突問題。

所謂哈希沖突，指不同的關鍵字在進行哈希算法后得到相同的哈希值，這意味著，不同關鍵字所對應的數(shù)據(jù)會存儲在同一個位置，這肯定會發(fā)生數(shù)據(jù)丟失，所以需要提供算法，解決沖突問題。

Tip： 研究哈希表，歸根結底，是研究如何計算哈希值以及如何解決哈希值沖突的問題。

針對上面的問題，有一種想當然的沖突解決方案，擴展列表的存儲長度，如把列表擴展到長度為8。

直觀思維是：擴展列表長度，哈希值的范圍會增加，沖突的可能性會降低。

'''
哈希函數(shù)
'''
def hash_code(key):
    # 設置字母 A 的在字母表中的位置是 1
    pos = 0
    for i in key:
        i = i.lower()
        res = ord(i) - ord('a') + 1
        pos += res
    return pos % 8

# 哈希表
hash_table = [None] * 8

# 保存所有學生
idx = hash_code('zjl')
hash_table[idx] = '周杰倫'
idx = hash_code('llj')
hash_table[idx] = '李連杰'
idx = hash_code('cl')
hash_table[idx] = '成龍'
idx = hash_code('zzz')
hash_table[idx] = '張志忠'
print('哈希表中的數(shù)據(jù)：', hash_table)
'''
輸出結果：
哈希表中的數(shù)據(jù)： ['周杰倫', None, '李連杰', None, None, None, '張志忠', '成龍']
'''

貌似解決了沖突問題，其實不然，當試著設置列表的長度為6、7、8、9、10時，只有當長度為8時沒有發(fā)生沖突，這還是在要存儲的數(shù)據(jù)是已知情況下的嘗試。

如果數(shù)據(jù)是動態(tài)變化的，顯然這種擴展長度的方案絕對不是本質(zhì)解決沖突的方案。即不能解決沖突，且產(chǎn)生大量空間浪費。

如何解決哈希沖突，會在后文詳細介紹，這里還是回到哈希算法上。

綜上所述，我們對哈希算法的理想要求是：

• 為每一個關鍵字生成一個唯一的哈希值，保證每一個數(shù)據(jù)都有只屬于自己的存儲位置。
• 哈希算法的性能時間復雜度要低。

現(xiàn)實情況是，同時滿足這2個條件的哈希算法幾乎是不可能有的，面對數(shù)據(jù)量較多時，哈希沖突是常態(tài)。所以，只能是盡可能滿足。

因沖突的存在，即使為 100 個數(shù)據(jù)提供 100 個有效存儲空間，還是會有空間閑置。這里把實際使用空間和列表提供的有效空間相除，得到的結果，稱之為哈希表的占有率（載荷因子）。

如上述，當列表長度為 4時， 占有率為 3/4=0.75，當列表長度為 8 時，占有率為 4/8=0.5，一般要求占率控制 在0.6~0.9之間。

2.3 常見哈希算法

前面在介紹什么是哈希算法時，提到了取余數(shù)法，除此之外，還有幾種常見的哈希算法。

2.3.1 折疊法

折疊法：將關鍵字分割成位數(shù)相同的幾個部分（最后一部分的位數(shù)可以不同）然后取這幾部分的疊加和（舍去進位）作為哈希值。

折疊法又分移位疊加和間界疊加。

• 移位疊加：將分割后的每一部分的最低位對齊，然后相加。
• 間界疊加：從一端沿分割線來回折疊，然后對齊相加。

因有相加求和計算，折疊法適合數(shù)字類型或能轉換成數(shù)字類型的關鍵字。假設現(xiàn)在有很多商品訂單信息，為了簡化問題，訂單只包括訂單編號和訂單金額。

現(xiàn)在使用用哈希表存儲訂單數(shù)據(jù)，且以訂單編號為關鍵字，訂單金額為值。

移位疊法換算關鍵字的思路：

第一步：把訂單編號20201011按每3位一組分割，分割后的結果：202、010、11。

按2位一組還是3位一組進行分割，可以根據(jù)實際情況決定。

第二步： 把分割后的數(shù)字相加202+010+11，得到結果：223。再使用取余數(shù)法，如果哈希表的長度為10，則除以10后的余數(shù)為3。

這里除以10僅是為了簡化問題細節(jié)，具體操作時，很少選擇列表的長度。

第三步：對其它的關鍵字采用相同的處理方案。

編碼實現(xiàn)保存商品訂單信息：

'''
移位疊加哈希算法
'''
def hash_code(key, hash_table_size):
    # 轉換成字符串
    key_s = str(key)
    # 保存求和結果
    s = 0
    # 使用切片
    for i in range(0, len(key_s), 3):
        s += int(key_s[i:i + 3])
    return s % hash_table_size

# 商品信息
products = [[20201011, 400.00], [19981112, 300], [20221212, 200]]
# 哈希表長度
hash_size = 10
# 哈希表
hash_table = [None] * hash_size
# 以哈希表方式進行存儲
for p in products:
    key = hash_code(p[0], hash_size)
    hash_table[key] = p[1]
# 顯示哈希表中的數(shù)據(jù)
print("哈希表中的數(shù)據(jù)：",hash_table)
# 根據(jù)訂單號進行查詢
hash_val = hash_code(19981112, hash_size)
val = hash_table[hash_val]
print("訂單號為{0}的金額為{1}".format(19981112, val))
'''
輸出結果
哈希表中的數(shù)據(jù)： [None, None, 300, 400.0, None, None, 200, None, None, None]
訂單號為19981112的金額為300
'''

間界疊加法：

間界疊加法，會間隔地把要相加的數(shù)字進行反轉。

如訂單編號19981112 按3位一組分割，分割后的結果：199、811、12，間界疊加操作求和表達式為199+118+12=339，再把結果339%10=9。

編碼實現(xiàn)間界疊加算法：

'''
間界疊加哈希算法
'''
def hash_code(key, hash_table_size):
    # 轉換成字符串
    key_s = str(key)
    # 保存求和結果
    s = 0
    # 使用切片
    for i in range(0, len(key_s), 3):
        # 切片
        tmp_s = key_s[i:i + 3]
        # 反轉
        if i % 2 != 0:
            tmp_s = tmp_s[::-1]
        s += int(tmp_s)
    return s % hash_table_size

# 商品信息（數(shù)據(jù)樣例）
products = [[20201011, 400.00], [19981112, 300], [20221212, 200]]
# 哈希表長度
hash_size = 10
# 哈希表
hash_table = [None] * hash_size
# 以哈希表方式進行存儲
for p in products:
    key = hash_code(p[0], hash_size)
    hash_table[key] = p[1]
# 顯示哈希表中的數(shù)據(jù)
print("哈希表中的數(shù)據(jù)：", hash_table)
# 根據(jù)訂單號進行查詢
hash_val = hash_code(19981112, hash_size)
val = hash_table[hash_val]
print("訂單號為{0}的金額為{1}".format(19981112, val))
'''
輸出結果：
哈希表中的數(shù)據(jù)： [None, None, None, 400.0, None, None, 200, None, None, 300]
訂單號為19981112的金額為300
'''

2.3.2 平方取中法

平方取中法：先是對關鍵字求平方，再在結果中取中間位置的數(shù)字。

求平方再取中算法，是一種較常見的哈希算法，從數(shù)學公式可知，求平方后得到的中間幾位數(shù)字與關鍵字的每一位都有關，取中法能讓最后計算出來的哈希值更均勻。

因要對關鍵字求平方，關鍵字只能是數(shù)字或能轉換成數(shù)字的類型，至于關鍵字本身的大小范圍限制，要根據(jù)使用的計算機語言靈活設置。

如下面的圖書數(shù)據(jù)，圖書包括圖書編號和圖書名稱。現(xiàn)在需要使用哈希表保存圖書信息，以圖書編號為關鍵字，圖書名稱為值。

使用平方取中法計算關鍵字的哈希值：

第一步：對圖書編號58求平方，結果為3364。

第二步：取3364的中間值36，然后再使用取余數(shù)方案。如果哈希表的長度為10，則36%10=6。

第三步：對其它的關鍵字采用相同的計算方案。

編碼實現(xiàn)平方取中算法：

'''
哈希算法
平方取中
'''
def hash_code(key, hash_table_size):
    # 求平方
    res = key ** 2
    #  取中間值，這里取中間 2 位（簡化問題）
    res = int(str(res)[1:3])
    # 取余數(shù)
    return res % hash_table_size

hash_table_size = 10
hash_table = [None]*hash_table_size
# 圖書信息
books = [[58, "python 從入門到精通"], [67, "C++ STL"], [78, "Java 內(nèi)存模型"]]
for b in books:
    hash_val = hash_code(b[0],hash_table_size)
    hash_table[hash_val]=b[1]

# 顯示哈希表中的數(shù)據(jù)
print("哈希表中的數(shù)據(jù)：", hash_table)
# 根據(jù)編號進行查詢
hash_val = hash_code(67, hash_table_size)
val = hash_table[hash_val]
print("編號為{0}的書名為{1}".format(67, val))

上述求平方取中間值的算法僅針對于本文提供的圖書數(shù)據(jù)，如果需要算法具有通用性，則需要根據(jù)實際情況修改。

不要被 取中的中字所迷惑，不一定是絕對中間位置的數(shù)字。

2.3.3 直接地址法

直接地址法：提供一個與關鍵字相關聯(lián)的線性函數(shù)。如針對上述圖書數(shù)據(jù)，可以提供線性函數(shù)f(k)=2*key+10。

系數(shù)2和常數(shù)10的選擇會影響最終生成的哈希值的大小。可以根據(jù)哈希表的大小和操作的數(shù)據(jù)含義自行選擇。

key為圖書編號。當關鍵字不相同時，使用線性函數(shù)得到的值也是唯一的，所以，不會產(chǎn)生哈希沖突，但是會要求哈希表的存儲長度比實際數(shù)據(jù)要大。

這種算法在實際應用中并不多見。

實際應用時，具體選擇何種哈希算法，完全由開發(fā)者定奪，哈希算法的選擇沒有固定模式可循，雖然上面介紹了幾種算法，只是提供一種算法思路。

2.4 哈希沖突

哈希沖突是怎么引起的，前文已經(jīng)說過?，F(xiàn)在聊聊常見的幾種哈希沖突解決方案。

2.4.1 線性探測

當發(fā)生哈希沖突后，會在沖突位置之后尋找一個可用的空位置。如下圖所示，使用取余數(shù)哈希算法，保存數(shù)據(jù)到哈希表中。

哈希表的長度設置為 15，除數(shù)設置為 13。

解決沖突的流程：

• 78和26的哈希值都是 0。而因為78在26的前面，78先占據(jù)哈希表的 0位置。
• 當存儲 26時，只能以 0位置為起始位置，向后尋找空位置，因 1位置沒有被其它數(shù)據(jù)占據(jù)，最終保存在哈希表的1位置。
• 當存儲數(shù)字 14時，通過哈希算法計算，其哈希值是1，本應該要保存在哈希表中1的位置，因1位置已經(jīng)被26所占據(jù)，只能向后尋找空位置，最終落腳在2位置。

線性探測法讓發(fā)生哈希沖突的數(shù)據(jù)保存在其它數(shù)據(jù)的哈希位置，如果沖突的數(shù)據(jù)較多，則占據(jù)的本應該屬于其它數(shù)據(jù)的哈希位置也較多，這種現(xiàn)象稱為哈希聚集。

查詢流程：

以查詢數(shù)據(jù)14為例。

• 計算 14的哈希值，得到值為 1 ，根據(jù)哈希值在哈希表中找到對應位置。
• 查看對應位置是否存在數(shù)據(jù)，如果不存在，宣告查詢失敗，如果存在，則需要提供數(shù)據(jù)比較方法。
• 因 1位置的數(shù)據(jù) 26并不等于14。于是，繼續(xù)向后搜索，并逐一比較。
• 最終可以得到結論14在哈希表的編號為2的位置。

所以，在查詢過程中，除了要提供哈希函數(shù)，還需要提供數(shù)據(jù)比較函數(shù)。

刪除流程：

以刪除數(shù)字26為例。

按上述的查詢流程找到數(shù)字26在哈希表中的位置1。

設置位置1為刪除狀態(tài)，一定要標注此位置曾經(jīng)保存過數(shù)據(jù)，而不能設置為空狀態(tài)。為什么？

如果設置為空狀態(tài)，則在查詢數(shù)字14時，會產(chǎn)生錯誤的返回結果，會認為14不存在。為什么？自己想想。

編碼實現(xiàn)線性探測法：

添加數(shù)據(jù)：

'''
線性探測法解決哈希沖突
'''
def hash_code(key, hash_table, num):
    # 哈希表的長度
    size = len(hash_table)
    # 取余數(shù)法計算哈希值
    hash_val = key % num
    # 檢查此位置是否已經(jīng)保存其它數(shù)據(jù)
    if hash_table[hash_val] is not None:
        # 則從hash_val 之后尋找空位置
        for i in range(hash_val + 1, size + hash_val):
            if i >= size:
                i = i % size
            if hash_table[i] is None:
                hash_val = i
                break
    return hash_val

# 哈希表
hash_table = [None] * 15
src_nums = [25, 78, 56, 32, 88, 26, 73, 81, 14]
for n in src_nums:
    hash_val = hash_code(n, hash_table, 13)
    hash_table[hash_val] = n

print("哈希表中的數(shù)據(jù)：", hash_table)
'''
輸出結果：
哈希表中的數(shù)據(jù)： [78, 26, 14, 81, 56, None, 32, None, 73, None, 88, None, 25, None, None]
'''

Tip：為了保證當哈希值發(fā)生沖突后，如果從沖突位置查到哈希表的結束位置還是沒有找到空位置，則再從哈希表的起始位置，也就是0位置再搜索到?jīng)_突位置。沖突位置是起點也是終點，構建一個查找邏輯環(huán)，以保證一定能找到空位置。

for i in range(hash_val + 1, size + hash_val):
	 pass

基于線性探測的數(shù)據(jù)查詢過程和存儲過程大致相同：

def get(key, hash_table, num):
    # 哈希表的長度
    size = len(hash_table)
    # 取余數(shù)法計算哈希值
    hash_val = key % num
    is_exist = False
    # 檢查此位置是否已經(jīng)保存其它數(shù)據(jù)
    if hash_table[hash_val] is None:
        # 不存在
        return None
    if hash_table[hash_val] != key:
        # 則從hash_val 之后尋找空位置
        for i in range(hash_val + 1, size + hash_val):
            if i >= size:
                i = i % size
            if hash_table[i] == key:
                hash_val = i
                is_exist = True
                break
    else:
        is_exist=True
    if is_exist:
        return hash_val

# 測試   
res = get(25, hash_table, 13)
print(res)

為了減少數(shù)據(jù)聚集，可以采用增量線性探測法，所謂增量指當發(fā)生哈希沖突后，探測空位置時，使用步長值大于1的方式跳躍式向前查找。目的是讓數(shù)據(jù)分布均勻，減小數(shù)據(jù)聚集。

除了采用增量探測之外，還可以使用再哈希的方案。也就是提供2個哈希函數(shù)，第1次哈希值發(fā)生沖突后，再調(diào)用第2個哈希函數(shù)再哈希，直到?jīng)_突不再產(chǎn)生。這種方案會增加計算時間。

2.4.2 鏈表法

上面所述的沖突解決方案的核心思想是，當沖突發(fā)生后，在哈希表中再查找一個有效空位置。

這種方案的優(yōu)勢是不會產(chǎn)生額外的存儲空間，但易產(chǎn)生數(shù)據(jù)聚集，會讓數(shù)據(jù)的存儲不均衡，并且會違背初衷，通過關鍵字計算出來的哈希值并不能準確描述數(shù)據(jù)正確位置。

鏈表法應該是所有解決哈希沖突中較完美的方案。所謂鏈表法，指當發(fā)生哈希沖突后，以沖突位置為首結點構建一條鏈表，以鏈表方式保存所有發(fā)生沖突的數(shù)據(jù)。如下圖所示：

鏈表方案解決沖突，無論在存儲、查詢、刪除時都不會影響其它數(shù)據(jù)位置的獨立性和唯一性，且因鏈表的操作速度較快，對于哈希表的整體性能都有較好改善。

使用鏈表法時，哈希表中保存的是鏈表的首結點。首結點可以保存數(shù)據(jù)也可以不保存數(shù)據(jù)。

編碼實現(xiàn)鏈表法：鏈表實現(xiàn)需要定義 2 個類，1 個是結點類，1 個是哈希類。

'''
結點類
'''
class HashNode():
    def __init__(self, value):
        self.value = value
        self.next_node = None

'''
哈希類
'''
class HashTable():
    def __init__(self):
        # 哈希表,初始大小為 15，可以根據(jù)需要動態(tài)修改
        self.table = [None] * 15
        # 實際數(shù)據(jù)大小
        self.size = 0

    '''
    存儲數(shù)據(jù)
    key:關鍵字
    value:值
    '''

    def put(self, key, value):
        hash_val = self.hash_code(key)
        # 新結點
        new_node = HashNode(value)
        if self.table[hash_val] is None:
            # 本代碼采用首結點保存數(shù)據(jù)方案
            self.table[hash_val] = new_node
            self.size+=1
        else:
            move = self.table[hash_val]
            while move.next_node is not None:
                move = move.next_node
            move.next_node = new_node
            self.size+=1

    '''
    查詢數(shù)據(jù)
    '''
    def get(self, key):
        hash_val = self.hash_code(key)
        if self.table[hash_val] is None:
            # 數(shù)據(jù)不存在
            return -1

        if self.table[hash_val].value == key:
            # 首結點就是要找的數(shù)據(jù)
            return self.table[hash_val].value

        # 移動指針
        move = self.table[hash_val].next_node
        while move.value != key and move is not None:
            move = move.next_node
        if move is None:
            return -1
        else:
            return move.value

    def hash_code(self, key):
        # 這里僅為說明問題，13 的選擇是固定的
        hash_val = key % 13
        return hash_val


# 原始數(shù)據(jù)
src_nums = [25, 78, 56, 32, 88, 26, 39, 82, 14]
# 哈希對象
hash_table = HashTable()
# 把數(shù)據(jù)添加到哈希表中
for n in src_nums:
    hash_table.put(n, n)
# 輸出哈希表中的首結點數(shù)據(jù)
for i in hash_table.table:
    if i is not None:
        print(i.value,end=" ")
print("\n-------------查詢-----------")
print(hash_table.get(26))
'''
輸出結果：
78 14 56 32 88 25 
-------------查詢-----------
26
'''

3.總結

哈希表是一種高級數(shù)據(jù)結構，其存儲、查詢性能非常好，在不考慮哈希哈希算法和哈希沖突的時間復雜度情況下，哈希查找時間復雜度可以達到常量級，成為很多實際應用場景下的首選。

研究哈希表，著重點就是搞清楚哈希算法以及如何解決哈希沖突。在算法的世界時，沒有固定的模式，開發(fā)者可以根據(jù)自己的需要自行設計哈希算法。

以上就是一文詳解Python中哈希表的使用的詳細內(nèi)容，更多關于Python哈希表的資料請關注腳本之家其它相關文章！

最新評論