哈希表命令

1. 谁能帮我解释一下“哈希表”的详细含义谢谢了

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
[编辑本段]基本概念
* 若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数(Hash function)，按这个思想建立的表为散列表。 * 对不同的关键字可能得到同一散列地址，即key1≠key2，而f(key1)=f(key2)，这种现象称冲突。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述，根据散列函数H(key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“象” 作为记录在表中的存储位置，这种表便称为散列表，这一映象过程称为散列造表或散列，所得的存储位置称散列地址。 * 若对于关键字集合中的任一个关键字，经散列函数映象到地址集合中任何一个地址的概率是相等的，则称此类散列函数为均匀散列函数(Uniform Hash function)，这就是使关键字经过散列函数得到一个“随机的地址”，从而减少冲突。
[编辑本段]常用的构造散列函数的方法
散列函数能使对一个数据序列的访问过程更加迅速有效，通过散列函数，数据元素将被更快地定位ǐ 1. 直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a•key + b，其中a和b为常数（这种散列函数叫做自身函数） 2. 数字分析法 3. 平方取中法 4. 折叠法 5. 随机数法 6. 除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p, p<=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生同义词。
[编辑本段]处理冲突的方法
1. 开放寻址法：Hi=(H(key) + di) MOD m, i=1,2,…, k(k<=m-1)，其中H(key)为散列函数，m为散列表长，di为增量序列，可有下列三种取法： 1. di=1,2,3,…, m-1，称线性探测再散列； 2. di=1^2, (-1)^2, 2^2,(-2)^2, (3)^2, …, ±(k)^2,(k<=m/2)称二次探测再散列; 3. di=伪随机数序列，称伪随机探测再散列。 == 2. 再散列法：Hi=RHi(key), i=1,2,…,k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。 3. 链地址法(拉链法) 4. 建立一个公共溢出区
[编辑本段]查找的性能分析
散列表的查找过程基本上和造表过程相同。一些关键码可通过散列函数转换的地址直接找到，另一些关键码在散列函数得到的地址上产生了冲突，需要按处理冲突的方法进行查找。在介绍的三种处理冲突的方法中，产生冲突后的查找仍然是给定值与关键码进行比较的过程。所以，对散列表查找效率的量度，依然用平均查找长度来衡量。 查找过程中，关键码的比较次数，取决于产生冲突的多少，产生的冲突少，查找效率就高，产生的冲突多，查找效率就低。因此，影响产生冲突多少的因素，也就是影响查找效率的因素。影响产生冲突多少有以下三个因素： 1. 散列函数是否均匀； 2. 处理冲突的方法； 3. 散列表的装填因子。 散列表的装填因子定义为：α= 填入表中的元素个数 / 散列表的长度 α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，填入表中的元素较多，产生冲突的可能性就越大；α越小，填入表中的元素较少，产生冲突的可能性就越小。 实际上，散列表的平均查找长度是装填因子α的函数，只是不同处理冲突的方法有不同的函数。 了解了hash基本定义，就不能不提到一些着名的hash算法，MD5 和 SHA-1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。那么他们都是什么意思呢? 这里简单说一下： （1) MD4 MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。 （2) MD5 MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好 （3) SHA-1 及其他 SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。 那么这些Hash算法到底有什么用呢? Hash算法在信息安全方面的应用主要体现在以下的3个方面： （1) 文件校验 我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。 MD5 Hash算法的"数字指纹"特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。 （2) 数字签名 Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。 对 Hash 值，又称"数字摘要"进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。 （3) 鉴权协议 如下的鉴权协议又被称作挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。 MD5、SHA1的破解 2004年8月17日，在美国加州圣芭芭拉召开的国际密码大会上，山东大学王小云教授在国际会议上首次宣布了她及她的研究小组近年来的研究成果——对MD5、HAVAL－128、MD4和RIPEMD等四个着名密码算法的破译结果。 次年二月宣布破解SHA-1密码。
[编辑本段]实际应用
以上就是一些关于hash以及其相关的一些基本预备知识。那么在emule里面他具体起到什么作用呢? 大家都知道emule是基于P2P （Peer-to-peer的缩写，指的是点对点的意思的软件）， 它采用了"多源文件传输协议”(MFTP，the Multisource FileTransfer Protocol)。在协议中，定义了一系列传输、压缩和打包还有积分的标准，emule 对于每个文件都有md5-hash的算法设置，这使得该文件独一无二，并且在整个网络上都可以追踪得到。 什么是文件的hash值呢? MD5-Hash-文件的数字文摘通过Hash函数计算得到。不管文件长度如何，它的Hash函数计算结果是一个固定长度的数字。与加密算法不同，这一个Hash算法是一个不可逆的单向函数。采用安全性高的Hash算法，如MD5、SHA时，两个不同的文件几乎不可能得到相同的Hash结果。因此，一旦文件被修改，就可检测出来。 当我们的文件放到emule里面进行共享发布的时候，emule会根据hash算法自动生成这个文件的hash值，他就是这个文件唯一的身份标志，它包含了这个文件的基本信息,然后把它提交到所连接的服务器。当有他人想对这个文件提出下载请求的时候， 这个hash值可以让他人知道他正在下载的文件是不是就是他所想要的。尤其是在文件的其他属性被更改之后（如名称等）这个值就更显得重要。而且服务器还提供了,这个文件当前所在的用户的地址,端口等信息,这样emule就知道到哪里去下载了。 一般来讲我们要搜索一个文件，emule在得到了这个信息后，会向被添加的服务器发出请求，要求得到有相同hash值的文件。而服务器则返回持有这个文件的用户信息。这样我们的客户端就可以直接的和拥有那个文件的用户沟通，看看是不是可以从他那里下载所需的文件。 对于emule中文件的hash值是固定的，也是唯一的，它就相当于这个文件的信息摘要，无论这个文件在谁的机器上，他的hash值都是不变的，无论过了多长时间，这个值始终如一，当我们在进行文件的下载上传过程中，emule都是通过这个值来确定文件。 那么什么是userhash呢? 道理同上，当我们在第一次使用emule的时候，emule会自动生成一个值，这个值也是唯一的，它是我们在emule世界里面的标志，只要你不卸载，不删除config，你的userhash值也就永远不变，积分制度就是通过这个值在起作用，emule里面的积分保存，身份识别，都是使用这个值，而和你的id和你的用户名无关，你随便怎么改这些东西，你的userhash值都是不变的，这也充分保证了公平性。其实他也是一个信息摘要，只不过保存的不是文件信息，而是我们每个人的信息。 那么什么是hash文件呢? 我们经常在emule日志里面看到，emule正在hash文件，这里就是利用了hash算法的文件校验性这个功能了，文章前面已经说了一些这些功能，其实这部分是一个非常复杂的过程，目前在ftp,bt等软件里面都是用的这个基本原理，emule里面是采用文件分块传输，这样传输的每一块都要进行对比校验，如果错误则要进行重新下载，这期间这些相关信息写入met文件，直到整个任务完成，这个时候part文件进行重新命名，然后使用move命令，把它传送到incoming文件里面，然后met文件自动删除，所以我们有的时候会遇到hash文件失败，就是指的是met里面的信息出了错误不能够和part文件匹配，另外有的时候开机也要疯狂hash，有两种情况一种是你在第一次使用，这个时候要hash提取所有文件信息，还有一种情况就是上一次你非法关机，那么这个时候就是要进行排错校验了。 关于hash的算法研究，一直是信息科学里面的一个前沿，尤其在网络技术普及的今天，他的重要性越来越突出，其实我们每天在网上进行的信息交流安全验证，我们在使用的操作系统密钥原理，里面都有它的身影，特别对于那些研究信息安全有兴趣的朋友，这更是一个打开信息世界的钥匙，他在hack世界里面也是一个研究的焦点。 一般的线性表、树中，记录在结构中的相对位置是随机的即和记录的关键字之间不存在确定的关系，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较”的基础上，查找的效率与比较次数密切相关。理想的情况是能直接找到需要的记录，因此必须在记录的存储位置和它的关键字之间建立一确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。因而查找时，只需根据这个对应关系f找到给定值K的像f(K)。若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上，由此不需要进行比较便可直接取得所查记录。在此，称这个对应关系f为哈希函数，按这个思想建立的表为哈希表（又称为杂凑法或散列表）。 哈希表不可避免冲突(collision)现象：对不同的关键字可能得到同一哈希地址 即key1≠key2，而hash(key1)=hash(key2)。具有相同函数值的关键字对该哈希函数来说称为同义词(synonym)。 因此，在建造哈希表时不仅要设定一个好的哈希函数，而且要设定一种处理冲突的方法。可如下描述哈希表：根据设定的哈希函数H(key)和所选中的处理冲突的方法，将一组关键字映象到一个有限的、地址连续的地址集(区间)上并以关键字在地址集中的“象”作为相应记录在表中的存储位置，这种表被称为哈希表。 对于动态查找表而言，1) 表长不确定；2)在设计查找表时，只知道关键字所属范围，而不知道确切的关键字。因此，一般情况需建立一个函数关系，以f(key)作为关键字为key的录在表中的位置，通常称这个函数f(key)为哈希函数。(注意：这个函数并不一定是数学函数) 哈希函数是一个映象，即：将关键字的集合映射到某个地址集合上，它的设置很灵活，只要这个地址集合的大小不超出允许范围即可。 现实中哈希函数是需要构造的，并且构造的好才能使用的好。 用途：加密，解决冲突问题。。。。 用途很广，比特精灵中就使用了哈希函数，你可 以自己看看。 具体可以学习一下数据结构和算法的书。
[编辑本段]字符串哈希函数
（着名的ELFhash算法） int ELFhash(char *key) { unsigned long h=0; while(*key) { h=(h<<4)+*key++; unsigned long g=h&0Xf0000000L; if(g) h^=g>>24; h&=~g; } return h%MOD; }

