哈希表的C實現（一）

 

哈希表（Hash table，也叫散列表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構。也就是說，它通過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。具體的介紹網上有很詳細的描述，如閒聊哈希表 ，這裏就不再累述了；

哈希表在像Java、C#等語言中是與生俱來的。可是在C的世界中，似乎只有自己動手，豐衣足食；在網上google了一把，大致有幾個版本，我會一一來分析對比；

首先先來交代一下哈希表實現中需要注意的一些概念：

（主要參考：這裏）

1. 哈希函數

也叫散列函數，即：根據key,計算出key對應記錄的儲存位置
position = f(key)

散列函數滿足以下的條件：

1、對輸入值運算，得到一個固定長度的摘要(Hash value)；

2、不同的輸入值可能對應同樣的輸出值；

以下的函數都可以認爲是一個散列函數：

f(x) = x mod 16; (1)

f(x) = (x² + 10) * x; (2)

f(x) = (x | 0×0000FFFF) XOR (x >> 16); (3)

不過，僅僅滿足上面這兩條的函數，作爲散列函數，還有不足的地方。我們還希望散列函數滿足下面幾點：

1、散列函數的輸出值儘量接近均勻分佈；

2、x的微小變化可以使f(x)發生非常大的變化，即所謂“雪崩效應”(Avalanche effect)；

上面兩點用數學語言表示，就是：

1， 輸出值y的分佈函數F(y)=y/m, m爲散列函數的最大值。或記爲y~U[0, m]

2，|df(x)/dx| >> 1；

從上面兩點，大家看看，前面舉例的三個散列函數，哪個更好呢？對了，是第三個：

f(x) = (x | 0×0000FFFF) XOR (x >> 16);

它很完美地滿足“好的散列函數”的兩個附加條件。

2、哈希衝突（Hash collision）

也就是兩個不同輸入產生了相同輸出值的情況。首先，哈希衝突是無法避免的，因此，哈希算法的選擇直接決定了哈希衝突發送的概率；同時必須要對哈希衝突進行處理，方法主要有以下幾種：

1， 鏈地址法

鏈地址法：對Hash表中每個Hash值建立一個衝突表，即將衝突的幾個記錄以表的形式存儲在其中

2， 開放地址法

下面就來看看每種方法的具體實現吧：

鏈地址法：

舉例說明： 設有 8 個元素 { a,b,c,d,e,f,g,h } ，採用某種哈希函數得到的地址分別爲： {0 ， 2 ， 4 ， 1 ， 0 ， 8 ， 7 ， 2} ，當哈希表長度爲 10 時，採用鏈地址法解決衝突的哈希表如下圖所示。 

圖片及舉例引自：這裏

#include "stdafx.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct _node{
    char *name;
    char *desc;
    struct _node *next;
}node;

#define HASHSIZE 101
static node* hashtab[HASHSIZE];

void inithashtab(){
    int i;
    for(i=0;i<HASHSIZE;i++)
        hashtab[i]=NULL;
}

unsigned int hash(char *s){
    unsigned int h=0;
    for(;*s;s++)
        h=*s+h*31;
    return h%HASHSIZE;
}

node* lookup(char *n){
    unsigned int hi=hash(n);
    node* np=hashtab[hi];
    for(;np!=NULL;np=np->next){
        if(!strcmp(np->name,n))
            return np;
    }
    
    return NULL;
}

char* m_strdup(char *o){
    int l=strlen(o)+1;
    char *ns=(char*)malloc(l*sizeof(char));
    strcpy(ns,o);
    if(ns==NULL)
        return NULL;
    else
        return ns;
}

char* get(char* name){
    node* n=lookup(name);
    if(n==NULL)
        return NULL;
    else
        return n->desc;
}

int install(char* name,char* desc){
    unsigned int hi;
    node* np;
    if((np=lookup(name))==NULL){
        hi=hash(name);
        np=(node*)malloc(sizeof(node));
        if(np==NULL)
            return 0;
        np->name=m_strdup(name);
        if(np->name==NULL) return 0;
        np->next=hashtab[hi];
        hashtab[hi]=np;
    }
    else
        free(np->desc);
    np->desc=m_strdup(desc);
    if(np->desc==NULL) return 0;
    
    return 1;
}

/* A pretty useless but good debugging function,
which simply displays the hashtable in (key.value) pairs
*/
void displaytable(){
    int i;
    node *t;
    for(i=0;i<HASHSIZE;i++){
        if(hashtab[i]==NULL)
            printf("()");
        else{
            t=hashtab[i];
            printf("(");
            for(;t!=NULL;t=t->next)
                printf("(%s.%s) ",t->name,t->desc);
            printf(".)");
        }
    }
}

void cleanup(){
    int i;
    node *np,*t;
    for(i=0;i<HASHSIZE;i++){
        if(hashtab[i]!=NULL){
            np=hashtab[i];
            while(np!=NULL){
                t=np->next;
                free(np->name);
                free(np->desc);
                free(np);
                np=t;
            }
        }
    }
}

main(){
    int i;
    char* names[]={"name","address","phone","k101","k110"};
    char* descs[]={"Sourav","Sinagor","26300788","Value1","Value2"};
    
    inithashtab();
    for(i=0;i<5;i++)
        install(names[i],descs[i]);
    
    printf("Done");
    printf("If we didnt do anything wrong..""we should see %s",get("k110"));
    
    install("phone","9433120451");
    
    printf("Again if we go right, we have %s and %s",get("k101"),get("phone"));
    
    /*displaytable();*/
    cleanup();
    return 0;
}

轉自http://www.cnblogs.com/xiekeli/archive/2012/01/13/2321207.html