查找三哈希表的查找

時間 2019-11-17

原文原文鏈接

要點

哈希表和哈希函數html

在記錄的存儲位置和它的關鍵字之間是創建一個肯定的對應關係（映射函數），使每一個關鍵字和一個存儲位置能惟一對應。這個映射函數稱爲哈希函數，根據這個原則創建的表稱爲哈希表(Hash Table)，也叫散列表。程序員

以上描述，若是經過數學形式來描述就是：算法

若查找關鍵字爲 key，則其值存放在 f(key) 的存儲位置上。由此，不需比較即可直接取得所查記錄。數據結構

注：哈希查找與線性表查找和樹表查找最大的區別在於，不用數值比較。dom

衝突ide

若 key1 ≠ key2 ，而 f(key1) = f(key2)，這種狀況稱爲衝突(Collision)。函數

根據哈希函數f(key)和處理衝突的方法將一組關鍵字映射到一個有限的連續的地址集（區間）上，並以關鍵字在地址集中的「像」做爲記錄在表中的存儲位置，這一映射過程稱爲構造哈希表。this

構造哈希表這個場景就像汽車找停車位，若是車位被人佔了，只能找空的地方停。spa

構造哈希表

由以上內容可知，哈希查找自己其實不費吹灰之力，問題的關鍵在於如何構造哈希表和處理衝突。設計

常見的構造哈希表的方法有 5 種：

（1）直接定址法

說白了，就是小學時學過的一元一次方程。

即 f(key) = a * key + b。其中，a和b 是常數。

（2）數字分析法

假設關鍵字是R進制數（如十進制）。而且哈希表中可能出現的關鍵字都是事先知道的，則可選取關鍵字的若干數位組成哈希地址。

選取的原則是使獲得的哈希地址儘可能避免衝突，即所選數位上的數字儘量是隨機的。

（3）平方取中法

取關鍵字平方後的中間幾位爲哈希地址。一般在選定哈希函數時不必定能知道關鍵字的所有狀況，僅取其中的幾位爲地址不必定合適；

而一個數平方後的中間幾位數和數的每一位都相關，由此獲得的哈希地址隨機性更大。取的位數由表長決定。

（4）除留餘數法

取關鍵字被某個不大於哈希表表長 m 的數 p 除後所得的餘數爲哈希地址。

即 f(key) = key % p (p ≤ m)

這是一種最簡單、最經常使用的方法，它不只能夠對關鍵字直接取模，也可在摺疊、平方取中等運算以後取模。

注意：p的選擇很重要，若是選的很差，容易產生衝突。根據經驗，通常狀況下能夠選p爲素數。

（5）隨機數法

選擇一個隨機函數，取關鍵字的隨機函數值爲它的哈希地址，即 f(key) = random(key)。

一般，在關鍵字長度不等時採用此法構造哈希函數較爲恰當。

解決衝突

設計合理的哈希函數能夠減小衝突，但不能徹底避免衝突。

因此須要有解決衝突的方法，常見有兩類

（1）開放定址法

若是兩個數據元素的哈希值相同，則在哈希表中爲後插入的數據元素另外選擇一個表項。
當程序查找哈希表時，若是沒有在第一個對應的哈希表項中找到符合查找要求的數據元素，程序就會繼續日後查找，直到找到一個符合查找要求的數據元素，或者遇到一個空的表項。

例子

若要將一組關鍵字序列 {1, 9, 25, 11, 12, 35, 17, 29} 存放到哈希表中。

採用除留餘數法構造哈希表；採用開放定址法處理衝突。

不妨設選取的p和m爲13，由 f(key) = key % 13 能夠獲得下表。

須要注意的是，在上圖中有兩個關鍵字的探查次數爲 2 ，其餘都是1。

這個過程是這樣的：

a. 12 % 13 結果是12，而它的前面有個 25 ，25 % 13 也是12，存在衝突。

咱們使用開放定址法 (12 + 1) % 13 = 0，沒有衝突，完成。

b. 35 % 13 結果是 9，而它的前面有個 9，9 % 13也是 9，存在衝突。

咱們使用開放定址法 (35 + 1) % 13 = 10，沒有衝突，完成。

（2）拉鍊法

將哈希值相同的數據元素存放在一個鏈表中，在查找哈希表的過程當中，當查找到這個鏈表時，必須採用線性查找方法。

在這種方法中，哈希表中每一個單元存放的再也不是記錄自己，而是相應同義詞單鏈表的頭指針。

例子