2. 哈希表的查找性能

散列表的查找过程基本上和造表过程相同。一些关键码可通过散列函数转换的地址直接找到，另一些关键码在散列函数得到的地址上产生了冲突，需要按处理冲突的方法进行查找。在介绍的三种处理冲突的方法中，产生冲突后的查找仍然是给定值与关键码进行比较的过程。所以，对散列表查找效率的量度，依然用平均查找长度来衡量。
查找过程中，关键码的比较次数，取决于产生冲突的多少，产生的冲突少，查找效率就高，产生的冲突多，查找效率就低。因此，影响产生冲突多少的因素，也就是影响查找效率的因素。影响产生冲突多少有以下三个因素：
1. 散列函数是否均匀；
2. 处理冲突的方法；
3. 散列表的装填因子。
散列表的装填因子定义为：α= 填入表中的元素个数 / 散列表的长度
α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，填入表中的元素较多，产生冲突的可能性就越大；α越小，填入表中的元素较少，产生冲突的可能性就越小。
实际上，散列表的平均查找长度是装填因子α的函数，只是不同处理冲突的方法有不同的函数。
了解了hash基本定义，就不能不提到一些着名的hash算法，MD5 和 SHA-1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。那么他们都是什么意思呢?
这里简单说一下：
⑴ MD4
MD4(RFC 1320）是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。
⑵ MD5
MD5(RFC 1321）是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好
⑶ SHA-1 及其他
SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举（brute-force）性更好。SHA-1 设计时基于和MD4相同原理，并且模仿了该算法。
那么这些Hash算法到底有什么用呢?
Hash算法在信息安全方面的应用主要体现在以下的3个方面：
⑴ 文件校验
我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测出数据传输中的信道误码，但却不能防止对数据的恶意破坏。
MD5 Hash算法的数字指纹特性，使它成为目前应用最广泛的一种文件完整性校验和（Checksum）算法，不少Unix系统有提供计算md5 checksum的命令。
⑵ 数字签名
Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。对 Hash 值，又称数字摘要进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。
⑶ 鉴权协议
如下的鉴权协议又被称作挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。
MD5、SHA1的破解
2004年8月17日，在美国加州圣芭芭拉召开的国际密码大会上，山东大学王小云教授在国际会议上首次宣布了她及她的研究小组的研究成果——对MD5、HAVAL－128、MD4和RIPEMD等四个着名密码算法的破译结果。2005年2月宣布破解SHA-1密码。

3. 哈希表在计算机中有什么用，急用！先谢谢啊！

哈希表

基本概念
* 若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数(Hash function)，按这个思想建立的表为散列表。 * 对不同的关键字可能得到同一散列地址，即key1≠key2，而f(key1)=f(key2)，这种现象称冲突。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述，根据散列函数H(key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“象” 作为记录在表中的存储位置，这种表便称为散列表，这一映象过程称为散列造表或散列，所得的存储位置称散列地址。 * 若对于关键字集合中的任一个关键字，经散列函数映象到地址集合中任何一个地址的概率是相等的，则称此类散列函数为均匀散列函数(Uniform Hash function)，这就是使关键字经过散列函数得到一个“随机的地址”，从而减少冲突。
常用的构造散列函数的方法
散列函数能使对一个数据序列的访问过程更加迅速有效，通过散列函数，数据元素将被更快地定位ǐ 1. 直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a•key + b，其中a和b为常数（这种散列函数叫做自身函数） 2. 数字分析法 3. 平方取中法 4. 折叠法 5. 随机数法 6. 除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p, p<=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生同义词。
处理冲突的方法
1. 开放寻址法：Hi=(H(key) + di) MOD m, i=1,2,…, k(k<=m-1)，其中H(key)为散列函数，m为散列表长，di为增量序列，可有下列三种取法： 1. di=1,2,3,…, m-1，称线性探测再散列； 2. di=1^2, (-1)^2, 2^2,(-2)^2, (3)^2, …, ±(k)^2,(k<=m/2)称二次探测再散列; 3. di=伪随机数序列，称伪随机探测再散列。 == 2. 再散列法：Hi=RHi(key), i=1,2,…,k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。 3. 链地址法(拉链法) 4. 建立一个公共溢出区
查找的性能分析
散列表的查找过程基本上和造表过程相同。一些关键码可通过散列函数转换的地址直接找到，另一些关键码在散列函数得到的地址上产生了冲突，需要按处理冲突的方法进行查找。在介绍的三种处理冲突的方法中，产生冲突后的查找仍然是给定值与关键码进行比较的过程。所以，对散列表查找效率的量度，依然用平均查找长度来衡量。 查找过程中，关键码的比较次数，取决于产生冲突的多少，产生的冲突少，查找效率就高，产生的冲突多，查找效率就低。因此，影响产生冲突多少的因素，也就是影响查找效率的因素。影响产生冲突多少有以下三个因素： 1. 散列函数是否均匀； 2. 处理冲突的方法； 3. 散列表的装填因子。 散列表的装填因子定义为：α= 填入表中的元素个数 / 散列表的长度 α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，填入表中的元素较多，产生冲突的可能性就越大；α越小，填入表中的元素较少，产生冲突的可能性就越小。 实际上，散列表的平均查找长度是装填因子α的函数，只是不同处理冲突的方法有不同的函数。 了解了hash基本定义，就不能不提到一些着名的hash算法，MD5 和 SHA-1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。那么他们都是什么意思呢? 这里简单说一下： （1) MD4 MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。 （2) MD5 MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好 （3) SHA-1 及其他 SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。 那么这些Hash算法到底有什么用呢? Hash算法在信息安全方面的应用主要体现在以下的3个方面： （1) 文件校验 我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。 MD5 Hash算法的"数字指纹"特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。 （2) 数字签名 Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。 对 Hash 值，又称"数字摘要"进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。 （3) 鉴权协议 如下的鉴权协议又被称作挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。 MD5、SHA1的破解 2004年8月17日，在美国加州圣芭芭拉召开的国际密码大会上，山东大学王小云教授在国际会议上首次宣布了她及她的研究小组近年来的研究成果——对MD5、HAVAL－128、MD4和RIPEMD等四个着名密码算法的破译结果。 次年二月宣布破解SHA-1密码。
实际应用
以上就是一些关于hash以及其相关的一些基本预备知识。那么在emule里面他具体起到什么作用呢? 大家都知道emule是基于P2P （Peer-to-peer的缩写，指的是点对点的意思的软件）， 它采用了"多源文件传输协议”(MFTP，the Multisource FileTransfer Protocol)。在协议中，定义了一系列传输、压缩和打包还有积分的标准，emule 对于每个文件都有md5-hash的算法设置，这使得该文件独一无二，并且在整个网络上都可以追踪得到。 什么是文件的hash值呢? MD5-Hash-文件的数字文摘通过Hash函数计算得到。不管文件长度如何，它的Hash函数计算结果是一个固定长度的数字。与加密算法不同，这一个Hash算法是一个不可逆的单向函数。采用安全性高的Hash算法，如MD5、SHA时，两个不同的文件几乎不可能得到相同的Hash结果。因此，一旦文件被修改，就可检测出来。 当我们的文件放到emule里面进行共享发布的时候，emule会根据hash算法自动生成这个文件的hash值，他就是这个文件唯一的身份标志，它包含了这个文件的基本信息,然后把它提交到所连接的服务器。当有他人想对这个文件提出下载请求的时候， 这个hash值可以让他人知道他正在下载的文件是不是就是他所想要的。尤其是在文件的其他属性被更改之后（如名称等）这个值就更显得重要。而且服务器还提供了,这个文件当前所在的用户的地址,端口等信息,这样emule就知道到哪里去下载了。 一般来讲我们要搜索一个文件，emule在得到了这个信息后，会向被添加的服务器发出请求，要求得到有相同hash值的文件。而服务器则返回持有这个文件的用户信息。这样我们的客户端就可以直接的和拥有那个文件的用户沟通，看看是不是可以从他那里下载所需的文件。 对于emule中文件的hash值是固定的，也是唯一的，它就相当于这个文件的信息摘要，无论这个文件在谁的机器上，他的hash值都是不变的，无论过了多长时间，这个值始终如一，当我们在进行文件的下载上传过程中，emule都是通过这个值来确定文件。 那么什么是userhash呢? 道理同上，当我们在第一次使用emule的时候，emule会自动生成一个值，这个值也是唯一的，它是我们在emule世界里面的标志，只要你不卸载，不删除config，你的userhash值也就永远不变，积分制度就是通过这个值在起作用，emule里面的积分保存，身份识别，都是使用这个值，而和你的id和你的用户名无关，你随便怎么改这些东西，你的userhash值都是不变的，这也充分保证了公平性。其实他也是一个信息摘要，只不过保存的不是文件信息，而是我们每个人的信息。 那么什么是hash文件呢? 我们经常在emule日志里面看到，emule正在hash文件，这里就是利用了hash算法的文件校验性这个功能了，文章前面已经说了一些这些功能，其实这部分是一个非常复杂的过程，目前在ftp,bt等软件里面都是用的这个基本原理，emule里面是采用文件分块传输，这样传输的每一块都要进行对比校验，如果错误则要进行重新下载，这期间这些相关信息写入met文件，直到整个任务完成，这个时候part文件进行重新命名，然后使用move命令，把它传送到incoming文件里面，然后met文件自动删除，所以我们有的时候会遇到hash文件失败，就是指的是met里面的信息出了错误不能够和part文件匹配，另外有的时候开机也要疯狂hash，有两种情况一种是你在第一次使用，这个时候要hash提取所有文件信息，还有一种情况就是上一次你非法关机，那么这个时候就是要进行排错校验了。 关于hash的算法研究，一直是信息科学里面的一个前沿，尤其在网络技术普及的今天，他的重要性越来越突出，其实我们每天在网上进行的信息交流安全验证，我们在使用的操作系统密钥原理，里面都有它的身影，特别对于那些研究信息安全有兴趣的朋友，这更是一个打开信息世界的钥匙，他在hack世界里面也是一个研究的焦点。 一般的线性表、树中，记录在结构中的相对位置是随机的即和记录的关键字之间不存在确定的关系，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较”的基础上，查找的效率与比较次数密切相关。理想的情况是能直接找到需要的记录，因此必须在记录的存储位置和它的关键字之间建立一确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。因而查找时，只需根据这个对应关系f找到给定值K的像f(K)。若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上，由此不需要进行比较便可直接取得所查记录。在此，称这个对应关系f为哈希函数，按这个思想建立的表为哈希表（又称为杂凑法或散列表）。 哈希表不可避免冲突(collision)现象：对不同的关键字可能得到同一哈希地址 即key1≠key2，而hash(key1)=hash(key2)。具有相同函数值的关键字对该哈希函数来说称为同义词(synonym)。 因此，在建造哈希表时不仅要设定一个好的哈希函数，而且要设定一种处理冲突的方法。可如下描述哈希表：根据设定的哈希函数H(key)和所选中的处理冲突的方法，将一组关键字映象到一个有限的、地址连续的地址集(区间)上并以关键字在地址集中的“象”作为相应记录在表中的存储位置，这种表被称为哈希表。 对于动态查找表而言，1) 表长不确定；2)在设计查找表时，只知道关键字所属范围，而不知道确切的关键字。因此，一般情况需建立一个函数关系，以f(key)作为关键字为key的录在表中的位置，通常称这个函数f(key)为哈希函数。(注意：这个函数并不一定是数学函数) 哈希函数是一个映象，即：将关键字的集合映射到某个地址集合上，它的设置很灵活，只要这个地址集合的大小不超出允许范围即可。 现实中哈希函数是需要构造的，并且构造的好才能使用的好。 用途：加密，解决冲突问题。。。。 用途很广，比特精灵中就使用了哈希函数，你可 以自己看看。 具体可以学习一下数据结构和算法的书。
字符串哈希函数
（着名的ELFhash算法） int ELFhash(char *key) { unsigned long h=0; while(*key) { h=(h<<4)+*key++; unsigned long g=h&0Xf0000000L; if(g) h^=g>>24; h&=~g; } return h%MOD; }

