雜湊表（雜湊表）詳解

雜湊表（Hash table，也叫雜湊表），是根據關鍵碼值(Key value)而直接進行訪問的資料結構。也就是說，它通過把關鍵碼值對映到表中一個位置來訪問記錄，以加快查詢的速度。這個對映函式叫做雜湊函式，存放記錄的陣列叫做雜湊表。

順序搜尋以及二叉樹搜尋樹中，元素儲存位置和元素各關鍵碼之間沒有對應的關係，因此在查詢一個元素時，必須要經過關鍵碼的多次比較。搜尋的效率取決於搜尋過程中元素的比較次數。

理想的搜尋方法：可以不經過任何比較，一次直接從表中得到要搜尋的元素。
如果構造一種儲存結構，通過某種函式(hashFunc)使元素的儲存位置與它的關鍵碼之間能夠建立一一對映的關係，那麼在查詢時通過該函式可以很快找到該元素。

當向該結構中：
插入元素時：根據待插入元素的關鍵碼，以此函式計算出該元素的儲存位置並按此位置進行存放
搜尋元素時：對元素的關鍵碼進行同樣的計算，把求得的函式值當做元素的儲存位置，在結構中按此位置取元素比較，若關鍵碼相等，則搜尋成功
該方式即為雜湊(雜湊)方法，雜湊方法中使用的轉換函式稱為雜湊(雜湊)函式，構造出來的結構稱為雜湊表(Hash Table)(或者
稱雜湊表)
例如：資料集合{180，750，600，430，541，900，460}

用該方法進行搜尋不必進行多次關鍵碼的比較，因此搜尋的速度比較快
問題：按照上述雜湊方式，向集合中插入元素443，會出現什麼問題？
這回就要引出一個概念叫雜湊衝突：對於兩個資料元素的關鍵字 和 （i !=j），有 ！= ，但有：HashFun(Ki) == HashFun(Kj)即不同關鍵字通過相同雜湊哈數計算出相同的雜湊地址，該種現象稱為雜湊衝突或雜湊碰撞。把具有不同關鍵碼而具有相同雜湊地址的資料元素稱為“同義詞”。

解決雜湊衝突兩種常見的方法是：閉雜湊和開雜湊
閉雜湊：
閉雜湊：也叫開放地址法，當發生雜湊衝突時，如果雜湊表未被裝滿，說明在雜湊表中必然還有空位置，那麼可以把key存放到表中“下一個” 空位中去
那如何尋找下一個空餘位置？ 這裡就要用到兩種方法：線性探測和二次探測
線性探測
設關鍵碼集合為{37, 25, 14, 36, 49, 68, 57, 11}，雜湊表為HT[12]，表的大小m = 12，假設雜湊函式為：Hash(x) = x %p（p = 11，是最接近m的質數），就有：
Hash(37) = 4
Hash(25) = 3
Hash(14) = 3
Hash(36) = 3
Hash(49) = 5
Hash(68) = 2
Hash(57) = 2
Hash(11) = 0
其中25，14，36以及68，57發生雜湊衝突，一旦衝突必須要找出下一個空餘位置
線性探測找的處理為：從發生衝突的位置開始，依次繼續向後探測，直到找到空位置為止
【插入】
1）. 使用雜湊函式找到待插入元素在雜湊表中的位置
2）. 如果該位置中沒有元素則直接插入新元素；如果該位置中有元素且和待插入元素相同，則不用插入；如果該位置中有元素但不是待插入元素則發生雜湊衝突，使用線性探測找到下一個空位置，插入新元素；
採用線性探測，實現起來非常簡單，缺陷是：
一旦發生雜湊衝突，所有的衝突連在一起，容易產生資料“堆積”，即：不同關鍵碼佔據了可利用的空位置，使得尋找某關鍵碼的位置需要許多次比較，導致搜尋效率降低。 如何緩解呢？ 引入新概念負載因子（負載因子的應用在下一篇博文）和二次探測

二次探測
發生雜湊衝突時，二次探查法在表中尋找“下一個”空位置的公式為：
Hi= (Ho + i^2) % m,Hi = (Ho -i^2 ) % m, i = 1,2,3…，(m-1)/Ho. 是通過雜湊函式Hash(x)對元素的關鍵碼 key 進行計算得到的位置，m是表的大小假設陣列的關鍵碼為37, 25, 14, 36, 49, 68, 57, 11，取m = 19，這樣可設定為HT[19]，採用雜湊函式Hash(x) = x % 19，則：
Hash(37)=18
Hash(25)=6
Hash(14)=14
Hash(36)=17
Hash(49)=11
Hash(68)=11
Hash(57)=0
Hash(11)=11
採用二次探測處理雜湊衝突：

研究表明：當表的長度為質數且表裝載因子a不超過0.5時，新的表項一定能夠插入，而且任何一個位置都不會被探查兩次。因此只要表中有一半的空位置，就不會存在表滿的問題。在搜尋時可以不考慮表裝滿的情況，但在插入時必須確保表的裝載因子a不超過0.5；如果超出必須考慮增容

