哈希表的实现

哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。具体的介绍网上有很详细的描述，如闲聊哈希表 ，这里就不再累述了；

哈希查找是通过计算数据元素的存储地址进行查找的一种方法。O(1)的查找，即所谓的秒杀。哈希查找的本质是先将数据映射成它的哈希值。哈希查找的核心是构造一个哈希函数，它将原来直观、整洁的数据映射为看上去似乎是随机的一些整数。

哈希查找的操作步骤：

1)       用给定的哈希函数构造哈希表；

2)       根据选择的冲突处理方法解决地址冲突；

3)       在哈希表的基础上执行哈希查找 O(1)。

建立哈希表操作步骤：

1)       step1 取数据元素的关键字key，计算其哈希函数值（地址）。若该地址对应的存储空间还没有被占用，则将该元素存入；否则执行step2解决冲突。

2)       step2 根据选择的冲突处理方法，计算关键字key的下一个存储地址。若下一个存储地址仍被占用，则继续执行step2，直到找到能用的存储地址为止。

哈希查找步骤为：

1)       Step1 对给定k值，计算哈希地址 Di=H（k）；若HST为空，则查找失败；若HST=k，则查找成功；否则，执行step2（处理冲突）。

2)       Step2 重复计算处理冲突的下一个存储地址 Dk=R（Dk-1），直到HST[Dk]为空，或HST[Dk]=k为止。若HST[Dk]=K，则查找成功，否则查找失败。

 

比如说：”5“是一个要保存的数，然后我丢给哈希函数，哈希函数给我返回一个”2"，那么此时的”5“和“2”就建立一种对应关系，这种关系就是所谓的“哈希关系”，在实际应用中也就形成了”2“是key，”5“是value。

那么有的朋友就会问如何做哈希，首先做哈希必须要遵守两点原则：

①: key尽可能的分散，也就是我丢一个“6”和“5”给你，你都返回一个“2”，那么这样的哈希函数不尽完美。

②：哈希函数尽可能的简单，也就是说丢一个“6”给你，你哈希函数要搞1小时才能给我，这样也是不好的。

其实常用的做哈希的手法有“五种”：

第一种：”直接定址法“。

很容易理解，key=Value+C；这个“C"是常量。Value+C其实就是一个简单的哈希函数。

第二种：“除法取余法”。

很容易理解， key=value%C;解释同上。

第三种：“数字分析法”。

这种蛮有意思，比如有一组value1=112233，value2=112633，value3=119033，

针对这样的数我们分析数中间两个数比较波动，其他数不变。那么我们取key的值就可以是

key1=22,key2=26,key3=90。

第四种：“平方取中法”。此处忽略，见名识意。

第五种：“折叠法”。

这种蛮有意思,比如value=135790，要求key是2位数的散列值。那么我们将value变为13+57+90=160，然后去掉高位“1”,此时key=60，哈哈，这就是他们的哈希关系，这样做的目的就是key与每一位value都相关，来做到“散列地址”尽可能分散的目地。

影响哈希查找效率的一个重要因素是哈希函数本身。当两个不同的数据元素的哈希值相同时，就会发生冲突。为减少发生冲突的可能性，哈希函数应该将数据尽可能分散地映射到哈希表的每一个表项中。

解决冲突的方法有以下两种：　　

(1)   开放地址法　　

如果两个数据元素的哈希值相同，则在哈希表中为后插入的数据元素另外选择一个表项。当程序查找哈希表时，如果没有在第一个对应的哈希表项中找到符合查找要求的数据元素，程序就会继续往后查找，直到找到一个符合查找要求的数据元素，或者遇到一个空的表项。　　

(2)   链地址法

将哈希值相同的数据元素存放在一个链表中，在查找哈希表的过程中，当查找到这个链表时，必须采用线性查找方法。

首先先来交代一下哈希表实现中需要注意的一些概念：

（主要参考：这里）

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);

它很完美地满足“好的散列函数”的两个附加条件。

链地址法：

