資料結構第十一節(散列表)
阿新 • • 發佈：2020-12-16
#散列表
##什麼是散列表
散列表（Hash table，也叫雜湊表），是根據鍵（Key）而直接訪問在記憶體儲存位置的資料結構。也就是說，它通過計算一個關於鍵值的函式，將所需查詢的資料對映到表中一個位置來訪問記錄，這加快了查詢速度。這個對映函式稱做雜湊函式，存放記錄的陣列稱做散列表。
舉一個簡單的例子，假設我們有5個數字，他們的個位都不相同，如何把這5個數字儲存起來，而且在查詢這個數字時超級快呢。在這個簡單的例子中由於它們的個位數都不相同，故我們對這些數字對10求餘取個位數，放在對應下標的的數組裡。（{54，76，31，92，109}這個集合，我們將54儲存到array[4]，將76儲存到array[6]，將31儲存到array[1]，將92儲存到array[2]，將54儲存到array[9]）
上面是一個極其簡單和特殊的例子，在正常情況下我們很難遇到上面的簡單情況，多數的情況，會出現衝突。對兩個不同的數，如果計算到了同樣的鍵值，該如何處理？
所以現在構造一個好用的散列表，最重要的是做好以下兩件事情：
1. 設計一個"好"的雜湊函式來計算Key值。(好的雜湊函式應儘可能避免衝突的出現，而且計算時應儘可能簡潔快速)
2. 出現了衝突時又該如何調整插入元素。
##散列表的實現
###雜湊函式的實現
雜湊函式的實現主要有以下幾種方法:
1. 直接定址法：取關鍵字或關鍵字的某個線性函式值為雜湊地址。即$hash(k)=k$或$hash(k)=a*k+b$，其中$a$,$b$為常數（這種雜湊函式叫做自身函式）
2. 數字分析法：假設關鍵字是以r為基的數，並且雜湊表中可能出現的關鍵字都是事先知道的，則可取關鍵字的若干數位組成雜湊地址。
3. 平方取中法：取關鍵字平方後的中間幾位為雜湊地址。通常在選定雜湊函式時不一定能知道關鍵字的全部情況，取其中的哪幾位也不一定合適，而一個數平方後的中間幾位數和數的每一位都相關，由此使隨機分佈的關鍵字得到的雜湊地址也是隨機的。取的位數由表長決定。
4. 摺疊法：將關鍵字分割成位數相同的幾部分（最後一部分的位數可以不同）， 然後取這幾部分的疊加和（捨去進位）作為雜湊地址。
5. 隨機數法
6. 除留餘數法：取關鍵字被某個不大於散列表表長m的數p除後所得的餘數為雜湊地址。即$hash(k)=k$ $mod$ $p$。不僅可以對關鍵字直接取模，也可在摺疊法、平方取中法等運算之後取模。對p的選擇很重要，一般取素數或m，若p選擇不好，容易產生衝突。
以上方法精是對數字型別的操作，對字串型別的資料，可以選擇通過相加或者進位轉化成數字後，再執行上面的計算方法。
###散列表解決衝突的方法
解決衝突主要有兩種方式，一種是鏈地址法，另一種為開放地址法。
對於第1種方法，是將有共同鍵值的元素串成一條連結串列的思路。而第2種方法，如果該位置已經有元素了，則換一個地方，當然為了查詢時還能找得到他，肯定是不可以隨便放的，需要按照指定的增長序列{$k_1,k_2,k_3,k_4...k_n$}，依次探查離自己距離自己$k_1,k_2,k_3,k_4...k_n$的地方是否有空。
增量序列的不同，提供了不同的解決衝突方法。常用的方法有三種，分別為線性探測和平方探測和雙雜湊。
使用線性探測時，如果出現衝突那就向後錯一位，看是否有空，直到找到空的（有點像上廁所找坑）；使用平方探測時，每次向前向後$d_i^2$位。使用這2種方法容易會造成聚集。聚集（Cluster，也翻譯做“堆積”）的意思是，在函式地址的表中，雜湊函式的結果不均勻地佔據表的單元，形成區塊，造成線性探測產生一次聚集（primary clustering）和平方探測的二次聚集（secondary clustering），雜湊到區塊中的任何關鍵字需要查詢多次試選單元才能插入表中，解決衝突，造成時間浪費。對於開放定址法，聚集會造成效能的災難性損失，是必須避免的。總體來說使用平方探測要比使用線性探測出現聚集的概率小。
使用雙雜湊時，如果出現衝突，就用當前的鍵值作為引數用另一個雜湊函式計算鍵值，直到找到空位。
###雜湊表程式碼實現
```cpp
#include
#include
#include
#define null -99999
#define notFound -1
using namespace std;
typedef struct CellNode* Cell;
struct CellNode
{
int Data;
};
//雜湊表結構體
typedef struct HashTlNode* HashTable;
struct HashTlNode
{
int TableSize;
Cell Table;
};
//判斷一個數是否為素數
bool isPrime(int n) {
if (n < 2) {
return false;
}
else if (n == 2 || n == 3) {
return true;
}
else if(n%6==1||n%6==5){
double p = sqrt(n);
for (int i = 2; i <= p; i++)
{
if (n % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
//求一個距離最小的素數
int NextPrime(int n) {
//如果N已經是素數,那麼他填滿了，在查詢不存在的數時一定會死環
//所以我們去找下一個素數
if (isPrime(n)) {
n++;
}
//必須是素數,而且可以寫成4k+3的形式，這樣保證平方探測時不會出現死環。
while (!(isPrime(n)&&n%4==3))
{
n++;
}
return n;
}
//建立空的雜湊表
HashTable CreatHashTable(int TableSize) {
HashTable H = (HashTable)malloc(sizeof(struct HashTlNode));
H->TableSize = NextPrime(TableSize);
H->
#include
#include
#include
#include
#define notFound -1
typedef struct CellNode* Cell;
struct CellNode
{
char Data[12];
int isEmpty;
int time;
};
//雜湊表結構體
typedef struct HashTlNode* HashTable;
struct HashTlNode
{
int TableSize;
Cell Table;
};
//判斷一個數是否為素數
bool isPrime(int n) {
if (n < 2) {
return false;
}
else if (n == 2 || n == 3) {
return true;
}
else if (n % 6 == 1 || n % 6 == 5) {
double p = sqrt(n);
for (int i = 2; i <= p; i++)
{
if (n % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
//求一個距離最小的素數
int NextPrime(int n) {
//如果N已經是素數,那麼他填滿了，在查詢不存在的數時一定會死環
//所以我們去找下一個素數
if (isPrime(n)) {
n++;
}
//必須是素數,而且可以寫成4k+3的形式，這樣保證平方探測時不會出現死環。
while (!(isPrime(n) && n % 4 == 3))
{
n++;
}
return n;
}
//建立空的雜湊表
HashTable CreatHashTable(int TableSize) {
HashTable H = (HashTable)malloc(sizeof(struct HashTlNode));
H-> $(size^2+2*m*size+m^2)$ $mod$ $size$ => $m^2$ $mod$ $size$。因為前兩項中包含size，故對他們求於一定為0。到現在我們證明了，對於數m，n(m + n = size 且 m，n < size)，它們對應的平方探測值相同。也就是，平方探測值關於size/2對稱。
```cpp
#include
#include
#include
#include
#define null -99999
#define notFound -1
using namespace std;
typedef struct CellNode* Cell;
struct CellNode
{
int Data;
};
//雜湊表結構體
typedef struct HashTlNode* HashTable;
struct HashTlNode
{
int TableSize;
Cell Table;
};
//判斷一個數是否為素數
bool isPrime(int n) {
if (n < 2) {
return false;
}
else if (n == 2 || n == 3) {
return true;
}
else if (n % 6 == 1 || n % 6 == 5) {
double p = sqrt(n);
for (int i = 2; i <= p; i++)
{
if (n % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
//求一個距離最小的素數
int NextPrime(int n) {
while (!isPrime(n))
{
n++;
}
return n;
}
//建立空的雜湊表
HashTable CreatHashTable(int TableSize) {
HashTable H = (HashTable)malloc(sizeof(struct HashTlNode));
H->
#include
#include
#include
#include
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
typedef struct CellNode* Cell;
struct CellNode
{
char Data[11];
int isEmpty;
char passw[17];
};
//雜湊表結構體
typedef struct HashTlNode* HashTable;
struct HashTlNode
{
int TableSize;
Cell Table;
};
//判斷一個數是否為素數
bool isPrime(int n) {
if (n < 2) {
return false;
}
else if (n == 2 || n == 3) {
return true;
}
else if (n % 6 == 1 || n % 6 == 5) {
double p = sqrt(n);
for (int i = 2; i <= p; i++)
{
if (n % i == 0) {
return false;
}
}
return true;
}
else {
return false;
}
}
//求一個距離最小的素數
int NextPrime(int n) {
//如果N已經是素數,那麼他填滿了，在查詢不存在的數時一定會死環
//所以我們去找下一個素數
if (isPrime(n)) {
n++;
}
//必須是素數,而且可以寫成4k+3的形式，這樣保證平方探測時不會出現死環。
while (!(isPrime(n) && n % 4 == 3))
{
n++;
}
return n;
}
//建立空的雜湊表
HashTable CreatHashTable(int TableSize) {
HashTable H = (HashTable)malloc(sizeof(struct HashTlNode));
H->TableSize = NextPrime(TableSize);
H->Table = (Cell)malloc(sizeof(struct CellNode) * H->TableSize);
for (int i = 0; i < H->TableSize; i++)
{
H->Table[i].isEmpty = 1;
}
return H;
}
//雜湊函式
int HashFunction(char key[], HashTable H) {
char result[7];
strncpy(result, key, 6);
return atoi(result);
}
//插入
void Insert(char key[], char pass[], HashTable H) {
int currentPos, NewPos;
int Cnum = 0;
currentPos = NewPos = HashFunction(key, H);
//迴圈結束條件，找到元素或者找不到（找到了未被使用的空間）。
while (H->Table[NewPos].isEmpty != 1)
{
//判斷是否相同，相同直接跳出
if (strcmp(key, H->Table[NewPos].Data) == 0) {
break;
}
else if (++Cnum % 2 != 0) {
NewPos = currentPos + (Cnum + 1) * (Cnum + 1) / 4;
while (NewPos >= H->TableSize)
{
NewPos -= H->TableSize;
}
}
else {
NewPos = currentPos - Cnum * Cnum / 4;
while (NewPos < 0)
{
NewPos += H->TableSize;
}
}
}
//沒有找到，建立新的
if (H->Table[NewPos].isEmpty == 1) {
H->Table[NewPos].isEmpty = 0;
strcpy(H->Table[NewPos].Data, key);
strcpy(H->Table[NewPos].passw, pass);
printf("New: OK\n");
}
else {
printf("ERROR: Exist\n");
}
}
int stringcmp(const char pass1[], const char pass2[]) {
for (int i = 0; i < max(strlen(pass1),strlen(pass2)); i++)
{
if (pass1[i] != pass2[i]) {
return 0;
}
}
return 1;
}
//登陸
void Login(char key[], char pass[], HashTable H) {
int currentPos, NewPos;
int Cnum = 0;
currentPos = NewPos = HashFunction(key, H);
//迴圈結束條件，找到元素或者找不到（找到了未被使用的空間）。
while (H->Table[NewPos].isEmpty != 1)
{
//判斷是否相同，相同直接跳出
if (strcmp(key, H->Table[NewPos].Data) == 0) {
break;
}
else if (++Cnum % 2 != 0) {
NewPos = currentPos + (Cnum + 1) * (Cnum + 1) / 4;
while (NewPos >= H->TableSize)
{
NewPos -= H->TableSize;
}
}
else {
NewPos = currentPos - Cnum * Cnum / 4;
while (NewPos < 0)
{
NewPos += H->TableSize;
}
}
}
//沒有找到
if (H->Table[NewPos].isEmpty == 1) {
printf("ERROR: Not Exist\n");
}
else {
if (stringcmp(H->Table[NewPos].passw,pass)) {
printf("Login: OK\n");
}
else {
printf("ERROR: Wrong PW\n");
}
}
}
int main() {
int n;
char id[11];
char pas[17];
char op = ' ';
scanf("%d", &n);
HashTable H = CreatHashTable(1000000);
for (int i = 0; i < n; i++)
{
scanf("\n%c", &op);
scanf("%s", id);
scanf("%s", pas);
if (op == 'L') {
Login(id, pas, H);
int p = 0;
}
else if (op == 'N') {
Insert(id, pas, H);
int p = 0;
}
}
return 0;
}
```
###11-雜湊4 Hashing - Hard Version (30point(s))
Given a hash table of size N, we can define a hash function H(x)=x%N. Suppose that the linear probing is used to solve collisions, we can easily obtain the status of the hash table with a given sequence of input numbers.
However, now you are asked to solve the reversed problem: reconstruct the input sequence from the given status of the hash table. Whenever there are multiple choices, the smallest number is always taken.
**Input Specification:**
Each input file contains one test case. For each test case, the first line contains a positive integer N (≤1000), which is the size of the hash table. The next line contains N integers, separated by a space. A negative integer represents an empty cell in the hash table. It is guaranteed that all the non-negative integers are distinct in the table.
**Output Specification:**
For each test case, print a line that contains the input sequence, with the numbers separated by a space. Notice that there must be no extra space at the end of each line.
**Sample Input:**
>11
33 1 13 12 34 38 27 22 32 -1 21
**Sample Output:**
>1 13 12 21 33 34 38 27 22 32
**題解：**
題目的大概意思是，先讀入一個 n，然後傳給你一個大小為N的散列表，如果散列表中的元素為負值，說明該位置是空的，而且該散列表在建立時，用的是散列表大小求餘的雜湊函式，解決衝突的方式為線性探索。
要求輸出散列表的插入順序，數字小的優先靠前。
整個題目可以用一個拓撲排序，再加上一個優先佇列(最小堆)來解決，不過優先佇列比較麻煩而且該題資料量不大，就直接線性掃描了。對於一個位置是否對另一個位置會造成影響(也就是說這個位置的存在，導致了元素衝突)，可以通過下面的方式來判別，在初始時我們有計算過它的初始偏移量p = i - t % n， p大於雜湊表尺寸時，p-=n。在我們輸出一個元素後，迴圈遍歷計算該元素到其他所有元素的距離，如果這個距離小於等於初始偏移量，就將該位置的元素偏移量減1。
```cpp
#include
#include
#include
#include
#include
#define INFINITY 999999
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
typedef struct CellNode Cell;
struct CellNode
{
int Data;
int pos;
int firstpos;
};
int main() {
int n, t, invalid = 0;
scanf("%d", &n);
vector| v(n);
for (int i = 0; i < n; i++)
{
scanf("%d", &t);
v[i].Data = t;
if (t < 0) {
v[i].firstpos = -1;
v[i].pos = -1;
invalid++;
}
else {
int p = i - t % n;
if (p < 0) {
p += n;
}
v[i].firstpos = p;
v[i].pos = p;
}
}
//判斷是否為第一個輸出，是前面不輸出空格
bool isf = true;
for (int i = 0; i < n-invalid; i++)
{
int p=0, minnum = INFINITY;
//掃描全序列，找偏移為0且最小的點。
for (int j = 0; j < n; j++)
{
if (v[j].pos == 0 && v[j].Data < minnum) {
minnum = v[j].Data;
p = j;
}
}
//輸出且刪除該點
if (isf) {
printf("%d", minnum);
isf = false;
}
else {
printf(" %d", minnum);
}
//因為p點而偏移的數，偏移量減去1
for (int j = 0; j < n; j++)
{
int dis = j - p;
if (dis < 0) {
dis += n;
}
//因為p點而偏移
if (v[j].firstpos >= dis) {
v[j].pos--;
}
}
v[p].pos = -1;
}
printf("\n");
return 0
|