哈希之详细介绍

(1)散列表（哈希表）的定义

一般的查找

给你一个顺序表，你会如何查找某个给定的元素？

•  一般思路就是从表头开始，一个挨一个的比较记录a[i]与key的值是“=”还是“≠”，直到有相等才算是査找成功，返回i的值。

到了有序表（已排序的表）査找时，我们可以利用a[i]与key的“<” 或 “>”，来折半査找，直到相等时査找成功返回i。

反正我们的目标就是要找到那个 i 值，是不是还有其它好点的方法呢？

一个小故事

试想这样的场景，你很想学太极拳，听说学校有个叫张三丰的人打得特别好，于是你到学校学生处找人。学生处的工作人员可能会拿出学生名单，一个一个的査找， 最终告诉你，学校没这个人，并说张三丰几百年前就已经在武当山作古了。可如果你找对了人，比如在操场上找那些爱运动的同学，人家会告诉你，“哦，你找张三丰呀， 有有有，我带你去。”于是他把你带到了体育馆内，并告诉你，那个教大家打太极的小伙子就是“张三丰”，原来“张三丰” 是因为他太极拳打得好而得到的外号。

• 数据结构的知识可以和生活上的事情类比，查找其实跟找人就很像。学生处的老师找张三丰，那就是顺序表査找，依赖的是姓名关键字的比较。而通过爱好运动的同学询问时，没有遍历，没有比较，就凭他们“欲找太极‘张三丰’，必在体育馆当中”的经验，直接告诉你位置。

也就是说，我们只需要通过某个函数f，使得

存储位置 = f(关键字)

那样我们可以通过査找关键字不需要比较就可获得需要的记录的存储位置。

这就是一种新的存储技术——散列技术。

散列技术与散列表

散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)。

査找时，根据这个确定的对应关系找到给定值key的映射f(key),若査找集合中存在这个记录，则必定在f(key)的位置上。

这里我们把这种对应关系f称为散列函数，又称为哈希(Hash)函数。按这个思想，采用散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表（Hashtable)。那么关键字对应的记录存储位置我们称为散列地址。

明白了！经常听说的哈希表，原来是这么回事。看来里面还有很多学问，兴趣满满呢。让我们后面继续深入地去了解哈希技术～

(2)散列表是怎么进行查找的

散列过程

整个散列过程其实就是两步。

1. 在存储的时候，通过散列函数计算记录的散列地址，并按此散列地址存储该记录。

就像张三丰我们就让他在体育馆，那如果是“爱因斯坦”我们让他在图书馆，如果是“居里夫人”，那就让她在化学实验室。如果是“巴顿将军”，这个打即时战略游戏的高手，我们可以让他到网吧。总之，不管什么记录，我们都需要用同一个散列函数计算出地址再存储。

2. 当査找记录时，我们通过同样的散列函数计算记录的散列地址，按此散列地址访问该记录。说起来很简单，在哪存的，上哪去找，由于存取用的是同一个散列函 数，因此结果当然也是相同的。

• 所以说，散列技术既是一种存储方法，也是一种查找方法。然而它与线性表、 树、图等结构不同的是，前面几种结构，数据元素之间都存在某种逻辑关系，可以用连线图示表示出来，而散列技术的记录之间不存在什么逻辑关系，它只与关键字有关联。因此，散列主要是面向査找的存储结构。

散列表的优势与劣势

散列技术最适合的求解问题是査找与给定值相等的记录。对于査找来说，简化了比较过程，效率就会大大提高。但万事有利就有弊，散列技术不具备很多常规数据结构的能力。

比如那种同样的关键字，它能对应很多记录的情况，却不适合用散列技术。一个班级几十个学生，他们的性别有男有女，你用关键字“男”去査找，对应的有许多学生的记录，这显然是不合适的。这个时候可以用班级学生的学号或者身份证号来散列存储，此时一个号码唯一对应一个学生才比较合适。

同样散列表也不适合范围查找，比如査找一个班级18-22岁的同学，在散列表中没法进行。想获得表中记录的排序也不可能，像最大值、最小值等结果也都无法从散列表中计算出来。

• 我们说了这么多，散列函数应该如何设计？这个我们需要重点来讲解，总之设计一个简单、均匀、存储利用率高的散列函数是散列技术中最关键的问题。重复一遍，设计一个合适的散列函数最重要！

哈希冲突

