第七章哈希表.docx
《第七章哈希表.docx》由会员分享，可在线阅读，更多相关《第七章哈希表.docx（16页珍藏版）》请在冰豆网上搜索。
第七章哈希表
第七章-哈希表
———————————————————————————————— 作者:
————————————————————————————————日期：
ﻩ
哈希表又称散列表,实际上就是一个数组。
哈希函数是一个用来求存储在哈希的关键字在哈希表的地址下标的函数．
比如一个哈希表ｉｎｔhashtable[5];
现在有下面4个数要存入到哈希表中:
（３，15，22,24）
给定一个哈希函数：
H（k）＝ｋ% 5
最终数据存储如下图：
理想情况下,哈希函数在关键字和地址之间建立了一个一一对应关系,从而使得查找只需一次计算即可完成。
由于关键字值的某种随机性,使得这种一一对应关系难以发现或构造。
因而可能会出现不同的关键字对应一个存储地址。
即k1≠k2,但H（k1）=Ｈ（k２）,这种现象称为冲突。
把这种具有不同关键字值而具有相同哈希地址的对象称“同义词”。
在大多数情况下，冲突是不能完全避免的。
这是因为所有可能的关键字的集合可能比较大,而对应的地址数则可能比较少。
对于哈希技术，主要研究两个问题:
（1）如何设计哈希函数以使冲突尽可能少地发生。
（2）发生冲突后如何解决。
哈希函数的构造方法:
构造好的哈希函数的方法，应能使冲突尽可能地少,因而应具有较好的随机性。
这样可使一组关键字的散列地址均匀地分布在整个地址空间。
根据关键字的结构和分布的不同,可构造出许多不同的哈希函数。
１.直接定址法
直接定址法是以关键字k本身或关键字加上某个数值常量c作为哈希地址的方法。
该哈希函数H（ｋ）为：
H（k）=k＋c（c≥0）
这种哈希函数计算简单，并且不可能有冲突发生。
当关键字的分布基本连续时，可使用直接定址法的哈希函数。
否则,若关键字分布不连续将造成内存单元的大量浪费。
2．除留余数法（注意:
这种方法常用）
取关键字k除以哈希表长度m所得余数作为哈希函数地址的方法。
即：
H（k）=ｋ%m
这是一种较简单、也是较常见的构造方法。
这种方法的关键是选择好哈希表的长度m。
使得数据集合中的每一个关键字通过该函数转化后映射到哈希表的任意地址上的概率相等。
理论研究表明，在m取值为素数（质数）时,冲突可能性相对较少。
3．平方取中法
取关键字平方后的中间几位作为哈希函数地址（若超出范围时，可再取模）。
4．折叠法
这种方法适合在关键字的位数较多，而地址区间较小的情况。
将关键字分隔成位数相同的几部分。
然后将这几部分的叠加和作为哈希地址（若超出范围,可再取模）。
例如,假设关键字为某人身份证号码4３55,则可以用4位为一组进行叠加。
即有５3５5＋81０1+1046＋４３0=14９３2,舍去高位。
则有H（435５）=４932
为该身份证关键字的哈希函数地址。
5.数值分析法
若事先知道所有可能的关键字的取值时,可通过对这些关键字进行分析，发现其变化规律,构造出相应的哈希函数。
若取最后两位作为哈希地址，则哈希地址的集合为下表所示：
冲突解决
1.开放地址法
处理冲突就是为该关键字的记录找到另一个“空”的哈希地址。
即通过一个新的哈希函数得到一个新的哈希地址。
如果仍然发生冲突，则再求下一个,依次类推。
直至新的哈希地址不再发生冲突为止。
用开放定址法处理冲突就是当冲突发生时，形成一个地址序列。
沿着这个序列逐个探测,直到找出一个“空”的开放地址。
将发生冲突的关键字值存放到该地址中去。
如Hi=（H（ｋ）+ｄ（ｉ）） %m,i=1,2,…ｋ（k其中H（k）为哈希函数，m为哈希表长,ｄ为增量函数,d（i）=dl，d２…dn－l。
增量序列的取法不同,可得到不同的开放地址处理冲突探测方法。
1.1线性探测法
线性探测法是从发生冲突的地址（设为d）开始，依次探查ｄ+ｌ，d+2,…m-１（当达到表尾m-1时,又从０开始探查）等地址，直到找到一个空闲位置来存放冲突处的关键字。
若整个地址都找遍仍无空地址,则产生溢出。
线性探查法的数学递推描述公式为：
注释:
这里的dｉ－1 为上一次哈希值
例题:
已知哈希表大小11，哈希表名字为A,给定关键字序列（２0,30，70，15，8，１2，1８，63,19）。
哈希函数为Ｈ（k）=ｋ％ll,采用线性探测法处理冲突，则将以上关键字依次存储到哈希表中。
试构造出该哈希表，并求出等概率情况下的平均查找长度。
本题中各元素的存放到哈希表过程如下:
Ｈ（20）=9,可直接存放到A[9]中去。
H（30）＝8,可直接存放到A［8]中去。
H（７0）＝4,可直接存放到Ａ［４]中去。
H（1５）=4，冲突；
d0=4
d１＝（4+1）%11＝5,将15放入到A[5]中。
H（8）=8,冲突;
d0＝８
ｄ１=（8+1）%１１＝9,仍冲突;
d2＝（8＋2）%1１=10，将8放入到Ａ[10]中。
H（１2）=l,可直接存放到Ａ[1］中去。
H（1８）=7,可直接存放到Ａ[７]中去。
H（６3）＝8，冲突;
ｄ0=8
ｄ1=（8+1）%11=9,仍冲突;
ｄ2=（8+2）%11＝10，仍冲突;
d３=（8+3）%11＝0，将63放入到Ａ[0］中。
H（19）=8，冲突；
d0=８
d１=（8+１）%11＝9,仍冲突;
d２=（８+2）%11＝10,仍冲突;
d3＝（8+3）％１１＝0,仍冲突;
d4＝（８+4）%11=1,仍冲突；
d５=（8＋5）%1１=2,将１9放入到A[2］中。
由此得哈希表如图所示:
平均查找长度:
（1*5+2＋3+４＋6）／9=20／9
利用线性探查法处理冲突容易造成关键字的“堆积”问题。
这是因为当连续ｎ个单元被占用后,再散列到这些单元上的关键字和直接散列到后面一个空闲单元上的关键字都要占用这个空闲单元，致使该空闲单元很容易被占用，从而发生非同义冲突。
造成平均查找长度的增加。
为了克服堆积现象的发生，可以用下面的方法替代线性探查法。
1.2平方探查法
设发生冲突的地址为d,则平方探查法的探查序列为:
d+１２，d+２2，…直到找到一个空闲位置为止。
平方探查法的数学描述公式为：
平方探测法和上面的线性探测法实现过程一样,只不过这里的解决冲突的新哈希不同而已。
若解决冲突时，探查到一半单元仍找不到一个空闲单元。
则表明此哈希表太满，需重新建立哈希表。
2.链地址法
用链地址法解决冲突的方法是:
把所有关键字为同义词的记录存储在一个线性链表中,这个链表称为同义词链表。
并将这些链表的表头指针放在数组中（下标从0到ｍ-１）。
这类似于图中的邻接表和树中孩子链表的结构。
链地址法查找分析：
由于在各链表中的第一个元素的查找长度为l，第二个元素的查找长度为２，依此类推。
因此，在等概率情况下成功的平均查找长度为：
（1*5＋２*2+3*ｌ+4*1）/9=１6/9
虽然链地址法要多费一些存储空间，但是彻底解决了“堆积”问题，大大提高了查找效率。
哈希表的查找及性能分析
哈希法是利用关键字进行计算后直接求出存储地址的。
当哈希函数能得到均匀的地址分布时，不需要进行任何比较就可以直接找到所要查的记录。
但实际上不可能完全避免冲突,因此查找时还需要进行探测比较。
在哈希表中,虽然冲突很难避免,但发生冲突的可能性却有大有小。
这主要与三个因素有关。
第一:
与装填因子有关
所谓装填因子是指哈希表中己存入的元素个数n与哈希表的大小m的比值，即＝n／ｍ。
当越小时，发生冲突的可能性越小,越大（最大为1）时,发生冲突的可能性就越大。
第二:
与所构造的哈希函数有关
若哈希函数选择得当,就可使哈希地址尽可能均匀地分布在哈希地址空间上,从而减少冲突的发生。
否则,若哈希函数选择不当,就可能使哈希地址集中于某些区域，从而加大冲突的发生。
第三：
与解决冲突的哈希冲突函数有关
哈希冲突函数选择的好坏也将减少或增加发生冲突的可能性。
下面有３道例题，分别是线性探测法、链地址法解决冲突的例题和综合练习辞典的例题
例题1：
线性探测法解决冲突
#inｃludｅ
#include
#incｌuｄe <ｓtｒｉｎｇ.h＞
/*
【例】已知哈希表地址区间为0~10，
给定关键字序列（20，30,70，15,8，12，１8,63,1９）。
哈希函数为H（ｋ）＝ｋ%11,采用线性探测法处理冲突,
新哈希函数 H（k） =（H（ｋ）＋1）%11
则将以上关键字依次存储到哈希表中。
试构造出该哈希表，并求出等概率情况下的平均查找长度。
*/
＃define N11
//创建哈希表
ｉnｔ* crｅate_hａshtａble（）;
//哈希函数:
用来求关键字在哈希表中的下标值
inthashｆun（intｋey）;
void add_hａsｈ（int＊ haｓhtａble,iｎtｄａtａ）;
inｔcount= 0;
intmaｉｎ（ｖｏid）
{
int* hashtabｌe = ｃreａte_haｓhtａｂlｅ（）;
ﻩｉntarr[9]= {20,30，7０,1５,8，1２，１8,63,１９};
ﻩinｔi;
ﻩfｏr（ｉ=０;i <9;ｉ＋+）
ﻩadd＿ｈash（hashtａｂｌe,arr[i］）;
ｐrintf（"平均查找长度为：
%f\n"，counｔ／9.0）;
rｅturn 0;
}
ｉnｔ* cｒeate_hａｓhtable（）
{
ﻩｉnt*hashtaｂle =（ｉｎt＊）malｌoc（N*sizeof（int））;
memsｅt（haｓhtａble,０,N*siｚeoｆ（iｎt））; //清空哈希表
if（!
hａｓhtablｅ）{prｉntf（＂caｎnot ｍalloｃ\n＂）；}
ﻩrｅｔuｒnhaｓhtaｂle；
}
inthashfun（intkey）
{
ﻩreｔuｒｎkｅy%N；
}
ｖoiｄaｄd_ｈash（inｔ*hashtable,int ｄatａ）
{
if（!
hashtａble）{ｐrｉｎtｆ（＂ｈasｈtａble=ＮULＬ\n"）；retｕrn;｝ﻩ
ｉnｔserch＝１;
ﻩiｎtaddｒ ＝ｈaｓhfｕn（daｔa）;
if（hashtable［ａddr]==0） /／表示这个空间是空的
ﻩｈasｈｔaｂle[addr]=data;
eｌse
｛//这个空间不是空的,产生冲突，需要调用新哈希函数去寻找新的哈希地址
ﻩdo
ﻩﻩ{
ﻩﻩｓｅrch＋+;
ﻩﻩａdｄr =（addr+ 1）％N;
}wｈile（ｈａshｔable[aｄdr］!
= 0）;／/不等于０表示空间非空,需要重新找
ﻩﻩ/／上面循环结束表示找到能够使用的哈希地址
ｈaｓｈｔable[ａdｄr］= data;
}
ﻩcoｕｎt＋=serch;
}
例题2:
链地址法解决冲突
＃ｉnclｕdｅ
#ｉnｃlｕde #ｉnclude
#defｉne N11
typedefstｒuｃｔNode
{
ﻩintdata;
ｓtｒuｃtNode＊nｅｘt;
｝nｏdｅ,*pｎｏdｅ;
pｎｏｄe*cｒeate_haｓｈtabｌe（）;
inthaｓｈｆｕn（ｉｎtkey）；
ｖｏidadd_hａｓh（pｎoｄｅ* hashtａble,intdａｔa）；
voidshoｗ_ｈaｓh（pnode＊hashtａble）；
intmaiｎ（voｉｄ）
{
ﻩinｔａrr[9］=｛20,30,70，１5,8,1２，１８,63,19｝;
ﻩｐnoｄe* hashｔaｂlｅ=creaｔe_ｈａshtａbｌe（）;ﻩ
ﻩｉntｉ；
fｏr（i=0;i＜ 9;i++）
ﻩadd＿hash（ｈａshtable,arr［i］）;
ﻩshoｗ_hａsh（ｈashｔａble）;
return0;
}
pnode*cｒeate_hashtable（）
｛
pnoｄe＊ hａshtable=（ｐnode*）ｍalloｃ（N*sizｅof（pｎode））;
ﻩiｆ（!
hashtablｅ）{ prinｔf（"ｈashtabｌe＝NULL\n"）;}
ｍemｓet（hａshtａｂｌe,０,N*siｚｅof（pｎｏde））； ／/清空
ﻩｒｅｔuｒｎｈaｓhtａble;
}
inｔhａsｈfuｎ（ｉｎt kｅy）｛retuｒnｋｅｙ%N;}
voidaｄd_hａsh（pｎodｅ*ｈasｈtablｅ，int ｄaｔa）
{
iｆ（!
haｓhtabｌe）{ｐｒｉnｔf（"ｈａshtablｅ=NULＬ＼n"）；returｎ;｝
ﻩｉｎｔ addｒ=hａshfｕn（daｔa）;
ｐｎode ｎeｗnode = （pnode）malloc（sizeoｆ（node））;
ｉf（！
nｅｗnｏｄｅ）｛printf（"canｎｏtmalｌoc\n"）; rｅｔuｒn；}
ﻩｎeｗnodｅ->nexｔ = NULＬ;
ﻩｎeｗnode－>data=ｄata;
ﻩif（haｓhtabｌｅ[addr]＝=NULL）//这个哈希地址空间为空
ﻩhashtabｌe[aｄdｒ]= neｗnode;
ﻩｅlｓe
ﻩ{//尾插
ｐnodｅｐ=hashtablｅ［aｄdr];
ﻩwhile（p－＞nexｔ!
=NUＬL）//循环结束p指向尾节点
ﻩﻩｐ＝p->next;
//下面将新节点插入到尾部
ｐ->nexｔ=nｅwnodｅ;
ﻩ}
}
voidsｈow_hash（pnodｅ*hａshtabｌe）
｛
ﻩｉnti;
ｆｏr（ｉ＝0;i＜N;ｉ++）
ﻩ{
ﻩprｉnｔf（"[%ｄ]->"，i）;
ﻩif（hasｈtaｂｌe[i]== ＮUＬL）
ﻩﻩprｉnｔf（"^\ｎ＂）;
ﻩｅlse
｛
ﻩpnｏdｅp =ｈasｈｔaｂle［i];
ﻩwhile（p!
=ＮULL）
ﻩ{
ﻩﻩﻩﻩprintf（"%d->",p->dａta）;
ﻩﻩｐ=p－>ｎext;
｝
ﻩﻩprｉntf（"^\n＂）;
}
ﻩ}
}
例题3:
用哈希表来实现一个简单的辞典
#inｃlude #include＜ｍallｏc.ｈ>
#iｎｃlude
#ｄｅfine N １000
tｙｐｅdefｓｔructWｏrds
{
ﻩcharwoｒds[22］;
ﻩｃｈａｒmｅａn[122];
}ｗorｄ，*pword；
tyｐedefstructＮode
｛
ｗordw;
ﻩstructＮｏde＊nｅｘt;
}nｏｄe,＊pnｏdｅ;
pnｏde *ｃｒeate_hａｓｈtａble（）；
int gｅtkey（cｈaｒ ＊str）;
iｎｔhaｓhfun（intｋey）;
vｏiｄadd_hash（pnodｅ * hashｔable,ｐｗord pw）;
ｐｗｏrｄfｉnd_hash（pnode*hashtablｅ,chaｒ*wｏrd）；
voidsave（pnoｄe ＊hａshtablｅ）；
voidload（pnｏｄe*hasｈtable）;
iｎtmain（void）
{
ﻩpnodｅ*hashｔａｂle＝ｃreaｔe＿hashtａｂle（）;
ﻩｗoｒｄ w[3]= {"helｌｏ","你好","hｉ","嗨＂,"hｏw aｒeyou＂，＂你最近怎么样"}；
add_hash（hashtaｂle,&w[0]）；
ﻩaｄd＿hａsh（ｈashｔａbｌe,＆w［1]）;
aｄd_hａsｈ（hasｈｔａbｌe,&w［2]）;
//saｖe（ｈashtaｂle）;
//ﻩｌｏad（hashtablｅ）;
chａrstｒ［2２］;
whｉlｅ
（1）
{
ﻩﻩgeｔs（str）;
if（！
stｒcmp（str,"exiｔ"））
rｅtuｒｎ0;
ﻩﻩpwｏrdp = fiｎｄ_hash（hasｈｔabｌe,str）;
ﻩｉf（p==NULL）
ﻩﻩprinｔf（＂没找到\n＂）;
ﻩelsｅ
ﻩprintｆ（"mean：
%s\n",p->mｅan）;
}
ﻩreturn0;
｝
pｎode * crｅatｅ_haｓhtaｂle（）
｛
pnoｄe*hashtablｅ=（pnode*）maｌloｃ（siｚeｏf（pnｏde）*N）;
ﻩｉf（!
hashtable）{ｐrintf（＂hashtａble=ＮULＬ\n"）；}
ﻩmemsｅt（haｓhｔable,０,ｓｉzeof（pｎode）*N）;
ﻩreturnｈaｓｈtaｂle；
}
iｎtgetkey（chａr *sｔｒ）
｛
iｎｔｋey= 0;
ﻩwｈile（*ｓtr!
＝'\0'）
ﻩ{
ﻩﻩkeｙ＝ keｙ +＊sｔr;
ﻩstr++;
}
rｅｔｕrnkey;
}
inthａｓhfun（int key）{reｔurｎkｅｙ％Ｎ;}
voiｄadd_hａsh（pnｏdｅ*hashtａble，pｗordpw）
｛
ﻩｉf（!
hashｔable）{ｐrintf（"haｓhtaｂle = NULL\n＂）; return;}
int addr =haｓｈfun（ ｇetkey（ｐw->ｗoｒds））；
ｐnoｄenewnode =（pｎode）malloc（sizｅoｆ（node））;
ﻩｉｆ（！
newｎode）｛pｒiｎtf（＂cannotmalloc\ｎ"）;reｔｕrn;}
ｎewnｏde->next=NUＬＬ;
mｅmｃpy（&neｗnｏde->w,pw,ｓizeoｆ（wｏrd））;
ﻩｉｆ（hashtａble[aｄdr]＝=ＮULL）
ﻩｈａshtable[adｄr]＝newnｏde;
ｅlsｅ
｛//尾插
ﻩﻩpnodeｐ =hａshtａblｅ［adｄr];
while（ｐ->next！
=ＮULＬ）/／循环结束时，p指向尾节点
ﻩｐ=p->neｘt;
ﻩ
ﻩ//将新节点插入到尾部
ﻩｐ-＞ｎeｘt＝ newnode;
}
}
pｗordfiｎd_hａsｈ（pnｏde * ｈashtable,ｃhar* word）
{
if（!
hａsｈtaｂle）{ｐrｉnｔｆ（＂ｈashｔablｅ＝ NULL\n"）； ｒｅｔｕrnNULL;}
ﻩｉｎt ａｄｄr＝ hashfun（gｅtkey（ｗord））;
ﻩ
ﻩif（ｈashtａbｌe［addr]==NULＬ）
ﻩﻩretｕrnNUＬＬ;
ﻩeｌse
{
ﻩﻩｐnｏdep=hashtable[ａddr］;
ﻩﻩwhｉle（p！
=ＮULL）
ﻩﻩ｛
ﻩｉf（!
strｃmp（p->w．woｒds， ｗord））
ﻩﻩrｅturｎ&p->w;
ﻩﻩﻩｐ=p-＞next;
ﻩ｝
rｅtｕｒnＮULL;
ﻩ}
}
voiｄ saｖe（pnode*hashｔable）
{
FIＬE＊ fp= fopｅn（"data","w＂）;
ﻩiｆ（!
ｆp）｛prｉntf（"cannot openｆile\ｎ"）; returｎ；}
ﻩinｔi;
ﻩpnｏｄe p;
ﻩfoｒ（ｉ=０；i ＜ Ｎ；i＋+）
{
ﻩiｆ（haｓhtａbｌｅ［i]!
=NULL）
ﻩﻩ{
ﻩﻩﻩp =hａｓhｔabｌe［ｉ］;
ﻩwｈile（ｐ !
＝NＵLL）
ﻩﻩ{
ﻩﻩfwrite（&p->w,ｓizｅｏf（ｗord），１,fｐ）;
p=p->ｎext;
}
}
ﻩ｝
fcｌoｓe（fｐ）;
}
void load（pnｏdｅ*hａsｈtabｌｅ）
｛
ﻩFＩLE*fp= foｐen（＂daｔa＂,"r"）；ﻩ
ﻩｉｆ（!
fp）｛prｉnｔf（＂cannotopenfile＼n"）;reｔurn;｝
ﻩｗoｒdw;
while（freaｄ（&w,ｓizeof（w）,1,ｆp）>0）
ﻩadd_hash（hashtablｅ,&w）；
ﻩfcloｓe（fｐ）；
｝
升级会员 