4. 哈希表查找的相关概念

HASH全称是“Hash House Harriers”（简称“Hash"、“HHH”，或“ 3H” ），是一项世界性的休闲活动，起源于1938年马来西亚的吉隆坡，如今在全世界184个国家几千个城市中都有开展，包括中国的北京、广州、上海、深圳、乌鲁木齐等城市。

Hash活动没有固定的成员和组织，也不存在固定的模式，各个城市的具体做法各有不同，但所有的hash都有两个共同的主题：跑步和啤酒，其参加者也因此自称“The running club with a drinking problem”。经过几十年的发展，hash活动已经超越简单的体育锻炼活动，而形成了一种特色鲜明、独具魅力的文化。

一、Hash活动崇尚一种自然健康、团结友爱、积极向上、挑战自我的精神。

Hash中最重要的一件事就是跑步，而且是有趣味、有难度的跑步。每次活动都有一两名参加者志愿充当“兔子”（hare）的角色，事先在野外设置好错综复杂的路线，而自称为猎狗（harriers）的参加者则追踪而至，顶着烈日骄阳或淋着瓢泼大雨，寻找兔子留下的蛛丝马迹。不论是攀山越岭还是涉水过河，是披荆斩棘还是踏污踩粪，只要是兔子布下的路线，猎狗们就义无反顾地一跑到底，决不偷工减料。这样一两个小时跑下来，不仅锻炼了身体，更磨炼了意志。猎狗们在追踪过程中，每到一个岔路口，都需要分工协作，分头找路，才能最快地找到正确的道路。而遇上沟沟坎坎或荆棘刺丛的时候，参加者更是会伸出手来互相帮助。如果有人迷了路，他不仅会经历一次对自己应变能力的挑战，更将体会到同伴在寻找他的过程中表现出来的团结和友爱。

二、Hash活动体现了一种幽默、开朗、豁达而且自然随意的生活态度。

在钢筋混凝土丛林中忙碌的现代人最需要的就是贴近自然，放松紧张的身心，而这也正是参加hash的人们所推崇的生活方式。

幽默可是说是全世界hash参加者的共性。他们最擅长的就是自嘲——自称为“猎狗”，海口的hash参加者还自称为“害虫”，每个人有一个可笑甚至恶心的外号，比如“卖女孩的小火柴”、“肉肉”、“肮脏的鱼”等等。唱歌、讲故事、说笑话、相互捉弄、插科打诨……每一次hash活动都充满欢笑和快乐。

看看沾满泥水的跑鞋和挂满草刺的小腿，畅饮一口冰啤酒高歌一曲，不由得豪气顿生，早不见了办公室里拘谨刻板的模样。新老朋友一起在空旷的野外大声喊叫，放肆地说笑话逗乐子，纵情地歌唱和欢笑，在音乐声中又闹又跳，疲倦的是躯体，而心灵得到了彻底的放松。

Hash活动过程中不准从事商业活动，不准打手机，不准谈工作，所有参加者都以绰号互称，远离铜臭气和复杂的人事关系，为纯真的友谊提供了生长的环境。难怪Hash里面许多人成了意气相投的好朋友之后，才猛然发现原来自己连对方是做什么生意的、有没有结婚都不知道。

Hash活动不以营利为目的，每次活动的结余归入基金供大活动时支出；所有工作都由参加者齐心协力地完成；每期的兔子可以按自己的意愿自由地组织一次跑步。这正是hash的魅力所在：为参加者提供一个可以尽情展现真我的机会。

正是出于对大自然的热爱，Hash参加者们对环境保护尤为重视。空瓶空罐绝对不允许乱扔、垃圾袋必须是可降解塑料做的、不准拈花惹草、不得踩坏庄稼、等等，这些规矩都是每一位hash参加者严格恪守，并在生活中也身体力行的。海口hash的参加者还曾组织过在五指山顶、牙龙湾、尖峰岭等风景点清理垃圾的活动。

三、Hash还是一项各种文化汇集、交流的活动。

Hash活动不仅仅是体育休闲活动。Hash参加者强烈的表现欲在这一宽松的环境中得到鼓励和张扬。他们创造了种种个性鲜明的hash徽标，改编了上千首hash歌曲，制作了不计其数的、风格各异的T恤、帽子、杯垫，出版了大量或精美或简陋然而同样精彩的hash杂志、报纸、宣传册，在Internet上，只要输入“hash”或者“hhh”进行搜索，可以发现成百上千个hash网站。可以说，hash已经有了自己的文化。参加过hash活动后，有人可能会不喜欢这种文化，可是没有人会忘记这样一种文化。它自有它独特的、令人无法忘怀的风味。