另一个问题是冲突。在理想的情况下，每一个关键字，通过散列函数计算出来的地址都是不一样的，可现实中，这只是一个理想。

我们时常会碰到两个关键字key1 ≠ key2，但是却有f (key1) = f (key2)，这种现象我们称为冲突（collision)，并把key1和 key2称为这个散列函数的同义词（synonym）。出现了冲突当然非常糟糕，那将造成数据査找错误。尽管我们可以通过精心设计的散列函数让冲突尽可能的少，但是不能完全避免。于是如何处理冲突就成了一个很重要的课题，这在我们后面也需要详细讲解。

处理哈希冲突是个大坑……需要深入了解的东西很多。这里简单预告下，通常有两类方法处理冲突：开放定址(Open Addressing)法和拉链(Chaining)法。有兴趣可以跳到后面章节先了解下。

(3)散列函数设计：直接定址法

上一篇说到了，设计一个简单、均匀、存储利用率高的散列函数是散列技术中最关键的问题。那么我们今天开始就看看，如何去设计散列函数。

散列函数的设计原则

• 不管做什么事情，要做到最优都不容易，既要付出尽可能的少，又要得到最大化的多。那么什么才算是好的散列函数呢？这里我们有两个原则可以参考。

1. 计算简单

你说设计一个算法可以保证所有的关键字都不会产生冲突，但是这个算法需要很复杂的计算，会耗费很多时间，这对于需要频繁地査找来说，就会大大降低査找的效率了。因此散列函数的计算时间不应该超过其他査找技术与关键字比较的时间。

2. 散列地址分布均匀

我们前面也提到冲突带来的问题，最好的办法就是尽量让散列地址均匀地分布在存储空间中，这样可以保证存储空间的有效利用，并减少为处理冲突而耗费的时间。

• 简单科普一下，以PHP为例。PHP的Hash采用的是目前最为普遍的DJBX33A (Daniel J. Bernstein, Times 33 with Addition)，这个算法被广泛运用与多个软件项目，Apache、Perl和Berkeley DB等。对于字符串而言这是目前所知道的最好的哈希算法，原因在于该算法的速度非常快，而且分类非常好（冲突小，分布均匀）。

下面我们逐个介绍一些常用的散列函数构造方法。估计设计这些方法的前辈们当年可能是从事间谍工作，因为这些方法都是将原来数字按某种规律变成另一个数字而已。首先是直接定址法。

直接定址法

如果我们现在要对0-100岁的人口数字统计表，那么我们对年龄这个关键字就可以直接用年龄的数字作为地址。此时f(key) = key。

• 这个时候，我们可以得出这么个哈希函数：f(0) = 0，f(1) = 1，……，f(20) = 20。这个是根据我们自己设定的直接定址来的。人数我们可以不管，我们关心的是如何通过关键字找到地址。

如果我们现在要统计的是80后出生年份的人口数，那么我们对出生年份这个关键字可以用年份减去1980来作为地址。此时f (key) = key-1980。

• 假如今年是2000年，那么1980年出生的人就是20岁了，此时 f(2000) = 2000 - 1980，可以找得到地址20，地址20里保存了数据“人数500万”。

也就是说，我们可以取关键字的某个线性函数值为散列地址，即：

f(key) = a × key + b

这样的散列函数优点就是简单、均匀，也不会产生冲突，但问题是这需要事先知道关键字的分布情况，适合査找表较小且连续的情况。由于这样的限制，在现实应用中，直接定址法虽然简单，但却并不常用。

(4)散列函数设计：除留余数法

除留余数法介绍

除留余数法此方法为最常用的构造散列函数方法。对于散列表长为m的散列函数公式为：

f( key ) = key mod p ( p ≤ m )

mod是取模（求余数）的意思。事实上，这方法不仅可以对关键字直接取模，也可在折叠、平方取中后再取模。

一个例子

• 很显然，本方法的关键就在于选择合适的p, p如果选得不好，就可能会容易产生同义词。下面我们来举个例子看看：

有一个关键字，它有12个记录，现在我们要针对它设计一个散列表。如果采用除留余数法，那么可以先尝试将散列函数设计为f(key) = key mod 12的方法。比如29 mod 12 = 5，所以它存储在下标为5的位置。

不过这也是存在冲突的可能的，因为12 = 2×6 = 3×4。如果关键字中有像18(3×6)、30(5×6)、42(7×6)等数字，它们的余数都为6，这就和78所对应的下标位置冲突了。

