查詢三 雜湊表的查詢
雜湊表和雜湊函式
在記錄的儲存位置和它的關鍵字之間是建立一個確定的對應關係（對映函式），使每個關鍵字和一個儲存位置能唯一對應。這個對映函式稱為雜湊函式，根據這個原則建立的表稱為雜湊表(Hash Table)，也叫散列表。
以上描述，如果通過數學形式來描述就是：
若查詢關鍵字為 key，則其值存放在 f(key) 的儲存位置上。由此，不需比較便可直接取得所查記錄。
注：雜湊查詢與線性表查詢和樹表查詢最大的區別在於，不用數值比較。
衝突
若 key1 ≠ key2 ，而 f(key1) = f(key2)，這種情況稱為衝突(Collision)。
根據雜湊函式f(key)和處理衝突的方法將一組關鍵字對映到一個有限的連續的地址集（區間）上，並以關鍵字在地址集中的“像”作為記錄在表中的儲存位置，這一對映過程稱為構造雜湊表
構造雜湊表這個場景就像汽車找停車位，如果車位被人佔了，只能找空的地方停。
構造雜湊表
由以上內容可知，雜湊查詢本身其實不費吹灰之力，問題的關鍵在於如何構造雜湊表和處理衝突。
常見的構造雜湊表的方法有 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，存在衝突。
我們使用開放定址法 (9 + 1) % 13 = 10，沒有衝突，完成。（2）拉鍊法
將雜湊值相同的資料元素存放在一個連結串列中，在查詢雜湊表的過程中，當查詢到這個連結串列時，必須採用線性查詢方法。在這種方法中，雜湊表中每個單元存放的不再是記錄本身，而是相應同義詞單鏈表的頭指標。
例子
如果對開放定址法例子中提到的序列使用拉鍊法，得到的結果如下圖所示：
實現一個雜湊表假設要實現一個雜湊表，要求
a. 雜湊函式採用除留餘數法，即 f(key) = key % p (p ≤ m)
b. 解決衝突採用開放定址法，即 f2(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版） 相關閱讀 歡迎閱讀 系列