在衍生出自己的文化之外，Hash活动从一开始就体现了不同文化的碰撞和交流。第一次hash跑步，就是由旅居马来西亚的英国人组织的。世界各地的hash，吸引了各种各样不同文化的人参加，尤其是旅居当地的外国人。这一点在英美之外的国家的hash中特别明显。因此，hash除了带有明显的英美文化气息外，还成了各种文化交汇融合的活动。像在中国的大多数hash，就成了各种外国人和中国人共同喜爱的活动，英语成为主要的交流手段，而他们的徽标、T恤设计中却透着浓郁的中国文化气息。Hash还是一个全球性的休闲活动，除了各地自有的hash活动，还有定期举行的“泛亚hash”、“泛太平洋hash”等等区域性的活动，每四年还有一次“全球hash”。这种大规模的hash，更是云集来自世界各地的爱好者，无形中也就是一次文化的盛会。Hash活动于生俱来的宽容和自由的特性，为各种不同文化背景的参加者提供了一个平等、宽松、随意、自由发挥的环境。所有的参加者自由地来，自由地去，各人对各人的言行和安全负责，不论国籍、年龄、种族、肤色、职业、教育程度如何，都只是“猎狗”或者“兔子”这两种角色之一种，以绰号相称，甚至真名都不为人知。在“跑步”和“啤酒”这两个主题下，参加者们彻底放下面子和成见，打破各种人为的隔阂和壁垒，真正玩到一块儿，发展友谊，取长补短，尽情展现各自的风采。

海口的hash最早也是由外国人发起，除了旅居海口的外国人，还吸引了许多外企的白领和英语爱好者参加。后来由于爱好hash的外国人逐渐离开海口，现在参加海口hash的主要是中国人，其中大部分是旅居海口的内地人。Hash本身的渊源、活动形式及其精神都带有浓厚的西方文化色彩，必然会对其参与者造成一定的影响，而中国古老的文化也给海口hash烙上独特的印迹。

海口hash的参与者有老有少、有男有女，分别来自社会各个层面，有着不同的文化素养和人生观。他们来参加hash，不仅面对hash本身具有的西方文化的冲击，而且也面临着相互间不同观念带来的冲突。但只要是热爱运动和自然的人，在接受hash的同时，也就会接受hash宽容、自由的氛围及其多姿多彩的文化，自然也就会变得更宽容、更善于理解他人。

正是由于hash具有这样独特的文化魅力，这项休闲活动才持续了近70年而不衰，风靡全球几千个城市，受到各界的广泛关注。尤其是定期举行的跨地区的hash，比如环亚太地区的hash，或者环东南亚的hash，每次都在不同的城市举行，对于举办城市来说，这无疑是当地旅游业发展的一次良好契机。

新闻

四川新闻网-成都商报讯 “兔子快跑，不要回头看，5只猎狗就在你身后，就要追上来了。”昨日下午，以玉林北路为中心，东南西北四个方向的大街上，突然出现了20多个在炎炎烈日下，流着大汗不停奔跑的年轻人。他们是“成都在线”的年轻网友们，他们将整个城市当成了他们的“游乐场”，玩起了风靡全球的健康休闲游戏——“城市猎狗行动”。看来，这种客居异乡的外国人的传统聚会方式已渐渐变成成都白领热爱的休闲活动。

名词解释
城市猎狗行动全称为Hash House Harriers，是一项世界性的休闲健身活动，代表的是一种健康、真实、自然而又稍带一点另类气息的生活态度。在全世界的几千个城市中都有开展。HASH活动并没有固定的模式，各个城市的做法各有不同，也不存在固定的HASH成员和组织，但跑步和啤酒是所有HASH中不可缺少的。
HASH规则源于传统的英国式的纸片追踪游戏。现在，HASH已经遍及全世界，许多人甚至以到世界各地参加HASH、收集不同的HASH T恤为乐。第一次比赛时，输的一方必须坐冰。

行动规则
兔子先跑，
猎狗按箭头追

昨日下午2时许，陆续有网友出现在玉林北路的凹凸酒吧里。“我是兔子，网名‘笑死人了’报到”，“我是猎狗，网名‘大乖’，我分在哪一组哦？”面对这群叽叽喳喳的年轻人，工作人员“冰心洋娃娃”等吼到声音发哑才将他们一一安排到位：兔子8人，穿上统一的红色T恤，分东南西北四个方向跑，每个方向两人，一男一女。猎狗19人，按方向分着白、蓝、绿、黑色T恤。

扮兔子的人手一册地图，他们将按照地图上的路线逃跑。兔子出发15分钟后，猎狗开始行动，他们事先不知道兔子的奔跑路线，只能根据兔子在每个转弯处留下的箭头进行寻找。在兔子跑回酒吧前，如果猎狗抓到一只兔子，猎狗就赢了，反之，就算兔子赢。

捕猎开始
跑晕了，
兔子被猎狗
堵在门口吃掉

“预备，跑！”下午3时10分，8只兔子踏上了逃命之旅，为防作弊，他们的手机全被随队人员缴获。东线，经一环路、科华路、人民南路等处回到起点；南线，经神仙树北路、倪家桥等处；西线，经芳草街、肖家河沿街、永丰立交桥、玉林南路等；北线，经一环路、洗面桥街、电信路、人民南路等。

满怀信心，北线兔子—“麦子”和“阿拉蕾”用了十多秒就跑到了第一个路口，他们在地上贴上了第一个转弯标志——一个宽约15厘米，长约30厘米的不干胶箭头。太阳当空照，又跑了100多米，“阿拉蕾”再也跑不动了，“麦子”只好忍痛抛下她继续逃命。跑到电信路时，“麦子”已经累得无法迈步了，不时向后张望，生怕猎狗追上来了。“你们在比赛哟，加油，小伙子！”路边一位大爷见状忙给他打气。在大爷的鼓励下，“麦子”又来了精神。3时50分左右，“麦子”第一个成功逃脱追捕，回到酒吧。

而其他各线情况就有些不妙了——西线兔子贴错了路标，东线猎狗“大乖”稀里糊涂抄了近路。南线兔子“天才狼”更绝，由于路线错得太离谱，他比所有人晚到了近半个小时，不幸成为猎狗们在酒吧门口用守株待兔的方法抓到的惟一一只兔子。

惩罚方式
坐在冰堆上，将一瓶啤酒喝光

尽管猎狗们对比赛规则持诸多保留意见，比如等待15分钟太长，兔子们留在路上的箭头容易被路人或风带走等，但经大家友好协商，组织者“成都在线”管理员“蛇蝎子”仍判定东线和北线兔子赢，南线和贴错了路标的西线兔子输。迎接输家的将是全球通行的惩罚方式——在刺骨的冰块堆上坐着喝完一瓶啤酒。

在尖叫声中，上千块冰块分两层铺到了一张椅子上。“天才狼”被罚第一个坐冰块。但屁股刚挨到椅子，“天才狼”就被冷得弹了起来，在掌声和笑声中，两名网友上前按住他的肩，他只好强忍寒冷，大喊着“凉快”，喝完了啤酒。除了西线兔子“笑死人了”辩解成功外，剩下的输家都一一坐上了冰椅。

组织者说
耍的就是一个“鲜”

“成都在线”网站管理员“蛇蝎子”告诉记者，几个月前他偶然在网上看到了风靡全球的“城市猎狗行动”——HASH，于是，两个星期前，他们开始筹划成都网友自己的HASH，并制作了衣服和路标。“成都在线”的网友们大多是年轻人，不喜欢打麻将斗地主，追求的是一种属于城市年轻人的独特耍法，要的就是积极健康，新鲜刺激。“我们大多数人都不知道彼此的真实姓名和职业，这让我们可以抛开各自现实生活中的身份和地位，在运动和体验中获得一种单纯的快乐，这就是我们所要的耍法”。

据悉，“成都在线”的网友们常常在网上发起各种新鲜的玩耍方式，比如“城市边缘角色体验”、“车聊”等，哪个网友想参加活动，留下自己的网名和联系方式即可。

网友自白
坐烦了，
何不出来遛遛？

参加昨日“城市猎狗行动”的网友，大多是年龄在25岁左右的年轻人，不少是金融业、策划行业、设计行业的白领人士。平时，他们大多呆在写字楼里，缺乏运动，昨日，他们获得了一次难得的放松。

“麦子”（平面设计师）——
尽管我是第一个到达终点的“兔子”，但平时，我成天呆在办公室里，很少有机会活动筋骨。唉，工作忙啊。所以一看到网友们在组织这个活动，我高兴坏了，马上就报名当一只“兔子”。尽管被5只“猎狗”追，但我很有信心。不过这一趟跑下来，我简直累得上气不接下气，看来，得加强锻炼了。

“大乖”（电子科大大四学生）——
我是被大家公认为跑得最快的“猎狗”，只差10秒钟就抓到“兔子”了。其实他们哪里晓得，我是因为不识路才抄了近路，正所谓“塞翁失马焉知非福”呵。
我马上就快毕业了，将和他们一样，坐进写字楼，以电梯代步，运动的机会越来越少了。所以，这次行动我岂能错过！

基本知识

Hash，一般翻译做“散列”，也有直接音译为”哈希“的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

HASH主要用于信息安全领域中加密算法，他把一些不同长度的信息转化成杂乱的128位的编码里,叫做HASH值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系

了解了hash基本定义，就不能不提到一些着名的hash算法，MD5 和 SHA1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。那么他们都是什么意思呢?