• 甚至极端一些，对于下图的关键字，如果我们让p为12的话，就可能出现下面的情况，所有的关键字都得到了0这个地址数，这未免也太糟糕了点。

但是我们如果不选用p=12来做除留余数法，而选用p=ll，则结果如下：

这个时候就只有12和144有冲突，相对来说，就要好很多了。

如何合理选取p值

使用除留余数法的一个经验是，若散列表表长为m，通常p为小于或等于表长（最好接近m)的最小质数或不包含小于20质因子的合数。

• 这句话怎么理解呢？要不这样吧，我再举个例子：某散列表的长度为100，散列函数H(k)=k%P,则P通常情况下最好选择哪个呢？A、91 B、93 C、97 D、99

实践证明，当P取小于哈希表长的最大质数时，产生的哈希函数较好。我选97，因为它是离长度值最近的最大 质数。

(5)散列冲突处理：开放定址法

前面我们讲了一些设计散列函数的方法，从前面的除留余数法的例子也可以看出，我们设计得再好的散列函数也不可能完全避免冲突，这就像我们再健康也只能尽量预防疾病，但却无法保证永远不得病一样，既然冲突不能避免，就要考虑如何处理它。

那么当我们在使用散列函数后发现两个关键字key1≠key2，但是却有f(key1) = f(key2)，即有冲突时，怎么办呢？我们可以从生活中找寻思路。

• 试想一下，当你观望很久很久，终于看上一套房打算要买了，正准备下订金，人家告诉你，这房子已经被人买走了，你怎么办？对呀，再找别的房子呗！这其实就是一种处理冲突的方法开放定址法。

开放定址法

所谓的开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。

公式为：

fi(key) = (f(key)+di) MOD m (di=1,2,3,......,m-1)

• 用开放定址法解决冲突的做法是：当冲突发生时，使用某种探测技术在散列表中形成一个探测序列。沿此序列逐个单元地查找，直到找到给定的关键字，或者碰到一个开放的地址（即该地址单元为空）为止（若要插入，在探查到开放的地址，则可将待插入的新结点存人该地址单元）。查找时探测到开放的地址则表明表中无待查的关键字，即查找失败。

比如说，我们的关键字集合为{12,67,56,16,25,37,22,29,15,47,48,34},表长为12。 我们用散列函数f(key) = key mod l2。

当计算前S个数{12,67,56,16,25}时，都是没有冲突的散列地址，直接存入：

计算key = 37时，发现f(37) = 1，此时就与25所在的位置冲突。

于是我们应用上面的公式f(37) = (f(37)+1) mod 12 = 2。于是将37存入下标为2的位置。这其实就是房子被人买了于是买下一间的作法：。

接下来22,29,15,47都没有冲突，正常的存入：

到了 key=48，我们计算得到f(48) = 0，与12所在的0位置冲突了，不要紧，我们f(48) = (f(48)+1) mod 12 = 1，此时又与25所在的位置冲突。于是f(48) = (f(48)+2) mod 12=2，还是冲突……一直到 f(48) = (f(48)+6) mod 12 = 6时，才有空位，机不可失，赶快存入：

我们把这种解决冲突的开放定址法称为线性探测法。

从这个例子我们也看到，我们在解决冲突的时候，还会碰到如48和37这种本来都不是同义词却需要争夺一个地址的情况，我们称这种现象为堆积。很显然，堆积的出现，使得我们需要不断处理冲突，无论是存入还是査找效率都会大大降低。

二次探测法

考虑深一步，如果发生这样的情况，当最后一个key=34，f(key)=10,与22所在的位置冲突，可是22后面没有空位置了，反而它的前面有一个空位置，尽管可以 不断地求余数后得到结果，但效率很差。

因此我们可以改进di = 12, -12, 22, -22,……, q2, -q2 (q <= m/2),这样就等于是可以双向寻找到可能的空位置。

对于34来说，我 们取di即可找到空位置了。另外增加平方运算的目的是为了不让关键字都聚集在 某一块区域。我们称这种方法为二次探测法。

fi(key) = (f(key)+di) MOD m (di = 12, -12, 22, -22,……, q2, -q2, q <= m/2)

随机探测法

还有一种方法是，在冲突时，对于位移量 di 采用随机函数计算得到，我们称之为随机探测法。

此时一定会有人问，既然是随机，那么查找的时候不也随机生成办吗？如何可以获得相同的地址呢？这是个问题。这里的随机其实是伪随机数。