開雜湊法又叫鏈地址法(開鏈法)。（將在下一篇博文中寫出）
開雜湊法：首先對關鍵碼集合用雜湊函式計算雜湊地址，具有相同地址的關鍵碼歸於同一子集合，每一個子集合稱為一個桶，各個桶中的元素通過一個單鏈錶連結起來，各連結串列的頭結點儲存在雜湊表中。

設元素的關鍵碼為37, 25, 14, 36, 49, 68, 57, 11, 雜湊表為HT[12]，表的大小為12，雜湊函式為Hash(x) = x % 11
Hash(37)=4
Hash(25)=3
Hash(14)=3
Hash(36)=3
Hash(49)=5
Hash(68)=2
Hash(57)=2
Hash(11)=0
使用雜湊函式計算出每個元素所在的桶號，同一個桶的連結串列中存放雜湊衝突的元素。

通常，每個桶對應的連結串列結點都很少，將n個關鍵碼通過某一個雜湊函式，存放到雜湊表中的m個桶中，那麼每一個桶中連結串列的平均長度為。以搜尋平均長度為的連結串列代替了搜尋長度為 n 的順序表，搜尋效率快的多。
應用鏈地址法處理溢位，需要增設連結指標，似乎增加了儲存開銷。事實上：
由於開地址法必須保持大量的空閒空間以確保搜尋效率，如二次探查法要求裝載因子a <= 0.7，而表項所佔空間又比指標大的多，所以使用鏈地址法反而比開地址法節省儲存空間。

引起雜湊衝突的一個原因可能是：雜湊函式設計不夠合理。
雜湊函式設計原則：
.雜湊函式的定義域必須包括需要儲存的全部關鍵碼，而如果雜湊表允許有m個地址時，其值域必須在0到m-1之間
.雜湊函式計算出來的地址能均勻分佈在整個空間中
.雜湊函式應該比較簡單
下面簡單介紹了一些雜湊函式：
1.直接定址法
取關鍵字的某個線性函式為雜湊地址：Hash（Key）= A*Key + B
優點：簡單、均勻
缺點：需要事先知道關鍵字的分佈情況
適合查詢比較小且連續的情況
2.除留餘數法
設雜湊表中允許的地址數為m，取一個不大於m，但最接近或者等於m的質數p作為除數，按照雜湊函式：Hash(key) = key% p(p<=m),將關鍵碼轉換成雜湊地址3.平方取中法
假設關鍵字為1234，對它平方就是1522756，抽取中間的3位227作為雜湊地址；
再比如關鍵字為4321，對它平方就是18671041，抽取中間的3位671(或710)作為雜湊地址
平方取中法比較適合：不知道關鍵字的分佈，而位數又不是很大的情況
4.摺疊法
摺疊法是將關鍵字從左到右分割成位數相等的幾部分(最後一部分位數可以短些)，然後將這幾部分疊加求和，並按雜湊表表長，取後幾位作為雜湊地址摺疊法適合事先不需要知道關鍵字的分佈，適合關鍵字位數比較多的情況
5.隨機數法
選擇一個隨機函式，取關鍵字的隨機函式值為它的雜湊地址，即H(key) = random(key),其中random為隨機數函式通常應用於關鍵字長度不等時採用此法
6.數學分析法
設有n個d位數，每一位可能有r種不同的符號，這r種不同的符號在各位上出現的頻率不一定相同，可能在某些位上分佈比較均勻，每種符號出現的機會均等，在某些位上分佈不均勻只有某幾種符號經常出現。可根據雜湊表的大小，選擇其中各種符號分佈均勻的若干位作為雜湊地址。
例如：假設要儲存某家公司員工登記表，如果用手機號作為關鍵字，那麼極有可能前7位都是 相同的，那麼我們可以選擇後面的四位作為雜湊地址，如果這樣的抽取工作還容易出現 衝突，還可以對抽取出來的數字進行反轉(如1234改成4321)、右環位移(如1234改成4123)、左環移位、前兩數與後兩數疊加(如1234改成12+34=46)等方法
說了這麼多概念，來看看程式碼。
雜湊表的結構定義：

typedef int KeyType;
typedef int ValueType;

typedef enum Status
{
    EMPTY,
    EXIST,
    DELETE,
}Status;

typedef struct HashNode 
{
    KeyType _key;
    ValueType _value;
    Status _status;
}HashNode;

typedef struct HashTable
{
    HashNode *_table;
    size_t _size;
    size_t _N;
}HashTable;

雜湊表的初始化：

void HashTableInit(HashTable* ht) //初始化
{
     size_t i = 0;
     assert(ht);

     ht->_size = 0;
     ht->_N = HashTablePrime(0);
     ht->_table = (HashNode *)malloc(sizeof(HashNode)*ht->_N);
     assert(ht->_table);

     for (i=0; i<ht->_N; i++)
         ht->_table[i]._status = EMPTY;
}

雜湊函式：

KeyType HashFunc(KeyType key,size_t n)
{
    return key%n;
}

看看雜湊表的插入：（這裡處理雜湊衝突時採用線性探測，二次探測將在下一次部落格中寫出）
擴容時要特別注意，不能簡單的用malloc和realloc開出空間後直接付給雜湊表，一定記得擴容之後需要重新對映原表的所有值。