这里简单说一下：

（1) MD4

MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。

（2) MD5

MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好

（3) SHA1 及其他

SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。

那么这些Hash算法到底有什么用呢?

Hash算法在信息安全方面的应用主要体现在以下的3个方面：

（1) 文件校验

我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。

MD5 Hash算法的"数字指纹"特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。

（2) 数字签名

Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。 对 Hash 值，又称"数字摘要"进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。

（3) 鉴权协议

如下的鉴权协议又被称作挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。以上就是一些关于hash以及其相关的一些基本预备知识。那么在emule里面他具体起到什么作用呢?

什么是文件的hash值呢?

大家都知道emule是基于P2P （Peer-to-peer的缩写，指的是点对点的意思的软件）， 它采用了"多源文件传输协议”(MFTP，the Multisource FileTransfer Protocol)。在协议中，定义了一系列传输、压缩和打包还有积分的标准，emule 对于每个文件都有md5-hash的算法设置，这使得该文件独一无二，并且在整个网络上都可以追踪得到。

MD5-Hash-文件的数字文摘通过Hash函数计算得到。不管文件长度如何，它的Hash函数计算结果是一个固定长度的数字。与加密算法不同，这一个Hash算法是一个不可逆的单向函数。采用安全性高的Hash算法，如MD5、SHA时，两个不同的文件几乎不可能得到相同的Hash结果。因此，一旦文件被修改，就可检测出来。

当我们的文件放到emule里面进行共享发布的时候，emule会根据hash算法自动生成这个文件的hash值，他就是这个文件唯一的身份标志，它包含了这个文件的基本信息,然后把它提交到所连接的服务器。当有他人想对这个文件提出下载请求的时候， 这个hash值可以让他人知道他正在下载的文件是不是就是他所想要的。尤其是在文件的其他属性被更改之后（如名称等）这个值就更显得重要。而且服务器还提供了,这个文件当前所在的用户的地址,端口等信息,这样emule就知道到哪里去下载了。

一般来讲我们要搜索一个文件，emule在得到了这个信息后，会向被添加的服务器发出请求，要求得到有相同hash值的文件。而服务器则返回持有这个文件的用户信息。这样我们的客户端就可以直接的和拥有那个文件的用户沟通，看看是不是可以从他那里下载所需的文件。

对于emule中文件的hash值是固定的，也是唯一的，它就相当于这个文件的信息摘要，无论这个文件在谁的机器上，他的hash值都是不变的，无论过了多长时间，这个值始终如一，当我们在进行文件的下载上传过程中，emule都是通过这个值来确定文件。

那么什么是userhash呢?

道理同上，当我们在第一次使用emule的时候，emule会自动生成一个值，这个值也是唯一的，它是我们在emule世界里面的标志，只要你不卸载，不删除config，你的userhash值也就永远不变，积分制度就是通过这个值在起作用，emule里面的积分保存，身份识别，都是使用这个值，而和你的id和你的用户名无关，你随便怎么改这些东西，你的userhash值都是不变的，这也充分保证了公平性。其实他也是一个信息摘要，只不过保存的不是文件信息，而是我们每个人的信息。

那么什么是hash文件呢?

我们经常在emule日至里面看到，emule正在hash文件，这里就是利用了hash算法的文件校验性这个功能了，文章前面已经说了一些这些功能，其实这部分是一个非常复杂的过程，目前在ftp,bt等软件里面都是用的这个基本原理，emule里面是采用文件分块传输，这样传输的每一块都要进行对比校验，如果错误则要进行重新下载，这期间这些相关信息写入met文件，直到整个任务完成，这个时候part文件进行重新命名，然后使用move命令，把它传送到incoming文件里面，然后met文件自动删除，所以我们有的时候会遇到hash文件失败，就是指的是met里面的信息出了错误不能够和part文件匹配，另外有的时候开机也要疯狂hash，有两种情况一种是你在第一次使用，这个时候要hash提取所有文件信息，还有一种情况就是上一次你非法关机，那么这个时候就是要进行排错校验了。

关于hash的算法研究，一直是信息科学里面的一个前沿，尤其在网络技术普及的今天，他的重要性越来越突出，其实我们每天在网上进行的信息交流安全验证，我们在使用的操作系统密钥原理，里面都有它的身影，特别对于那些研究信息安全有兴趣的朋友，这更是一个打开信息世界的钥匙，他在hack世界里面也是一个研究的焦点。

5. 哈希表，求最小值

HashTable table1 = new HashTable();
HashTable table2 = new HashTable();
table1.put("one","1");
table2.put("one","2");
table1.put("two","1");
table2.put("two","2");
for (Iterator iter = table1.keySet().iterator();
iter.hasNext(); ) {
Object keyString = (Object) iter.next();
Object valueObject = table1.get(keyString);
int oneValue = Integer.parseInt((String)valueObject );
int twoValue = Integer.parseInt((String)table2.get(keyString) );
if(oneValue > twoValue){
System.out.println("KEY是"+keyString+"Value"+twoValue);
}else if(oneValue < twoValue){
System.out.println("KEY是"+keyString+"Value"+oneValue);
}else{
System.out.println("KEY是"+keyString+"两值相等"+oneValue);
}
}

6. 高分悬赏 题目：哈希表查询设计及实现

/*
（1）设计哈希表，该表应能够容纳50个英文单词。
（2）对该哈希表进行查询，实现对特定单词的快速查询，并显示经过的节点内容
已经发到你邮箱里了 [email protected]
*/
#include <conio.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define szNAME 80
#define HASH_ROOT 47 /*用于计算哈希地址的随机数*/
#define szHASH 50 /*哈希表总长度*/
#define POPULATION 30 /*学生总数*/

/*哈希表结构体*/
struct THash {
int key; /*钥匙码*/
char name[10]; /*姓名*/
int depth; /*检索深度*/
};

/*根据钥匙码和哈希根计算哈希地址*/
int GetHashAddress(int key, int root)
{
return key % root;
}/*end GetHashAddress*/

/*冲突地址计算，如果发现地址冲突，则用当前地址和钥匙码、哈希根重新生成一个新地址*/
int GetConflictAddress(int key, int address, int root)
{
int addr = address + key % 5 + 1;
return addr % root;
}/*end GetConflictAddress*/

/*根据字符串生成哈希钥匙码，这里的方法是将串内所有字符以数值形式求累加和*/
int CreateKey(char * name)
{
int key = 0;
unsigned char * n = (unsigned char *)name;
while(*n) key += *n++;
return key;
}/*end CreateKey*/

/*输入一个名字，并返回哈希钥匙码*/
int GetName(char * name)
{
scanf("%s", name);
return CreateKey(name);
}/*end CreateKey*/

/*根据学生人数、长度和哈希根构造哈希表*/
struct THash * CreateNames(int size, int root, int population)
{
int i =0, key = 0, addr = 0, depth = 0; char name[10];
struct THash * h = 0, *hash = 0;

/*哈希根和长度不能太小*/
if(size < root || root < 2) return 0;

/*根据哈希表长度构造一个空的哈希表*/
hash = (struct THash *)malloc(sizeof(struct THash) * size);

/*将整个表清空*/
memset(hash, 0, sizeof(struct THash) * size);

for(i = 0; i < population; i++) {
/*首先产生一个随机的学生姓名，并根据姓名计算哈希钥匙码，再根据钥匙码计算地址*/
key = GetName(name);
addr = GetHashAddress(key, root);
h = hash + addr;
if (h->depth == 0) { /*如果当前哈希地址没有被占用，则存入数据*/
h->key = key;
strcpy(h->name , name);
h->depth ++;
continue;
}/*end if*/
/*如果哈希地址已经被占用了，就是说有冲突，则寻找一个新地址，直到没有被占用*/
depth = 0;
while(h->depth ) {
addr = GetConflictAddress(key, addr, root);
h = hash + addr;
depth ++;
}/*end while*/
/*按照新地址存放数据，同时记录检索深度*/
h->key = key;
strcpy(h->name , name);
h->depth = depth + 1;
}/*next*/
return hash;
}/*end CreateNames*/

/*在哈希表中以特定哈希根查找一个学生的记录*/
struct THash * Lookup(struct THash * hash, char * name, int root)
{
int key = 0, addr = 0; struct THash * h = 0;
/*不接受空表和空名称*/
if(!name || !hash) return 0;
key = CreateKey(name);
addr = GetHashAddress(key, root);
h = hash + addr;
/*如果结果不正确表示按照冲突规则继续寻找*/
while(strcmp(h->name , name)) {
addr = GetConflictAddress(key, addr, root);
h = hash + addr;
if(h->key == 0) return 0;
}/*end while*/
return hash + addr;
}/*end Lookup*/

/*根据一条哈希表记录打印该记录的学生信息*/
void Print(struct THash * record)
{
if (!record) {
printf("【查无此人】\n");
return ;
}/*end if*/
if(record->depth)
printf("【钥匙码】%04d\t【姓名】%s\t【检索深度】%d\n", record->key, record->name, record->depth );
else
printf("【空记录】\n");
/*end if*/
}/*end Print*/