伪随机数是说，如果我们设置随机种子相同，则不断调用随机函数可以生成不会重复的数列，我们在査找时，用同样的随机种子，它每次得到的数列是相同的，相同的 di 当然可以得到相同的散列地址。

fi(key) = (f(key)+di) MOD m (di是一个随机数列)

总之，开放定址法只要在散列表未填满时，总是能找到不发生冲突的地址，是我们常用的解决冲突的办法。

(6)散列冲突处理：链地址法

链地址法（拉链法）

前面我们谈到了散列冲突处理的开放定址法，它的思路就是一旦发生了冲突，就去寻找下一个空的散列地址。那么，有冲突就非要换地方呢，我们直接就在原地处理行不行呢？

可以的，于是我们就有了链地址法。

将所有关键字为同义词的记录存储在一个单链表中，我们称这种表为同义词子表，在散列表中只存储所有同义词子表的头指针。

对于关键字集合{12,67,56,16,25,37, 22,29,15,47,48,34}，我们用前面同样的12为除数，进行除留余数法：

• 此时，已经不存在什么冲突换址的问题，无论有多少个冲突，都只是在当前位置给单链表增加结点的问题。很不错的解决思路吧？

拉链法解决冲突的做法是：将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链法中，装填因子α可以大于 1，但一般均取α≤1。

拉链法的优势与缺点

与开放定址法相比，拉链法有如下几个优点：

1. 拉链法处理冲突简单，且无堆积现象，即非同义词决不会发生冲突，因此平均查找长度较短；
2. 由于拉链法中各链表上的结点空间是动态申请的，故它更适合于造表前无法确定表长的情况；
3. 开放定址法为减少冲突，要求装填因子α较小，故当结点规模较大时会浪费很多空间。而拉链法中可取α≥1，且结点较大时，拉链法中增加的指针域可忽略不计，因此节省空间；
4. 在用拉链法构造的散列表中，删除结点的操作易于实现。只要简单地删去链表上相应的结点即可。而对开放地址法构造的散列表，删除结点不能简单地将被删结 点的空间置为空，否则将截断在它之后填人散列表的同义词结点的查找路径。这是因为各种开放地址法中，空地址单元（即开放地址）都是查找失败的条件。因此在用开放地址法处理冲突的散列表上执行删除操作，只能在被删结点上做删除标记，而不能真正删除结点。

拉链法的缺点：指针需要额外的空间，故当结点规模较小时，开放定址法较为节省空间，而若将节省的指针空间用来扩大散列表的规模，可使装填因子变小，这又减少了开放定址法中的冲突，从而提高平均查找速度。

• 链地址法的优势是对于可能会造成很多 冲突的散列函数来说，提供了绝不会出现找不到地址的保障。当然，这也就带来了査找时需要遍历单链表的性能损耗，不过性能损耗在很多场合下也不是什么大问题。

(7)哈希表的链地址法实现

哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。哈希表在像Java、C#等语言中是与生俱来的。可是在C的世界中，似乎只有自己动手，丰衣足食了。

哈希表实现中需要注意的问题。

1. 哈希函数

也叫散列函数，即：根据key，计算出key对应记录的储存位置：position = f(key)

散列函数满足以下的条件：

1. 对输入值运算，得到一个固定长度的摘要(Hash value)；
2. 不同的输入值可能对应同样的输出值；

以下的函数都可以认为是一个散列函数：

• f(x) = x mod 16;
• f(x) = (x2 + 10) * x; 
• f(x) = (x | 0×0000FFFF) XOR (x >> 16); 

不过，仅仅满足上面这两条的函数，作为散列函数，还有不足的地方。我们还希望散列函数满足下面几点：

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

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

2、哈希冲突（Hash collision）

也就是两个不同输入产生了相同输出值的情况。首先，哈希冲突是无法避免的，因此，哈希算法的选择直接决定了哈希冲突发送的概率；同时必须要对哈希冲突进行处理，方法主要有以下几种：

1. 链地址法。即对Hash表中每个Hash值建立一个冲突表，即将冲突的几个记录以表的形式存储在其中。具体可以参照 散列冲突处理：链地址法 。
2. 开放地址法。具体可以参照 散列冲突处理：开放定址法 。

[cpp]  view plain copy

 

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

转载于:https://www.cnblogs.com/hypo106/p/6794437.html