哈希表(Hash table) [散列表] C語言簡單實現

　　散列表（Hash table，也叫哈希表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構。也就是說，它通過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫做散列函數，存放記錄的數組叫做散列表。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　------摘自百度百科

填充因子定義：

　　α=表中填充的元素數/哈希表的長度

hash函數計算方式：

1.直接尋址法

2.數字分析法

3.平方取中法

4.折疊法

5.隨機數法

6.除留余數法

7.斐波那契數列

以上方法詳情自行百度，這里不再贅述。

 

哈希表解決沖突有兩種方式：

1.開放地址法 ： hi=(h(key)+di)%m ,1<=i<=m-1,di為增量序列，m為表長增量序列, di有不同方法生成 。 盡量填滿每一個hash數組位，所以hash表長度>= 實際插入填充數量   即填充因子至少為1

2.鏈地址法:  把重復的hash值元素放在一個鏈表下。一般不會超過hash表長度，但是為了避免鏈表過長，當填充因子為7/10 時候，hash表大小擴種兩倍

 

下面是C語言實現例子。hash函數主要采用 折疊法+除留余數法，解決沖突采用鏈地址法，暫時未添加自動擴充hash表長度。

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

// hash表默認長度
#define HASH_TABLE_SIZE 16

// hash表元素鏈表節點
typedef struct __node{
    char *key;
    char *value;
    struct __node *next;
}NODE, *PNODE, **PPNODE;

// hash表結構
typedef struct __hash_table{
    PPNODE table;
    unsigned total; // 總空間
    unsigned size;  // 已用空間
}HASH_TABLE, *PHASH_TABLE;

// 創建hash表中元素節點
PNODE create_node(const char* key, const char *value)
{
    PNODE pnode = (PNODE)malloc(sizeof(NODE));
    if(NULL == pnode) return NULL;

    pnode->next = NULL;
    if (NULL != key)
    {
        unsigned len = strlen(key) + 1;
        pnode->key = (char*)malloc(len);
        memcpy(pnode->key, key, len);
    }

    if (NULL != value)
    {
        unsigned len = strlen(value) + 1;
        pnode->value = (char*)malloc(len);
        memcpy(pnode->value, value, len);
    }
    return pnode;
}

// 創建hash表
PHASH_TABLE create_hash_table(unsigned size)
{
    if(size < 1) return NULL;

    PPNODE ppNodeTable = (PPNODE)malloc(sizeof(PNODE) * size);
    if (NULL == ppNodeTable) return NULL;

    for (unsigned i = 0; i < size; i++)
    {
        ppNodeTable[i] = NULL;
    }
    PHASH_TABLE pHashTable = (PHASH_TABLE)malloc(sizeof(HASH_TABLE));
    if(NULL == pHashTable) return NULL;
    pHashTable->table = ppNodeTable;
    pHashTable->total = size;
    pHashTable->size = 0;
    return pHashTable;
}

// hash函數 對疊法+除留余數法
unsigned hash(const char* key, unsigned hash_size)
{
    unsigned int h=0;
    for( ; *key != '\0'; ++key)
        h = *key + h * 31;
    return h%hash_size;
}

// 從hash表中獲取key對應的value
const char* get_hash_value(PHASH_TABLE pHashTable, const char* key)
{
    if(NULL == key) return NULL;

    unsigned index = hash(key, pHashTable->total);
    PNODE pnode = pHashTable->table[index];
    if(NULL == pnode) return NULL;

    do
    {
        if(strcmp(pnode->key, key) == 0)
        {
            return pnode->value;
        }

        pnode = pnode->next;
    }while (pnode != NULL);    
}

// 插入hash表
int insert_hash(PHASH_TABLE pHashTable ,const char *key, const char *value)
{
    if(NULL == key) return 0;
    // 剩余空間不足
    if(pHashTable->size == pHashTable->total) return -1;

    if(get_hash_value(pHashTable, key) != NULL) return -1;

    
    PNODE pnode = create_node(key, value);
    if(NULL == pnode) return 0;

    unsigned index = hash(key,pHashTable->total);
    if(NULL == pHashTable->table[index])
    {
        pHashTable->table[index] = pnode;
        ++ pHashTable->size;
    } else {
        pnode->next = pHashTable->table[index];
        pHashTable->table[index] = pnode;
    }

    return index;
}

// 釋放hash表
void free_hash_table(PHASH_TABLE pHashTable)
{
    if(NULL == pHashTable || pHashTable->size == 0) return;

    PNODE pnode = NULL;
    for (unsigned i = 0; i < pHashTable->total; i++)
    {
        pnode = pHashTable->table[i];
        if(pnode == NULL) continue;

        PNODE tmp = NULL;
        while( pnode != NULL)
        {
            tmp = pnode;
            pnode = pnode->next;
            free(tmp->key);
            free(tmp->value);
            free(tmp);
        }
        pHashTable->table[i] = NULL;
        pHashTable->size --;
        if(pHashTable->size == 0) return;
    }
    
    free(pHashTable->table);
    free(pHashTable);
}

// 打印hash表內容
void print_hash(PHASH_TABLE pHashTable)
{
    if(NULL == pHashTable || 0 == pHashTable->size) return;

    for (unsigned i = 0; i < pHashTable->total; i++)
    {
        printf("%u ",i);
        PNODE pnode = pHashTable->table[i];
        while (pnode != NULL)
        {
            if(pnode->value != NULL)
                printf("[%s,%s] ",pnode->key, pnode->value);
            else 
                printf("[%s,null] ",pnode->key);
            pnode = pnode->next;
        }
        printf("\n");
    }
}

int main(int argc, char *argv[])
{
   PHASH_TABLE pHashTable = create_hash_table(HASH_TABLE_SIZE);
   insert_hash(pHashTable, "zs","張三");
   insert_hash(pHashTable, "ls","李四");
   insert_hash(pHashTable, "we","王二");
   insert_hash(pHashTable, "mz","麻子");
   insert_hash(pHashTable, "lb","劉備");
   insert_hash(pHashTable, "gy","關羽");
   insert_hash(pHashTable, "zf","張飛");
   insert_hash(pHashTable, "cc","曹操");
   insert_hash(pHashTable, "cp","曹丕");
   insert_hash(pHashTable, "cz","曹植");
   insert_hash(pHashTable, "cr","曹仁");
//    const char* value = get_hash_value(pHashTable,"mz");
//    if(value != NULL)
//    {
//        printf("mz->%s\n",value);
//    } else {
//        printf("沒有找到zs\n");
//    }

    print_hash(pHashTable);
    
    free_hash_table(pHashTable);
    return 0;
}