/*打印学生花名册*/
void Display(struct THash * hash, int size)
{
struct THash * h = 0;
if (!hash || size < 1) return ;
printf("学生花名册：\n");
printf("--------------------\n");
for(h = hash; h < hash + size; h++) {
printf("【地址】%d\t", h - hash);
Print(h);
}/*next*/
printf("--------------------\n");
}/*end Display*/

/*主函数，程序入口*/
int main(void)
{
/*哈希表变量声明*/
struct THash * hash = 0, * h = 0;
int cmd = 0; /*命令*/
char name[10]; /*学生姓名*/

/*生成30个学生用的哈希表*/
hash = CreateNames(szHASH, HASH_ROOT, POPULATION);
for(;;) {
printf("哈希表展示：1-显示哈希表；2-检索姓名；其他任意键退出：\n");
cmd = getch();
cmd -= '0';
switch(cmd) {
case 1: Display(hash, szHASH); break;
case 2:
printf("请输入要检索的学生姓名：");
scanf("%s", name);
h = Lookup(hash, name, HASH_ROOT);
printf("【地址】%d\t", h - hash);
Print(h);
break;
default:
free(hash);
return 0;
}/*end case*/
}/*next*/
return 0;
}/*end main*/

7. 哈希表的设计与实现(线性探测再散列法解决冲突）

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
[编辑本段]基本概念
* 若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数(Hash function)，按这个思想建立的表为散列表。 * 对不同的关键字可能得到同一散列地址，即key1≠key2，而f(key1)=f(key2)，这种现象称冲突。具有相同函数值的关键字对该散列函数来说称做同义词。综上所述，根据散列函数H(key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集（区间）上，并以关键字在地址集中的“象” 作为记录在表中的存储位置，这种表便称为散列表，这一映象过程称为散列造表或散列，所得的存储位置称散列地址。 * 若对于关键字集合中的任一个关键字，经散列函数映象到地址集合中任何一个地址的概率是相等的，则称此类散列函数为均匀散列函数(Uniform Hash function)，这就是使关键字经过散列函数得到一个“随机的地址”，从而减少冲突。
[编辑本段]常用的构造散列函数的方法
散列函数能使对一个数据序列的访问过程更加迅速有效，通过散列函数，数据元素将被更快地定位ǐ 1. 直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a•key + b，其中a和b为常数（这种散列函数叫做自身函数） 2. 数字分析法 3. 平方取中法 4. 折叠法 5. 随机数法 6. 除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p, p<=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生同义词。
[编辑本段]处理冲突的方法
1. 开放寻址法：Hi=(H(key) + di) MOD m, i=1,2,…, k(k<=m-1)，其中H(key)为散列函数，m为散列表长，di为增量序列，可有下列三种取法： 1. di=1,2,3,…, m-1，称线性探测再散列； 2. di=1^2, (-1)^2, 2^2,(-2)^2, (3)^2, …, ±(k)^2,(k<=m/2)称二次探测再散列; 3. di=伪随机数序列，称伪随机探测再散列。 == 2. 再散列法：Hi=RHi(key), i=1,2,…,k RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。 3. 链地址法(拉链法) 4. 建立一个公共溢出区
[编辑本段]查找的性能分析
散列表的查找过程基本上和造表过程相同。一些关键码可通过散列函数转换的地址直接找到，另一些关键码在散列函数得到的地址上产生了冲突，需要按处理冲突的方法进行查找。在介绍的三种处理冲突的方法中，产生冲突后的查找仍然是给定值与关键码进行比较的过程。所以，对散列表查找效率的量度，依然用平均查找长度来衡量。 查找过程中，关键码的比较次数，取决于产生冲突的多少，产生的冲突少，查找效率就高，产生的冲突多，查找效率就低。因此，影响产生冲突多少的因素，也就是影响查找效率的因素。影响产生冲突多少有以下三个因素： 1. 散列函数是否均匀； 2. 处理冲突的方法； 3. 散列表的装填因子。 散列表的装填因子定义为：α= 填入表中的元素个数 / 散列表的长度 α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，填入表中的元素较多，产生冲突的可能性就越大；α越小，填入表中的元素较少，产生冲突的可能性就越小。 实际上，散列表的平均查找长度是装填因子α的函数，只是不同处理冲突的方法有不同的函数。 了解了hash基本定义，就不能不提到一些着名的hash算法，MD5 和 SHA-1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。那么他们都是什么意思呢? 这里简单说一下： （1) MD4 MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。 （2) MD5 MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好 （3) SHA-1 及其他 SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。 那么这些Hash算法到底有什么用呢? Hash算法在信息安全方面的应用主要体现在以下的3个方面： （1) 文件校验 我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。 MD5 Hash算法的"数字指纹"特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。 （2) 数字签名 Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。 对 Hash 值，又称"数字摘要"进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。 （3) 鉴权协议 如下的鉴权协议又被称作挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。 MD5、SHA1的破解 2004年8月17日，在美国加州圣芭芭拉召开的国际密码大会上，山东大学王小云教授在国际会议上首次宣布了她及她的研究小组近年来的研究成果——对MD5、HAVAL－128、MD4和RIPEMD等四个着名密码算法的破译结果。 次年二月宣布破解SHA-1密码。
[编辑本段]实际应用
以上就是一些关于hash以及其相关的一些基本预备知识。那么在emule里面他具体起到什么作用呢? 大家都知道emule是基于P2P （Peer-to-peer的缩写，指的是点对点的意思的软件）， 它采用了"多源文件传输协议”(MFTP，the Multisource FileTransfer Protocol)。在协议中，定义了一系列传输、压缩和打包还有积分的标准，emule 对于每个文件都有md5-hash的算法设置，这使得该文件独一无二，并且在整个网络上都可以追踪得到。 什么是文件的hash值呢? MD5-Hash-文件的数字文摘通过Hash函数计算得到。不管文件长度如何，它的Hash函数计算结果是一个固定长度的数字。与加密算法不同，这一个Hash算法是一个不可逆的单向函数。采用安全性高的Hash算法，如MD5、SHA时，两个不同的文件几乎不可能得到相同的Hash结果。因此，一旦文件被修改，就可检测出来。 当我们的文件放到emule里面进行共享发布的时候，emule会根据hash算法自动生成这个文件的hash值，他就是这个文件唯一的身份标志，它包含了这个文件的基本信息,然后把它提交到所连接的服务器。当有他人想对这个文件提出下载请求的时候， 这个hash值可以让他人知道他正在下载的文件是不是就是他所想要的。尤其是在文件的其他属性被更改之后（如名称等）这个值就更显得重要。而且服务器还提供了,这个文件当前所在的用户的地址,端口等信息,这样emule就知道到哪里去下载了。 一般来讲我们要搜索一个文件，emule在得到了这个信息后，会向被添加的服务器发出请求，要求得到有相同hash值的文件。而服务器则返回持有这个文件的用户信息。这样我们的客户端就可以直接的和拥有那个文件的用户沟通，看看是不是可以从他那里下载所需的文件。 对于emule中文件的hash值是固定的，也是唯一的，它就相当于这个文件的信息摘要，无论这个文件在谁的机器上，他的hash值都是不变的，无论过了多长时间，这个值始终如一，当我们在进行文件的下载上传过程中，emule都是通过这个值来确定文件。 那么什么是userhash呢? 道理同上，当我们在第一次使用emule的时候，emule会自动生成一个值，这个值也是唯一的，它是我们在emule世界里面的标志，只要你不卸载，不删除config，你的userhash值也就永远不变，积分制度就是通过这个值在起作用，emule里面的积分保存，身份识别，都是使用这个值，而和你的id和你的用户名无关，你随便怎么改这些东西，你的userhash值都是不变的，这也充分保证了公平性。其实他也是一个信息摘要，只不过保存的不是文件信息，而是我们每个人的信息。 那么什么是hash文件呢? 我们经常在emule日志里面看到，emule正在hash文件，这里就是利用了hash算法的文件校验性这个功能了，文章前面已经说了一些这些功能，其实这部分是一个非常复杂的过程，目前在ftp,bt等软件里面都是用的这个基本原理，emule里面是采用文件分块传输，这样传输的每一块都要进行对比校验，如果错误则要进行重新下载，这期间这些相关信息写入met文件，直到整个任务完成，这个时候part文件进行重新命名，然后使用move命令，把它传送到incoming文件里面，然后met文件自动删除，所以我们有的时候会遇到hash文件失败，就是指的是met里面的信息出了错误不能够和part文件匹配，另外有的时候开机也要疯狂hash，有两种情况一种是你在第一次使用，这个时候要hash提取所有文件信息，还有一种情况就是上一次你非法关机，那么这个时候就是要进行排错校验了。 关于hash的算法研究，一直是信息科学里面的一个前沿，尤其在网络技术普及的今天，他的重要性越来越突出，其实我们每天在网上进行的信息交流安全验证，我们在使用的操作系统密钥原理，里面都有它的身影，特别对于那些研究信息安全有兴趣的朋友，这更是一个打开信息世界的钥匙，他在hack世界里面也是一个研究的焦点。 一般的线性表、树中，记录在结构中的相对位置是随机的即和记录的关键字之间不存在确定的关系，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较”的基础上，查找的效率与比较次数密切相关。理想的情况是能直接找到需要的记录，因此必须在记录的存储位置和它的关键字之间建立一确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。因而查找时，只需根据这个对应关系f找到给定值K的像f(K)。若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上，由此不需要进行比较便可直接取得所查记录。在此，称这个对应关系f为哈希函数，按这个思想建立的表为哈希表（又称为杂凑法或散列表）。 哈希表不可避免冲突(collision)现象：对不同的关键字可能得到同一哈希地址 即key1≠key2，而hash(key1)=hash(key2)。具有相同函数值的关键字对该哈希函数来说称为同义词(synonym)。 因此，在建造哈希表时不仅要设定一个好的哈希函数，而且要设定一种处理冲突的方法。可如下描述哈希表：根据设定的哈希函数H(key)和所选中的处理冲突的方法，将一组关键字映象到一个有限的、地址连续的地址集(区间)上并以关键字在地址集中的“象”作为相应记录在表中的存储位置，这种表被称为哈希表。 对于动态查找表而言，1) 表长不确定；2)在设计查找表时，只知道关键字所属范围，而不知道确切的关键字。因此，一般情况需建立一个函数关系，以f(key)作为关键字为key的录在表中的位置，通常称这个函数f(key)为哈希函数。(注意：这个函数并不一定是数学函数) 哈希函数是一个映象，即：将关键字的集合映射到某个地址集合上，它的设置很灵活，只要这个地址集合的大小不超出允许范围即可。 现实中哈希函数是需要构造的，并且构造的好才能使用的好。 用途：加密，解决冲突问题。。。。 用途很广，比特精灵中就使用了哈希函数，你可 以自己看看。 具体可以学习一下数据结构和算法的书。
[编辑本段]字符串哈希函数
（着名的ELFhash算法） int ELFhash(char *key) return h%MOD; }