举例说明： 设有 8 个元素 { a,b,c,d,e,f,g,h } ，采用某种哈希函数得到的地址分别为： {0 ， 2 ， 4 ， 1 ， 0 ， 8 ， 7 ， 2} ，当哈希表长度为 10 时，采用链地址法解决冲突的哈希表如下图所示。 

  1 #include "stdafx.h"
  2 #include <string.h>
  3 #include <stdio.h>
  4 #include <stdlib.h>
  5 
  6 typedef struct _node{
  7     char *name;
  8     char *desc;
  9     struct _node *next;   
 10 }node;
 11 
 12 #define HASHSIZE 101
 13 static node* hashtab[HASHSIZE];
 14 

     //哈希表由数组实现
 15 void inithashtab(){   
 16     int i;
 17     for(i=0;i<HASHSIZE;i++)
 18         hashtab[i]=NULL;
 19 }
 20 

     // 哈希函数
 21 unsigned int hash(char *s){     
 22     unsigned int h=0;
 23     for(;*s;s++)
 24         h=*s+h*31;
 25     return h%HASHSIZE;
 26 }
 27 
 28 node* lookup(char *n){
 29     unsigned int hi=hash(n);    
 30     node* np=hashtab[hi];
 31     for(;np!=NULL;np=np->next){
 32         if(!strcmp(np->name,n))
 33             return np;
 34     }
 35     
 36     return NULL;
 37 }
 38 
 39 char* m_strdup(char *o){
 40     int l=strlen(o)+1;
 41     char *ns=(char*)malloc(l*sizeof(char));
 42     strcpy(ns,o);
 43     if(ns==NULL)
 44         return NULL;
 45     else
 46         return ns;
 47 }
 48 
 49 char* get(char* name){
 50     node* n=lookup(name);
 51     if(n==NULL)
 52         return NULL;
 53     else
 54         return n->desc;
 55 }
 56 
 57 int install(char* name,char* desc){
 58     unsigned int hi;
 59     node* np;
 60     if((np=lookup(name))==NULL){
 61         hi=hash(name);
 62         np=(node*)malloc(sizeof(node));
 63         if(np==NULL)
 64             return 0;
 65         np->name=m_strdup(name);
 66         if(np->name==NULL) return 0;
 67         np->next=hashtab[hi];
 68         hashtab[hi]=np;
 69     }
 70     else
 71         free(np->desc);
 72     np->desc=m_strdup(desc);
 73     if(np->desc==NULL) return 0;
 74     
 75     return 1;
 76 }
 77 
 78 /* A pretty useless but good debugging function,
 79 which simply displays the hashtable in (key.value) pairs
 80 */
 81 void displaytable(){
 82     int i;
 83     node *t;
 84     for(i=0;i<HASHSIZE;i++){
 85         if(hashtab[i]==NULL)
 86             printf("()");
 87         else{
 88             t=hashtab[i];
 89             printf("(");
 90             for(;t!=NULL;t=t->next)
 91                 printf("(%s.%s) ",t->name,t->desc);
 92             printf(".)");
 93         }
 94     }
 95 }
 96 
 97 void cleanup(){
 98     int i;
 99     node *np,*t;
100     for(i=0;i<HASHSIZE;i++){
101         if(hashtab[i]!=NULL){
102             np=hashtab[i];
103             while(np!=NULL){
104                 t=np->next;
105                 free(np->name);
106                 free(np->desc);
107                 free(np);
108                 np=t;
109             }
110         }
111     }
112 }
113 
114 main(){
115     int i;
116     char* names[]={"name","address","phone","k101","k110"};
117     char* descs[]={"Sourav","Sinagor","26300788","Value1","Value2"};
118     
119     inithashtab();
120     for(i=0;i<5;i++)
121         install(names[i],descs[i]);
122     
123     printf("Done");
124     printf("If we didnt do anything wrong..""we should see %s",get("k110"));
125     
126     install("phone","9433120451");
127     
128     printf("Again if we go right, we have %s and %s",get("k101"),get("phone"));
129     
130     /*displaytable();*/
131     cleanup();
132     return 0;
133 }