int HashTableInsert(HashTable* ht, KeyType key, ValueType value) //插入
{
    KeyType index = key;
    assert(ht);
    **if (ht->_N == ht->_size) //擴容
    {
        KeyType index;
        size_t newN = HashTablePrime(ht->_N);
        HashNode *tmp = (HashNode *)malloc(sizeof(HashNode)*newN);
        size_t i = 0;
        assert(tmp);
        //HashTablePrint(ht); //擴容除錯使用
        for (i=0; i<newN; i++)
            tmp[i]._status = EMPTY;
        for (i=0; i<ht->_N; i++)  //擴容之後把以前的表中元素重新對映
        {
            if (ht->_table[i]._status == EXIST) //原表存在時
            {
                index = HashFunc(ht->_table[i]._key,newN);
                if (tmp[index]._status == EXIST) //發生雜湊衝突時
                {
                    while (1)
                    {
                        index +=1;
                        if ((size_t)index > newN)
                            index %= newN;
                        if (tmp[index]._status != EXIST)
                            break;
                    }
                }

                tmp[index]._key = ht->_table[i]._key;
                tmp[index]._value = ht->_table[i]._value;
                tmp[index]._status = EXIST;
            }
            else
                tmp[i]._status = ht->_table[i]._status;
        }
        ht->_table = tmp;
        ht->_N = newN;
    }**

    index = HashFunc(key,ht->_N);

    if (ht->_table[index]._status == EXIST) //發生雜湊衝突
    {
        size_t i = 0;
        for (i=0; i<ht->_N;i++ )
        {
            if (ht->_table[index]._key == key)
                return -1;
            index +=i;
            if ((size_t)index >ht->_N)
                index %= ht->_N;
            if (ht->_table[index]._status != EXIST)
                break;
        }
    }

    ht->_table[index]._key = key;
    ht->_table[index]._value = value;
    ht->_table[index]._status = EXIST;
    ht->_size++;

    return 0;
}

雜湊表的查詢：

HashNode* HashTableFind(HashTable* ht, KeyType key) //查詢
{
    size_t i = 0;
    KeyType index = key;
    assert(ht);
    index = HashFunc(key,ht->_N);
    if (ht->_table[index]._key == key)
        return &(ht->_table[index]);
    else 
    {
        for (i=0; i<ht->_N; i++)
        {
            index += i;
            if (ht->_table[index]._key == key)
                return &(ht->_table[index]);
            if (ht->_table[index]._status == EMPTY)
                return NULL;
        }
    }

   return NULL;
}

雜湊表的刪除：

int HashTableRemove(HashTable* ht, KeyType key) //刪除
{
    assert(ht);
    if(HashTableFind(ht,key))
    {
        HashTableFind(ht,key)->_status = DELETE;
        return 0;
    }
    else
        return -1;

}

雜湊表的銷燬：（使用了malloc開闢空間必須手動銷燬）

void HashTableDestory(HashTable* ht)//銷燬
{
    free(ht->_table);
    ht->_table = NULL;
    ht->_size = 0;
    ht->_N = 0;
}

雜湊表的列印：

void HashTablePrint(HashTable *ht) //列印hash表
{
    size_t i = 0;
    assert(ht);
    for (i=0; i<ht->_N; i++)
    {
        if (ht->_table[i]._status == EXIST)
            printf("[%d]%d ",i,ht->_table[i]._key);
        else if (ht->_table[i]._status == EMPTY)
            printf("[%d]E ",i);
        else
            printf("[%d]D ",i);
    }
    printf("\n\n");
}

雜湊表整個在插入這塊會比較ran，要仔細理解，特別是擴容那塊。

測試案例：

void TestHashTable()
{
    HashTable ht;
    HashTableInit(&ht);

    HashTableInsert(&ht,53,0);
    HashTableInsert(&ht,54,0);
    HashTableInsert(&ht,55,0);
    HashTableInsert(&ht,106,0);
    HashTableInsert(&ht,1,0);
    HashTableInsert(&ht,15,0);
    HashTableInsert(&ht,10,0);


    HashTablePrint(&ht);
    printf("%d ",HashTableFind(&ht,53)->_key);
    printf("%d ",HashTableFind(&ht,54)->_key);
    printf("%d ",HashTableFind(&ht,10)->_key);
    printf("%d ",HashTableFind(&ht,15)->_key);
    printf("%p ",HashTableFind(&ht,3));
    printf("\n\n");

    HashTableRemove(&ht,53);
    HashTableRemove(&ht,54);
    HashTableRemove(&ht,106);
    HashTableRemove(&ht,10);
    HashTableRemove(&ht,5);
    HashTablePrint(&ht);

    HashTableInsert(&ht,53,0);
    HashTableInsert(&ht,54,0);
    HashTableInsert(&ht,106,0);
    HashTablePrint(&ht);

    HashTableDestory(&ht);
    HashTablePrint(&ht);
}

測試結果：

更多內容請關注本文部落格：請戳關注連結
如需轉載和翻譯請聯絡本人。