8. 数据结构哈希表，求大神，急急急

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 20
#define MAX_SIZE 20 //人名的最大长度
#define HASHSIZE 60 //定义表长
#define SUCCESS 1
#define UNSUCCESS -1
typedef int Status; //为现有类型添加一个同义字
typedef char NA[MAX_SIZE]; // typedef 掩饰数组类型
typedef struct //记录
{
NA name;
NA xuehao; //关键字
NA tel;
}Stu; //查找表中记录类型

typedef struct //建立哈希表
{
Stu *elem[HASHSIZE]; //数据元素存储基址
int cou; //当前数据元素个数
int siz; //当前容量
}HashTable;

Status eq(NA x,NA y)
{
if(strcmp(x,y)==0)
return SUCCESS;
else return UNSUCCESS;
}

Status NUM_BER; //记录的个数 全局变量
Status NUM_BER1;

void Create(Stu* a) //创建新的通讯录
{
system("CLS"); //调用DOS命令CLS能够清屏
int i;
FILE *fp1,*fp2;
if((fp1=fopen("record.txt","r"))!=NULL) //打开文件
{
fclose(fp1); //关闭文件
}
else
{
fp2=fopen("record.txt","w"); //如果不存在,就创建一个record.txt
fclose(fp2);
}
printf("\n输入要添加的个数：\n");
scanf("%d",&NUM_BER);
for(i=0;i<NUM_BER;i++)
{
printf("请输入第%d个记录的姓名:\n",i+1);
scanf("%s",a[i].name);
printf("请输入%d个记录的学号:\n",i+1);
scanf("%s",a[i].xuehao);
printf("请输入第%d个记录的电话号码:\n",i+1);
scanf("%s",a[i].tel);
}
getchar();
printf("添加成功!!!\n");

}

void getin(Stu * a) //录入通讯录的内容，传入一个record的指针，然后针对这个指针指向的内存记录进行操作
{int i;
system("cls"); //调用DOS命令CLS能够清屏
printf("输入要添加的个数：\n");
scanf("%d",&NUM_BER);
for(i=0;i<NUM_BER;i++)
{
printf("请输入第%d个记录的姓名:\n",i+1);
scanf("%s",a[i].name);
printf("请输入%d个记录的学号:\n",i+1);
scanf("%s",a[i].xuehao);
printf("请输入第%d个记录的电话号码:\n",i+1);
scanf("%s",a[i].tel);
}
}
void output(Stu* a) //显示输入的用户信息
{int i;
system("cls");
printf(" \n姓名\t学号\t\t电话号码");
for( i=0;i<NUM_BER;i++)
printf("\n%s\t%s\t\t%s",a[i].name,a[i].xuehao,a[i].tel);
}
int Hash(NA name)
{
int i,m;
i = 1;
m=(int)name[0];//强制转化成数字
while(name[i]!='\0')
{
m+=(int)name[i];
i++;
}
m=m%HASHSIZE;
return m;
}

Status collision(int p,int c) //冲突处理函数，采用二次探测法解决冲突 //二次探测法处理冲突
{
int i,q;
i=c/2+1;
while(i<HASHSIZE)
{
if(c%2==0)
{
c++;
q=(p+i*i)%HASHSIZE;
if(q>=0) return q;
else i=c/2+1;
}
else
{
q=(p-i*i)%HASHSIZE;
c++;
if(q>=0) return q;
else i=c/2+1;
}
}
return UNSUCCESS;
}

void CreateHash(HashTable* H,Stu* a) //建表，以人的姓名为关键字，建立相应的哈希表
{ int i,p=-1,c,pp;
system("cls");//若哈希地址冲突，进行冲突处理
for(i=0;i<NUM_BER+NUM_BER1;i++)
{
c=0;
p=Hash(a[i].name);
pp=p;
while(H->elem[pp]!=NULL)
{
pp=collision(p,c); //若哈希地址冲突，进行冲突处理
if(pp<0)
{
printf("第%d记录无法解决冲突",i+1); //需要显示冲突次数时输出
continue; //无法解决冲突，跳入下一循环
}
}
H->elem[pp]=&(a[i]); //求得哈希地址，将信息存入
H->cou++;
printf("第%d个记录冲突次数为%d。\n",i+1,c);
}
printf("\n建表完成!\n此哈希表容量为%d,当前表内存储的记录个数为%d.\n",HASHSIZE,H->cou);

}

void SearchHash(HashTable* H,int c) //在通讯录里查找姓名关键字，c用来记录冲突次数，若查找成功，显示信息
{
int p,pp;NA NAME;
system("cls");
printf("\n请输入要查找记录的姓名：\n");
scanf("%s",NAME);
p=Hash(NAME);
pp=p;
while((H->elem[pp]!=NULL)&&(eq(NAME,H->elem[pp]->name)==-1))
pp=collision(p,c);
if(H->elem[pp]!=NULL&&eq(NAME,H->elem[pp]->name)==1)
{
printf("\n查找成功！\n查找过程冲突次数为%d．以下是您需要要查找的信息：\n\n",c);
printf("姓名：%s\n学号：%s\n电话号码：%s\n",H->elem[pp]->name,H->elem[pp]->xuehao,H->elem[pp]->tel);
}
else printf("\n此人不存在，查找不成功!\n");

}

void Modify(HashTable* H,int c) //在通讯录里修改某人信息
{
int p,pp;NA NAME;
system("cls");
printf("\n请输入要修改记录的姓名：\n");
scanf("%s",NAME);
p=Hash(NAME);
pp=p;
while((H->elem[pp]!=NULL)&&(eq(NAME,H->elem[pp]->tel)==-1))
pp=collision(p,c);
if(H->elem[pp]!=NULL&&eq(NAME,H->elem[pp]->tel)==1)
{
printf("\n以下是您需要修改的信息：");
printf("姓名：%s\n学号：%s\n电话号码：%s\n",H->elem[pp]->name,H->elem[pp]->xuehao,H->elem[pp]->tel);
(H->elem)[pp]->tel[0]='\0';
printf("请输入修改后记录的姓名:\n");
scanf("%s",H->elem[pp]->name);
printf("请输入修改后记录的学号:\n");
scanf("%s",H->elem[pp]->xuehao);
printf("请输入修改后记录的电话号码:\n");
scanf("%s",H->elem[pp]->tel);
printf("修改成功!");
}
else
printf("\n此人不存在，修改不成功!\n");
}

