C语言-简单哈希表（hash table）

　　腾讯三面的时候，叫我写了个哈希表，当时紧张没写好···结果跪了···

　　回来后粪发涂墙，赶紧写了一个！

　　什么都不说了···先让我到厕所里面哭一会···

　　%>_<%

　　果然现场发挥，以及基础扎实才是important的！　　

　　用链地址法解决冲突的哈希表（C语言，VS2008编写、测试）：

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

struct node {
    int count;   // count the same value 
    char *value;
    node *next;
};

// 使用链地址法解决冲突
struct hash_table {
    int size;    // table size
    node **list; // 链表队列一条链为一个散列位置
};

//==================================================//
// declare

int hash_func(char *str, int tableSize);
hash_table *hash_table_init(int tableSize);
node *hash_table_new_node(char *str, int len);
int hash_table_insert(char *str, struct hash_table * head);
node *hash_table_find(char *str, struct hash_table * head);
void hash_table_clear(struct hash_table * head);
void hash_table_print(hash_table *head);

//==================================================//
// realize

// hash function: return the position of str in the hash table
int hash_func(char *str, int tableSize) {
    unsigned int hashVal = 0;

    while (*str != '')
        hashVal += (hashVal << 5) + *str++;
    
    return hashVal % tableSize;
}

// init & create hash table
hash_table *hash_table_init(int tableSize) {    
    hash_table *head;

    head = (hash_table *)malloc(sizeof(hash_table));
    if (NULL == head)
        return NULL;
    // 元素总数量尽可能为素数，以保证mod尽可能均匀
    head->size = tableSize;

    // 链表队列中，一条链为一个散列位置
    head->list = (node **)malloc(sizeof(node *) * tableSize);

    // initialize each hash list 
    int i;
    for (i = 0; i < head->size; i++)
        head->list[i] = NULL;

    return head;
}

// return one new node
node *hash_table_new_node(char *str, int len) {
    node *newNode = (node *)malloc(sizeof(node));
    newNode->count = 1;
    newNode->next = NULL;
    newNode->value = (char *)malloc(len + 1);
    memset(newNode->value, 0, len + 1);
    memcpy(newNode->value, str, len);

    return newNode;
}

// insert one node into hash table
int hash_table_insert(char *str, hash_table *head) {
    int len = strlen(str);
    // get str's position in the hash table
    int pos = hash_func(str, head->size);

    printf("[insert] %s at pos: %d
", str, pos);

    // locate list
    node *q = head->list[pos], *p = head->list[pos];
    for ( ; p != NULL; p = p->next) {
        if (memcmp(p->value, str, len) == 0) {
            p->count++; // found the same value, count+1
            return pos;
        }
        q = p; // store the previous node
    }

    // if not found, then insert one new node
    node *newNode = hash_table_new_node(str, len);
    /*
    //===================================================================//
    // method 1:
    // TODO: 如果是字符串不同，但是哈希值一样呢？？？貌似没考虑到这种情况
    // insert into the head of list
    newNode->next = head->list[pos];
    head->list[pos] = newNode;
    */
    //===================================================================//
    // method 2:
    // insert into the tail of list
    // 由于p指向了NULL，所以要插入链表尾的话，就必须增加一个变量q记录p前一个节点位置
    if (NULL == q) {
        newNode->next = head->list[pos];
        head->list[pos] = newNode;
    } else {
        q->next = newNode;
        newNode->next = NULL;
    }

    return pos;
}

// find the node which stored str & return it
node *hash_table_find(char *str, hash_table *head) {
    if (NULL == head)
        return NULL;

    int pos = hash_func(str, head->size);
    node *p = head->list[pos];
    
    int len = strlen(str);

    for ( ; p != NULL; p = p->next) 
        if (memcmp(p->value, str, len) == 0) 
            break;//return p; // found & return

    return p; //return NULL;
}

// clear the whole hash table
void hash_table_clear(hash_table *head) {
    if (NULL == head)
        return;
    
    node *p = NULL, *q = NULL;

    int i;
    for (i = 0; i < head->size; i++) {
        p = head->list[i];        
        while (p != NULL) {
            p->count = 0; // TODO: test
            q = p->next;
            // free value
            if (p->value) {
                free(p->value);
                p->value = NULL;
            }
            // free current node
            if (p) {
                free(p);
                p = NULL;
            }
            // point to next node
            p = q;
        }        
    }
    // free list
    if (head->list) {
        free(head->list);
        head->list = NULL;
    }
    // free head
    if (head) {
        free(head);
        head = NULL;
    }
}

// print the whole hash table
void hash_table_print(hash_table *head) {
    if (NULL == head) {
        printf("hash table is NULL! 
");
        return;
    }
    
    int i;
    node *p = NULL;

    for ( i = 0; i < head->size; i++) {
        p = head->list[i];
        printf("//============list %d============//
", i);
        while (p != NULL) {            
            if (p->value)
                printf("%s:%d ", p->value, p->count);
            else
                printf("(NULL):(0) ");
            p = p->next;
        }
        printf("
");
    }
}

// test
int main() {
    // create
    hash_table *head = hash_table_init(10);

    // insert
    hash_table_insert("test 1", head);
    hash_table_insert("test 2", head);
    hash_table_insert("test 2", head);
    hash_table_insert("test 3", head);
    hash_table_insert("test 4", head);

    hash_table_print(head);

    // find
    node *find = hash_table_find("test 2", head);
    printf("
[Find] %s:%d

", find->value, find->count);

    // clear
    hash_table_clear(head);

    hash_table_print(head);

    // create
    head = hash_table_init(6);

    // insert
    hash_table_insert("test 1", head);
    hash_table_insert("test 2", head);
    hash_table_insert("test 2", head);
    hash_table_insert("test 3", head);
    hash_table_insert("test 4", head);

    hash_table_print(head);

    return 0;
}