若是對開放定址法例子中提到的序列使用拉鍊法，獲得的結果以下圖所示：

實現一個哈希表

假設要實現一個哈希表，要求

a. 哈希函數採用除留餘數法，即 f(key) = key % p (p ≤ m)

b. 解決衝突採用開放定址法，即 f₂(key) = (f(key)+i) % size (p ≤ m)

（1）定義哈希表的數據結構

class HashTable {
     public int key = 0; // 關鍵字
     public int data = 0; // 數值
     public int count = 0; // 探查次數
}

（2）在哈希表中查找關鍵字key

根據設定的哈希函數，計算哈希地址。若是出現地址衝突，則按設定的處理衝突的方法尋找下一個地址。

如此反覆，直到不衝突爲止（查找成功）或某個地址爲空（查找失敗）。

/**
* 查找哈希表
* 構造哈希表採用除留取餘法，即f(key) = key mod p (p ≤ size)
* 解決衝突採用開放定址法，即f2(key) = (f(key) + i) mod p (1 ≤ i ≤ size-1)
* ha爲哈希表，p爲模，size爲哈希表大小，key爲要查找的關鍵字
*/
public int searchHashTable(HashTable[] ha, int p, int size, int key) {
     int addr = key % p; // 採用除留取餘法找哈希地址

     // 若發生衝突，用開放定址法找下一個哈希地址
     while (ha[addr].key != NULLKEY && ha[addr].key != key) {
        addr = (addr + 1) % size;
    }

     if (ha[addr].key == key) {
         return addr; // 查找成功
    } else {
         return FAILED; // 查找失敗
    }
}

（3）刪除關鍵字爲key的記錄

在採用開放定址法處理衝突的哈希表上執行刪除操做，只能在被刪記錄上作刪除標記，而不能真正刪除記錄。

找到要刪除的記錄，將關鍵字置爲刪除標記DELKEY。

public int deleteHashTable(HashTable[] ha, int p, int size, int key) {
     int addr = 0;
    addr = searchHashTable(ha, p, size, key);
     if (FAILED != addr) { // 找到記錄
        ha[addr].key = DELKEY; // 將該位置的關鍵字置爲DELKEY
         return SUCCESS;
    } else {
         return NULLKEY; // 查找不到記錄，直接返回NULLKEY
    }
}

（4）插入關鍵字爲key的記錄

將待插入的關鍵字key插入哈希表
先調用查找算法，若在表中找到待插入的關鍵字，則插入失敗；
若在表中找到一個開放地址，則將待插入的結點插入到其中，則插入成功。

public void insertHashTable(HashTable[] ha, int p, int size, int key) {
     int i = 1;
     int addr = 0;
    addr = key % p; // 經過哈希函數獲取哈希地址
     if (ha[addr].key == NULLKEY || ha[addr].key == DELKEY) { // 若是沒有衝突，直接插入
        ha[addr].key = key;
        ha[addr].count = 1;
    } else { // 若是有衝突，使用開放定址法處理衝突
         do {
            addr = (addr + 1) % size; // 尋找下一個哈希地址
            i++;
        } while (ha[addr].key != NULLKEY && ha[addr].key != DELKEY);

        ha[addr].key = key;
        ha[addr].count = i;
    }
}

（5）創建哈希表

先將哈希表中各關鍵字清空，使其地址爲開放的，而後調用插入算法將給定的關鍵字序列依次插入。

public void createHashTable(HashTable[] ha, int[] list, int p, int size) {
     int i = 0;

     // 將哈希表中的全部關鍵字清空
     for (i = 0; i < ha.length; i++) {
        ha[i].key = NULLKEY;
        ha[i].count = 0;
    }

     // 將關鍵字序列依次插入哈希表中
     for (i = 0; i < list.length; i++) {
         this.insertHashTable(ha, p, size, list[i]);
    }
}