void Delete(HashTable* H,int c) //在通讯录里查找姓名关键字，若查找成功，显示信息然后删除
{
int m,p,pp;NA str;
m=0;
system("cls");
printf("\n请输入要删除记录的姓名：\n");
m++;
scanf("%s",str);
p=Hash(str);
pp=p;
while((H->elem[pp]!=NULL)&&(eq(str,H->elem[pp]->name)==-1))
pp=collision(p,c);
if(H->elem[pp]!=NULL&&eq(str,H->elem[pp]->name)==1)
{
printf("\n以下是您需要要删除的信息：\n\n",c);
printf("姓名：%s\n学号：%s\n电话号码：%s\n",H->elem[pp]->name,H->elem[pp]->xuehao,H->elem[pp]->tel);
(H->elem)[pp]->name[0]='\0';
printf("删除成功!!!");
}
else
printf("\n此人不存在，删除不成功!\n");
}
void Save(HashTable * H) //将记录保存到指定文件
{
system("CLS");
int i;
FILE* fp;
if((fp=fopen("record.txt","w"))!=NULL)
{
fprintf(fp,"==================== 班级通讯录 ===================\n");
for(i=0;i<HASHSIZE;i++)
{
if((H->elem)[i]!='\0')
{
fprintf(fp,"学生姓名:%s\n",H->elem[i]->name);
fprintf(fp,"学生学号:%s\n",H->elem[i]->xuehao);
fprintf(fp,"学生电话号码:%s\n",H->elem[i]->tel);
fprintf(fp,"***********************************************\n");
}
}
fclose(fp);
printf("==================== 班级通讯录 ===================\n");
printf("\n\n恭喜你!!成功储存，你能在record.txt找到相应纪录\n");
system("pause");
}
else
{
printf("抱歉，保存记录失败！！");
system("pause");
}
}

int main()
{
Stu a[MAXSIZE];
int c,flag=1,i=0;
HashTable *H;
H=(HashTable*)malloc(sizeof(HashTable));
for(i=0;i<HASHSIZE;i++)
{
H->elem[i]=NULL;
H->siz=HASHSIZE;
H->cou=0;
}
while (1)
{ int num;

printf("\n");
printf("\n***************************班级通讯录****************************");
printf("\n* 【1】. 创建用户信息 *");
printf("\n* 【2】. 添加用户信息 *");
printf("\n* 【3】. 显示所有用户信息 *");
printf("\n* 【4】. 以姓名建立哈希表（二次探测法解决冲突）*");
printf("\n* 【5】. 查找用户信息 *");
printf("\n* 【6】. 删除用户信息 *");
printf("\n* 【7】. 修改用户信息 *");
printf("\n* 【8】. 保存 *");
printf("\n* 【9】. 退出程序 *");
printf("\n*****************************************************************");
printf("\n");
printf("\n* 温馨提示： *");
printf("\n* 进行4、5、6操作前 请先输出3 *");
printf("\n*****************************************************************");
printf("\n请输入一个任务选项>>>");
printf("\n");
scanf("%d",&num);
switch(num)
{
case 1:Create(a) ;break;
case 2:getin(a); break;
case 3:output(a); break;
case 4:CreateHash(H,a); break;
case 5:c=0;SearchHash(H,c); break;
case 6:c=0;Delete(H,c); break;
case 7:c=0;Modify(H,c); break;
case 8:Save(H); break;
case 9:return 0; break;
default:
printf("输入错误，请重新输入!");
printf("\n");
}
}
system("pause");
return 0;
}

9. 哈希表的实际应用

以上就是一些关于hash以及其相关的一些基本预备知识。那么在emule里面他具体起到什么作用呢?
大家都知道emule是基于P2P （Peer-to-peer的缩写，指的是对等连接的软件）， 它采用了多源文件传输协议”（MFTP，the Multisource FileTransfer Protocol）。在协议中，定义了一系列传输、压缩和打包还有积分的标准，emule 对于每个文件都有md5-hash的算法设置，这使得该文件独一无二，并且在整个网络上都可以追踪得到。
什么是文件的hash值呢?
MD5-Hash-文件的数字文摘通过Hash函数计算得到。不管文件长度如何，它的Hash函数计算结果是一个固定长度的数字。与加密算法不同，这一个Hash算法是一个不可逆的单向函数。采用安全性高的Hash算法，如MD5、SHA时，两个不同的文件几乎不可能得到相同的Hash结果。因此，一旦文件被修改，就可检测出来。
当我们的文件放到emule里面进行共享发布的时候，emule会根据hash算法自动生成这个文件的hash值，他就是这个文件唯一的身份标志，它包含了这个文件的基本信息，然后把它提交到所连接的服务器。当有他人想对这个文件提出下载请求的时候， 这个hash值可以让他人知道他正在下载的文件是不是就是他所想要的。尤其是在文件的其他属性被更改之后（如名称等）这个值就更显得重要。而且服务器还提供了，这个文件当前所在的用户的地址，端口等信息，这样emule就知道到哪里去下载了。
一般来讲我们要搜索一个文件，emule在得到了这个信息后，会向被添加的服务器发出请求，要求得到有相同hash值的文件。而服务器则返回持有这个文件的用户信息。这样我们的客户端就可以直接的和拥有那个文件的用户沟通，看看是不是可以从他那里下载所需的文件。
对于emule中文件的hash值是固定的，也是唯一的，它就相当于这个文件的信息摘要，无论这个文件在谁的机器上，他的hash值都是不变的，无论过了多长时间，这个值始终如一，当我们在进行文件的下载上传过程中，emule都是通过这个值来确定文件。
那么什么是userhash呢?
道理同上，当我们在第一次使用emule的时候，emule会自动生成一个值，这个值也是唯一的，它是我们在emule世界里面的标志，只要你不卸载，不删除config，你的userhash值也就永远不变，积分制度就是通过这个值在起作用，emule里面的积分保存，身份识别，都是使用这个值，而和你的id和你的用户名无关，你随便怎么改这些东西，你的userhash值都是不变的，这也充分保证了公平性。其实他也是一个信息摘要，只不过保存的不是文件信息，而是我们每个人的信息。
那么什么是hash文件呢?
我们经常在emule日志里面看到，emule正在hash文件，这里就是利用了hash算法的文件校验性这个功能了，文章前面已经说了一些这些功能，其实这部分是一个非常复杂的过程，在ftp,bt等软件里面都是用的这个基本原理，emule里面是采用文件分块传输，这样传输的每一块都要进行对比校验，如果错误则要进行重新下载，这期间这些相关信息写入met文件，直到整个任务完成，这个时候part文件进行重新命名，然后使用move命令，把它传送到incoming文件里面，然后met文件自动删除，所以我们有的时候会遇到hash文件失败，就是指的是met里面的信息出了错误不能够和part文件匹配，另外有的时候开机也要疯狂hash，有两种情况一种是你在第一次使用，这个时候要hash提取所有文件信息，还有一种情况就是上一次你非法关机，那么这个时候就是要进行排错校验了。
关于hash的算法研究，一直是信息科学里面的一个前沿，尤其在网络技术普及的今天，他的重要性越来越突出，其实我们每天在网上进行的信息交流安全验证，我们在使用的操作系统密钥原理，里面都有它的身影，特别对于那些研究信息安全有兴趣的朋友，这更是一个打开信息世界的钥匙，他在hack世界里面也是一个研究的焦点。
一般的线性表、树中，记录在结构中的相对位置是随机的即和记录的关键字之间不存在确定的关系，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较”的基础上，查找的效率与比较次数密切相关。理想的情况是能直接找到需要的记录，因此必须在记录的存储位置和它的关键字之间建立一确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。因而查找时，只需根据这个对应关系f找到给定值K的像f(K）。若结构中存在关键字和K相等的记录，则必定在f(K）的存储位置上，由此不需要进行比较便可直接取得所查记录。在此，称这个对应关系f为哈希函数，按这个思想建立的表为哈希表（又称为杂凑法或散列表）。
哈希表不可避免冲突（collision）现象：对不同的关键字可能得到同一哈希地址 即key1≠key2，而hash(key1)=hash(key2）。具有相同函数值的关键字对该哈希函数来说称为同义词（synonym）。因此，在建造哈希表时不仅要设定一个好的哈希函数，而且要设定一种处理冲突的方法。可如下描述哈希表：根据设定的哈希函数H(key）和所选中的处理冲突的方法，将一组关键字映象到一个有限的、地址连续的地址集（区间）上并以关键字在地址集中的“象”作为相应记录在表中的存储位置，这种表被称为哈希表。
对于动态查找表而言，1) 表长不确定；2）在设计查找表时，只知道关键字所属范围，而不知道确切的关键字。因此，一般情况需建立一个函数关系，以f(key）作为关键字为key的录在表中的位置，通常称这个函数f(key）为哈希函数。（注意：这个函数并不一定是数学函数）
哈希函数是一个映象，即：将关键字的集合映射到某个地址集合上，它的设置很灵活，只要这个地址集合的大小不超出允许范围即可。
现实中哈希函数是需要构造的，并且构造的好才能使用的好。
用途：加密，解决冲突问题。
用途很广，比特精灵中就使用了哈希函数，你可以自己看看。
具体可以学习一下数据结构和算法的书。

10. 求大神细致的介绍下哈希表和循环变量具体的使用方法。

哈希表就是用来存储数据的地方，跟变量的作用类似，变量能做的哈希表也能做，两者效率差不多。

举个例子，游戏开始时记录玩家1初始的黄金、木材和人口，以后不管什么时候，输入1就显示这些数据：

记录时注意目录和标签分别用不同的数字表示。