鏈地址法的基本思想是：將所有雜湊地址為i 的元素構成一個稱為同義詞鏈的連結串列，並將連結串列的頭指標存在雜湊表的第i個單元中，因而查詢、插入和刪除主要在同義詞鏈中進行。 

該雜湊方法首先對關鍵碼集合用某一個雜湊函式計算它們的存放位置。

若設散列表地址空間的所有位置是從0到m-1，則關鍵碼集合中的所有關鍵碼被劃分為m個子集，具有相同地址的關鍵碼歸於同一子集。我們稱同一子集中的關鍵碼互為同義詞。每一個子集稱為一個桶。

通常各個桶中的表項通過一個連結串列連結起來，稱之為同義詞子表。所有桶號相同的表項都連結在同一個同義詞子表中，各連結串列的表頭結點組成一個向量。

進一步的分析：

1、通常，每個桶中的同義詞子表都很短，設有n個關鍵碼通過某一個雜湊函式，存放到散列表中的 m 個桶中。那麼每一個桶中的同

義詞子表的平均長度為 n / m。這樣，以搜尋平均長度為 n / m 的同義詞子表代替了搜尋長度為 n 的順序表，搜尋速度快得多（O(1)）。

2、時間複雜度分析：應用鏈地址法處理溢位，需要增設連結指標，似乎增加了儲存開銷。事實上，由於開地址法必須保持大量的空閒空間以確保搜尋

效率，如二次探查法要求裝填因子，（a = n / m）而表項所佔空間又比指標大得多，所以使用鏈地址法反而比開地址法節省存儲空間。

下面給出鏈地址法的實現，包括建立雜湊表，釋放雜湊表，在雜湊表中根據key查詢一項，根據key 插入一項，根據key 刪除一項等。

使用雙向連結串列實現。

#ifndef _HASH_H_
#define _HASH_H_
//雙向連結串列的雜湊
typedef struct hash hash_t;
typedef unsigned int (*hashfunc_t)(unsigned int,void*);//雜湊函式

/*建立雜湊表*/
hash_t* hash_alloc(unsigned int buckets,hashfunc_t hash_func); 
/*查詢關鍵字*/
void* hash_lookup_entry(hash_t *hash,void* key,unsigned int key_size);
/*雜湊表中新增記錄*/
void hash_add_entry(hash_t *hash,void *key,unsigned int key_size,
        void *value,unsigned int value_size);
/*釋放雜湊表*/
void hash_free_entry(hash_t *hash,void *key,unsigned int key_size);

#endif
 

#include "hash.h"
#include <assert.h>
#include "common.h"
typedef struct hash_node
{
    void *key; //任意型別的關鍵字
    void *value;//資訊
    struct hash_node *prev;//前驅指標
    struct hash_node *next;//後繼指標
}hash_node_t;

struct hash
{
    unsigned int buckets;
    hashfunc_t hash_func;
    hash_node_t **nodes;
};

//得到桶號
hash_node_t **hash_get_bucket(hash_t *hash,void *key)
{
    unsigned int bucket=hash->hash_func(hash->buckets,key);
    if(bucket >= hash->buckets)
    {
        fprintf(stderr,"bad buckets lookup\n");
        exit(EXIT_FAILURE);
    }

   return &(hash->nodes[bucket]);
}

hash_node_t *hash_get_node_by_key(hash_t *hash,void *key,unsigned int key_size)
{
    hash_node_t **bucket=hash_get_bucket(hash,key);
    hash_node_t *node=*bucket;
    if(node==NULL)
        return NULL;

    while(node!=NULL && memcmp(node->key,key,key_size)!=0)
    {
        node=node->next;
    }

    return node;
}

hash_t* hash_alloc(unsigned int buckets,hashfunc_t hash_func)
{
    hash_t *hash=(hash_t *)malloc(sizeof(hash_t));
    hash->buckets=buckets;
    hash->hash_func=hash_func;
    int size=buckets * sizeof(hash_node_t*);
    hash->nodes=(hash_node_t**)malloc(size);
    memset(hash->nodes,0,size);
    return hash;
     
}

void* hash_lookup_entry(hash_t *hash,void* key,unsigned int key_size)
{
    hash_node_t *node=hash_get_node_by_key(hash,key,key_size);
    if(node==NULL)
        return NULL;

    return node->value;
}