完整代碼

  1 class HashTable {
  2      public int key = 0; // 關鍵字
  3      public int data = 0; // 數值
  4      public int count = 0; // 探查次數
  5 }
  6
  7 public class HashSearch {
  8
  9      private final static int MAXSIZE = 20;
10      private final static int NULLKEY = 1;
11      private final static int DELKEY = 2;
12      private final static int SUCCESS = 0;
13      private final static int FAILED = 0xFFFFFFFF;
14
15      /**
16      * 查找哈希表
17      * 構造哈希表採用除留取餘法，即f(key) = key mod p (p ≤ size)
18      * 解決衝突採用開放定址法，即f2(key) = (f(key) + i) mod p (1 ≤ i ≤ size-1)
19      * ha爲哈希表，p爲模，size爲哈希表大小，key爲要查找的關鍵字
20       */
21      public int searchHashTable(HashTable[] ha, int p, int size, int key) {
22          int addr = key % p; // 採用除留取餘法找哈希地址
23
24          // 若發生衝突，用開放定址法找下一個哈希地址
25          while (ha[addr].key != NULLKEY && ha[addr].key != key) {
26             addr = (addr + 1) % size;
27         }
28
29          if (ha[addr].key == key) {
30              return addr; // 查找成功
31         } else {
32              return FAILED; // 查找失敗
33         }
34     }
35
36      /**
37      * 刪除哈希表中關鍵字爲key的記錄
38      * 找到要刪除的記錄，將關鍵字置爲刪除標記DELKEY
39       */
40      public int deleteHashTable(HashTable[] ha, int p, int size, int key) {
41          int addr = 0;
42         addr = searchHashTable(ha, p, size, key);
43          if (FAILED != addr) { // 找到記錄
44             ha[addr].key = DELKEY; // 將該位置的關鍵字置爲DELKEY
45              return SUCCESS;
46         } else {
47              return NULLKEY; // 查找不到記錄，直接返回NULLKEY
48         }
49     }
50
51      /**
52      * 將待插入的關鍵字key插入哈希表
53      * 先調用查找算法，若在表中找到待插入的關鍵字，則插入失敗；
54      * 若在表中找到一個開放地址，則將待插入的結點插入到其中，則插入成功。
55       */
56      public void insertHashTable(HashTable[] ha, int p, int size, int key) {
57          int i = 1;
58          int addr = 0;
59         addr = key % p; // 經過哈希函數獲取哈希地址
60          if (ha[addr].key == NULLKEY || ha[addr].key == DELKEY) { // 若是沒有衝突，直接插入
61             ha[addr].key = key;
62             ha[addr].count = 1;
63         } else { // 若是有衝突，使用開放定址法處理衝突
64              do {
65                 addr = (addr + 1) % size; // 尋找下一個哈希地址
66                 i++;
67             } while (ha[addr].key != NULLKEY && ha[addr].key != DELKEY);
68
69             ha[addr].key = key;
70             ha[addr].count = i;
71         }
72     }
73
74      /**
75      * 建立哈希表
76      * 先將哈希表中各關鍵字清空，使其地址爲開放的，而後調用插入算法將給定的關鍵字序列依次插入。
77       */
78      public void createHashTable(HashTable[] ha, int[] list, int p, int size) {
79          int i = 0;
80
81          // 將哈希表中的全部關鍵字清空
82          for (i = 0; i < ha.length; i++) {
83             ha[i].key = NULLKEY;
84             ha[i].count = 0;
85         }
86
87          // 將關鍵字序列依次插入哈希表中
88          for (i = 0; i < list.length; i++) {
89              this.insertHashTable(ha, p, size, list[i]);
90         }
91     }
92
93      /**
94      * 輸出哈希表
95       */
96      public void displayHashTable(HashTable[] ha) {
97          int i = 0;
98         System.out.format("pos:\t", "pos");
99          for (i = 0; i < ha.length; i++) {
100             System.out.format("%4d", i);
101         }
102         System.out.println();
103
104         System.out.format("key:\t");
105          for (i = 0; i < ha.length; i++) {
106              if (ha[i].key != NULLKEY) {
107                 System.out.format("%4d", ha[i].key);
108             } else {
109                 System.out.format("    ");
110             }
111         }
112         System.out.println();
113
114         System.out.format("count:\t");
115          for (i = 0; i < ha.length; i++) {
116              if (0 != ha[i].count) {
117                 System.out.format("%4d", ha[i].count);
118             } else {
119                 System.out.format("    ");
120             }
121         }
122         System.out.println();
123     }
124
125      public static void main(String[] args) {
126          int[] list = { 3, 112, 245, 27, 44, 19, 76, 29, 90 };
127         HashTable[] ha = new HashTable[MAXSIZE];
128          for ( int i = 0; i < ha.length; i++) {
129             ha[i] = new HashTable();
130         }
131
132         HashSearch search = new HashSearch();
133         search.createHashTable(ha, list, 19, MAXSIZE);
134         search.displayHashTable(ha);
135
136     }
137
138 }

哈希查找之JAVA實現

參考資料

《數據結構習題與解析》（B級第3版）

相關閱讀

歡迎閱讀 程序員的內功——算法 系列