算法学习之哈希表实现

       哈希表是一个键值对的数据结构，经常用于数据库索引，map，缓存等地方。可以表示成value = f(key),查找效率很高。哈希表实现最关键的地方是哈希函数的选择，好的哈希函数可以均匀分布，冲突小。现在工业界最常用的哈希函数是murmur，memcached和nginx使用的就是murmur。简单常用的哈希函数构造法有：1.直接定值法，利用key设计一个线性函数 f=a*key+b; 2.数字分析法，主要抽取部分数字进行循环左移，右移，相加减等各种操作。3.平方取中法。4.折叠法。5.除留余数法等。

    哈希表冲突处理，哈希函数是会发生冲突的，不同的key计算出了相同的hashcode。处理的方法有闭散列法和开散列法。1.闭散列法就是所有的操作还在原来的存储空间，没有开辟新的存储空间。线性探测法：f(key)=(f(key)+1)mod n。

双重散列法:hash函数产生冲突时，调用rehash函数重新计算hash值。2.开散列法也称为拉链法，用链表组织整个哈希表，拉链法是用的最多的一种方法。

     实现一个c语言版的存储字符串类型的hashmap。

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#define   DEFAULT_INITIAL_CAPACITY     1 << 4   //哈希表默认初始化容量  
#define   MAXIMUM_CAPACITY             1 << 30  //哈希表最大容量  
#define   DEFAULT_LOAD_FACTOR          0.75F    //哈希表负载系数,当系数越大占用空间越大，查询效率越高，系数越小占用空间越小，查询效率变低，此系数可调最佳0.75,如有需求可以自己调整  
struct hlist_node  
{  
   struct hlist_node **prev;   //如果用双向链表组织哈希表可以使用，本程序是用单链表组织的  
   struct hlist_node *next;  
};  
struct hlist_head  
{  
   struct hlist_node *first;  
};  
struct node  
{  
   struct hlist_node hlist_node;  
   char *key;  
   char *value;  
};  
struct hash_map  
{  
   struct hlist_head *table;    //哈希表基地址  
   int length;                 //哈希表头结点长度  
   int size;                   //k-v键值对个数  
   int threshold;             //哈希表阈值  
};  
/*计算hashcode，java jdk1.8的计算方法，通过关键字的地址计算关键字的哈希值，此哈希函数散列情况较好  */
static int hash(char *key)  
{  
      unsigned int seed = 131; // 31 131 1313 13131 131313 etc..  
      unsigned int hash = 0;  
      while (*key)  
      {  
        hash = hash * seed + (*key++);  
      }  
  
    return (hash & 0x7FFFFFFF);  
}  
/*当哈希表内存不够用时，扩容，扩容的时候把旧哈希表中的内容复制到新的哈希表中*/  
static void resize(struct hash_map *map)  
{  
     int old_cap = map->length;  
     int new_cap,i;  
     if(old_cap >= MAXIMUM_CAPACITY) {  
           map->threshold = MAXIMUM_CAPACITY;  
     } else if((new_cap = old_cap << 1) < MAXIMUM_CAPACITY && old_cap >= DEFAULT_INITIAL_CAPACITY){  
           map->threshold = map->threshold << 1;  
           map->length = new_cap;  
     }  
     struct hlist_head *old_table = map->table;  
  
     map->table = (struct hlist_head*)calloc(map->length,sizeof(struct hlist_head));  
     for(i = 0; i < old_cap; i++) {  
         if(old_table[i].first != NULL) {  
            struct hlist_node *p = old_table[i].first;  
            if(p->next == NULL) {  
                map->table[hash(((struct node*)p)->key) & (new_cap - 1)].first = p;  
            } else {  
                struct hlist_node *low_head = NULL,*low_tail = NULL;  
                struct hlist_node *high_head = NULL, *high_tail = NULL;  
                while(p != NULL) {  
                    if(hash(((struct node*)p)->key) & old_cap == 0) {  
                        if(low_tail == NULL)  
                            low_head = p;  
                        else  
                            low_tail->next = p;  
                        low_tail = p;  
                    } else {  
                        if(high_tail == NULL)  
                            high_head = p;  
                        else  
                            high_tail->next = p;  
                        high_tail = p;  
                    }  
                      p = p->next;  
                }  
                if(low_tail != NULL) {  
                    low_tail->next = NULL;  
                    map->table[i].first = low_head;  
                }  
                if(high_tail != NULL) {  
                    high_tail->next = NULL;  
                    map->table[i + old_cap].first = high_head;  
                }  
            }  
         }  
     }  
     free(old_table);  
}  
/*初始化哈希表，获取哈希表对象指针*/  
static struct hash_map *new_hash_map()  
{  
      struct hash_map *hash_map = (struct hash_map*)malloc(sizeof(struct hash_map));  
      hash_map->length = DEFAULT_INITIAL_CAPACITY;  
      hash_map->threshold = (int)(DEFAULT_LOAD_FACTOR * (DEFAULT_INITIAL_CAPACITY));  
      hash_map->size  = 0;  
      hash_map->table = (struct hlist_head*)calloc(hash_map->length,sizeof(struct hlist_head));  
      return hash_map;  
}  
/*初始化哈希表节点*/  
static struct hlist_node *new_node(char *key,char *value)  
{  
      struct node *node = (struct node*)malloc(sizeof(struct node));  
      node->key = key;  
      node->value = value;  
      node->hlist_node.next = NULL;  
      return &(node->hlist_node);  
}  
/*向哈希表中添加值*/  
static int put_val(struct hash_map *map,int hash,char *key,char *value)  
{  
     struct hlist_node *p;  
     int i;  
     int n = map->length;  
      /*如果此节点为空，说明这个链表还没有哈希映射*/  
     if((p = map->table[i = (n-1) & hash].first) == NULL) {  
         map->table[i].first = new_node(key,value);  
     } else {  
  
         struct node *e = NULL;  
         /*遍历链表*/  
        if(!strcmp(((struct node*)p)->key,key)) {  
                 e = p;  
        }  
         while(p->next != NULL) {  
              struct node *tmp = (struct node*)p;  
               /*如果有相等的key，则需要修改此key对应的value，所以记下这个节点*/  
              if(!strcmp(tmp->key,key)) {  
                 e = tmp;  
                 break;  
              }  
              p = p->next;  
          }  
            /*如果没有相同的key则在链表末尾插入新节点*/  
          if(!e) {  
              p->next = new_node(key,value);  
          } else { /*否则更改key对应的value*/  
              e->value = value;  
              return 1;  
          }  
     }  
     if(++map->size > map->threshold)  
          resize(map);  
     return 0;  
}  
int put(struct hash_map *map,char *key,char *value)  
{  
     return put_val(map,hash(key),key,value);  
}  
struct hlist_node *get_node(struct hash_map *map,int hash,char *key)  
{  
     struct hlist_node *p;  
     int n;  
     if(map->table != NULL && (n = map->length) > 0 &&  
           (p = map->table[(n-1) & hash].first) != NULL){  
          struct node *tmp;  
          while(p != NULL) {  
               tmp = (struct node*)p;  
               if(!strcmp(tmp->key,key)) {  
                   return p;  
               }  
             p = p->next;  
          }  
     }  
     return NULL;  
}  
char *get(struct hash_map *map,char *key)  
{  
     struct node *e;  
     return (e = (struct node*)get_node(map,hash(key),key)) == NULL ? NULL : e->value;  
}  
int main()  
{  
    struct hash_map *map = new_hash_map();  
    put(map,"中国","北京");  
    put(map,"美国","华盛顿");  
    put(map,"俄罗斯","莫斯科");  
    put(map,"日本","东京");  
    printf("%s\n",get(map,"中国"));  
    printf("%s\n",get(map,"俄罗斯"));  
    return 0;  
}