void hash_add_entry(hash_t *hash,void *key,unsigned int key_size,
        void *value,unsigned int value_size)
{
    //已經存在
    if(hash_lookup_entry(hash,key,key_size))
    {
        fprintf(stderr,"duplicate hash key\n");
        return ;
    }

    hash_node_t *node=malloc(sizeof(hash_node_t));
    node->prev=NULL;
    node->next=NULL;

    node->key=malloc(key_size);
    memcpy(node->key,key,key_size);

    node->value=malloc(value_size);
    memcpy(node->value,value,value_size);

    hash_node_t **bucket=hash_get_bucket(hash,key);
    if(*bucket == NULL)
    {
        *bucket=node;
    }
    else
    {
        //將新的節點插入到頭部
        node->next=*bucket;
        (*bucket)->prev=node;
        *bucket=node;
    }
}

//刪除操作
void hash_free_entry(hash_t *hash,void *key,unsigned int key_size)
{
     hash_node_t *node=hash_get_node_by_key(hash,key,key_size);
     if(node==NULL)
         return ;

     free(node->key);
     free(node->value);

     if(node->prev)
         node->prev->next=node->next;
     else
     {
         hash_node_t **bucket=hash_get_bucket(hash,key);
         *bucket=node->next;
     }

     if(node->next)
         node->next->prev=node->prev;
      
     free(node);
}


 

#include "hash.h"
#include "common.h"

typedef struct stu
{
   char sno[5];
   char name[32];
   int age;
}stu_t;

typedef struct stu2
{
   int sno;
   char name[32];
   int age;
}stu2_t;
//字串雜湊函式
unsigned int hash_str(unsigned int buckets,void *key)
{
    char *sno=(char *)key;
    unsigned int index=0;
    while(*sno)
    {
        index=*sno+4*index;
        sno++;
    }

    return index % buckets;
}

unsigned int hash_int(unsigned int buckets,void *key)
{
    int *sno=(int *)key;
    return (*sno) % buckets;
}

int main()
{
/*
    stu_t stu_arr[]=
    {
       {"1234","AAAA",20},
       {"4568","AAAA",23},
       {"6729","AAAA",19}
    };

    hash_t  *hash=hash_alloc(256,hash_str);

    int size=sizeof(stu_arr)/sizeof(stu_arr[0]);
    int i;
    for(i=0;i<size;i++)
    {//插入地址,關鍵碼,關鍵碼的長度，資料項
        hash_add_entry(hash,stu_arr[i].sno,strlen(stu_arr[i].sno),
                &stu_arr[i],sizeof(stu_arr[i]));
    }
    //查詢
    stu_t *s=(stu_t *)hash_lookup_entry(hash,"4568",strlen("4568"));
    if(s)
    {
        printf("%s %s %d\n",s->sno,s->name,s->age);
    }
    else
        printf("Not found\n");

    
    hash_free_entry(hash,"1234",strlen("1234"));

    s=(stu_t *)hash_lookup_entry(hash,"1234",strlen("1234"));
    if(s)
    {
        printf("%s %s %d\n",s->sno,s->name,s->age);
    }
    else
        printf("Not found\n");
*/

    stu2_t stu_arr[]=
    {
       {1234,"AAAA",20},
       {4568,"AAAA",23},
       {6729,"AAAA",19}
    };

    hash_t  *hash=hash_alloc(256,hash_int);

    int size=sizeof(stu_arr)/sizeof(stu_arr[0]);
    int i;
    for(i=0;i<size;i++)
    {//插入地址,關鍵碼,關鍵碼的長度，資料項
        hash_add_entry(hash,&(stu_arr[i].sno),sizeof(stu_arr[i].sno),
                &stu_arr[i],sizeof(stu_arr[i]));
    }
    //查詢
    int sno=4568;
    stu2_t *s=(stu2_t *)hash_lookup_entry(hash,&sno,sizeof(sno));
    if(s)
    {
        printf("%d %s %d\n",s->sno,s->name,s->age);
    }
    else
        printf("Not found\n");

    sno=1234;
    hash_free_entry(hash,&sno,sizeof(sno));

    s=(stu2_t *)hash_lookup_entry(hash,&sno,sizeof(sno));
    if(s)
    {
        printf("%d %s %d\n",s->sno,s->name,s->age);
    }
    else
        printf("Not found\n");
    return 0;
}

可以看到因為我們封裝的時候使用的是void *，所以支援各種型別的關鍵字，例如測試中的字串和整型。