哈希查找_数据结构实验报告
实验16:哈希查找实验报告参考模板
深圳大学实验报告课程名称:数据结构实验与课程设计实验项目名称:哈希查找实验学院:计算机与软件学院专业:软件工程指导教师:杨芳报告人:薛锡增学号:2013150368 班级: 3 实验时间:2014-12-11实验报告提交时间:2014/12/12教务处制一、实验目的1、掌握哈希查找算法的基本思想2、掌握哈希查找表的构造方法3、掌握链表法解决冲突的方法4、掌握哈希查找的时间性能二、实验要求1、熟悉C++语言编程2、了解哈希查找的原理三、实验内容1、问题描述采用散列表方式,对关键字进行查找。
2、查找算法⑴、利用哈希函数(除留余数法,哈希表长为5)及记录的关键字计算出记录的存储地址⑵、直接到指定地址进行查找⑶、如果查找不成功,则采用(表头插入)链地址法,将记录插入到指定地址所在链表的头上。
3、输入⑴、第一行:测试次数。
⑵、每个样本分2行:第一行:第一个数字n表示样本数目,其后跟n个样本;第二行:查找的关键字的值。
4、输出查找是否成功(1—表示成功,0表示不成功),所在位置(从0开始),查找次数。
5、输入样本25 2 4 9 5 746 2 6 8 4 9 176、输出样本1 4 20 2 2四、程序清单#include<iostream>using namespace std;struct node{int data;node* next;node(){next=NULL;}};const int m=11;int main(){node h[15];int n,i,s;node* p;//freopen("cin1.txt","r",stdin);cin>>n;for(i=0;i<n;i++){cin>>s;p=new node();p->data=s;p->next=h[s%11].next;h[s%11].next=p;}int t;cin>>t;while(t--){cin>>s;int sum=1;p=h[s%11].next;while(p){if(s==p->data){cout<<s%11<<" "<<sum<<endl;break;}sum++;p=p->next;}if(!p){cout<<"error"<<endl;p=new node();p->data=s;p->next=h[s%11].next;h[s%11].next=p;}}return0;}五、程序运行时截图流程图:对逐个输入的数据进行除11取余,放到数组相应的位置上输入数据后对其除11取余到数组相应的位置上进行查找,找到就输出数组下标、数组上的第几个结点六、实验心得与体会(实验中遇到的问题及解决方案,或写点感想)哈希查找还没交,对概念不是很懂,在处理问题上也出现不少小细节,不过最后还是做出来了。
哈希实验报告
引言概述:本文旨在对哈希实验进行报告,重点介绍哈希实验的二次探测法、哈希函数、哈希表的查找、插入与删除操作,并分析实验结果。
通过本实验的开展,我们对哈希算法的原理、实现和性能有了更深入的理解,也增加了对数据结构的实践能力。
正文内容:一、二次探测法1.定义与原理2.步骤与流程3.优缺点分析4.实验过程与结果5.实验中的注意事项二、哈希函数1.哈希函数的设计原则2.常见的哈希函数算法3.哈希冲突与解决方法4.哈希函数的优化策略5.实验中的哈希函数选择与应用三、哈希表的查找操作1.哈希表的存储结构与基本操作2.直接定址法查找3.拉链法查找4.其他查找方法与比较5.实验结果与分析四、哈希表的插入与删除操作1.插入操作的实现思路2.插入操作的效率分析3.删除操作的实现思路4.删除操作的效率分析5.实验结果分析与对比五、实验结果与总结1.实验数据的统计与分析2.实验中的问题与解决方案3.实验结论与总结4.对哈希算法的进一步探讨与应用展望5.实验的意义与启示总结:通过对哈希实验的详细阐述,我们对二次探测法、哈希函数、哈希表的查找、插入与删除操作有了更深入的了解。
实验结果与分析表明,在哈希表的实现中,选择合适的哈希函数、解决哈希冲突以及优化插入与删除操作,对提高哈希表的性能至关重要。
哈希算法作为一种重要的数据结构应用,具有广泛的应用前景,在实际问题中具有重要的实践意义。
通过本次实验,我们不仅提升了对数据结构的理论理解,也增强了数据结构算法的实践能力,为今后的学习与研究打下了坚实的基础。
数据结构哈希表的实验报告
课程实习报告一、需求分析:1.本程序来自于图书馆靠书名来检索想要查找的书问题。
2.本程序要求:(1)根据输入建立图书名称表,采用创建散列表实现。
(2)建散列表后,如果想要查找的数据在散列表中输出yes否则输出no。
二、哈希表简介结构中存在关键字和K相等的记录,则必定存储在f(K)的位置上。
由此,不需比较便可直接取得所查记录。
这个对应关系f称为散列函数(Hash function),按这个思想建立的表为散列表。
* 对不同的关键字可能得到同一散列地址,即key1≠key2,而f(key1)=f(key2),这种现象称冲突。
具有相同函数值的关键字对该散列函数来说称做同义词。
* 综上所述,根据散列函数H(key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集(区间)上,并以关键字在地址集中的“象”,作为这条记录在表中的存储位置,这种表便称为散列表,这一映象过程称为散列造表或散列,所得的存储位置称散列地址。
这个现象也叫散列桶,在散列桶中,只能通过顺序的方式来查找,一般只需要查找三次就可以找到。
科学家计算过,当负载因子(load factor)不超过75%,查找效率最高。
* 若对于关键字集合中的任一个关键字,经散列函数映象到地址集合中任何一个地址的概率是相等的,则称此类散列函数为均匀散列函数(Uniform Hash function),这就是使关键字经过散列函数得到一个“随机的地址”,从而减少冲突。
程序设计流程程序思想(一)哈希函数unsigned int hash_BKDE(char *str)生成映射地址,成为散列表的编号。
(二)哈希表HashTable::HashTable()通过数组储存元素(三)插入函数void HashTable::insert(char*c)插入字符串,先计算要插入字符串生成的映射地址,然后在相应的地址插入,如果没有空位查找空位插入。
(四)查找函数bool HashTable::find(char*c)进行查找,先计算要生成字符串的地址,再到散列表中进行查找比较。
哈工程数据结构实验报告
哈工程数据结构实验报告一、实验目的本实验的目的是通过对于哈工程的数据结构实验的实践操作,掌握并理解数据结构中的哈希表的基本原理、实现方式,以及相关的查找、插入和删除操作。
通过实验的实践操作,进一步加深对于数据结构的理解和运用能力。
二、实验步骤和实验原理1.实验环境本次实验使用的是C++语言在Visual Studio环境下进行开发。
2.实验内容本次实验主要涉及到哈希表的构建和相关操作的实践。
具体步骤如下:(1)首先创建一个结构体,包括学生姓名和学号等信息。
(2)然后定义哈希表的存储结构,其中包括哈希表的大小、装填因子等。
(3)根据哈希表的大小,创建一个存储结点的数组。
(4)实现哈希函数,根据学生学号计算哈希值。
(5)实现插入操作,即将结点插入到哈希表中的合适位置。
(6)实现查找操作,根据学生学号查找对应的结点。
(7)实现删除操作,根据学生学号删除对应的结点。
(8)测试程序的运行效果,包括对哈希表进行插入、查找和删除操作等。
三、实验结果与分析通过对实验的步骤和原理的实践操作,成功构建了一个哈希表,并实现了插入、查找和删除操作。
在实验结果的分析中,可以发现哈希表具有一定的优势:通过哈希函数的映射,可以将元素快速地插入到对应的位置,从而实现了快速的查找和删除操作。
四、实验总结通过本次实验,我对于哈希表的原理、实现方式以及相关操作有了更深刻的理解。
通过实践操作,我进一步加深了对于数据结构的掌握和运用能力。
同时,我也认识到哈希表在实际应用中的重要性和优势,对于提高数据处理和查询效率有着重要的作用。
期待在日后的学习和工作中能够更加深入地学习和应用数据结构的知识,提升自己的技术水平和能力。
查找的算法实验报告
一、实验目的1. 理解并掌握几种常见的查找算法(顺序查找、二分查找等)的原理和实现方法。
2. 分析不同查找算法的时间复杂度和空间复杂度。
3. 通过实际编程,验证不同查找算法的性能差异。
4. 提高算法设计和分析能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 数据结构:列表(List)三、实验内容本次实验主要涉及以下几种查找算法:1. 顺序查找(Linear Search)2. 二分查找(Binary Search)3. 哈希查找(Hash Search)四、实验步骤1. 顺序查找实现顺序查找算法,用于查找列表中是否存在特定元素。
```pythondef linear_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1```2. 二分查找实现二分查找算法,要求列表已排序。
```pythondef binary_search(arr, target):low = 0high = len(arr) - 1while low <= high:mid = (low + high) // 2if arr[mid] == target:return midelif arr[mid] < target:low = mid + 1else:high = mid - 1return -1```3. 哈希查找实现哈希查找算法,使用哈希表存储数据,提高查找效率。
```pythondef hash_search(arr, target):hash_table = {}for i, num in enumerate(arr):hash_table[num] = ireturn hash_table.get(target, -1)```五、实验结果与分析1. 顺序查找- 时间复杂度:O(n)- 空间复杂度:O(1)2. 二分查找- 时间复杂度:O(log n)- 空间复杂度:O(1)3. 哈希查找- 时间复杂度:O(1)- 空间复杂度:O(n)六、实验结论1. 顺序查找算法简单易实现,但效率较低,适用于数据量较小的场景。
哈希表实验报告
数据结构实验报告四——哈希表查找名字(字符串)实验题目:哈希表查找名字(字符串)实验目标:输入一组名字(至少50个),将其保存并利用哈希表查找。
输出哈希查找冲突次数,哈希表负载因子、查找命中率。
数据结构:哈希表和数组(二维)。
二维数组用于静态顺序存储名字(字符串),哈希表采用开放定址法,用于存储名字(字符串)对应的关键字并实现对名字(字符串)的查找。
需要的操作有:1.关键字求取(主函数中两次出现,未单独编为函数)关键字key=abs(字符串首位ASCII码值-第二位ASCII码值+第([]+1)位ASCII码值-最后一位ASCII码值-倒数第二位ASCII码值)*字符串长度(abs为求整数绝对值的函数)。
2.处理关键字的哈希函数(Hash)利用平方取中法求关键值key在哈希表中的位置。
公式add=(key*key)%1000/LENGTH(add 为key在哈希表中的地址)。
int Hash(int key){return((key*key)/1000%LENGTH);}3.处理哈希表中冲突的函数(Collision)利用线性探测再散列处理冲突,利用全局变量count统计冲突次数。
int Collision(int key,int Hashtable[]){int i;for(i=1;i<=LENGTH;i++){if(Hashtable[(Hash(key)+i)%LENGTH]==-1)return((Hash(key)+i)%LENGTH);count++;}}4.哈希表初始化(InitHash)void InitHash(int Hashtable[]){int i;for(i=0;i<LENGTH;i++)Hashtable[i]=-1;}5.向哈希表中插入关键字(InsertHash)void InsertHash(int key,int Hashtable[]){int add;if(Hashtable[add]==-1)Hashtable[add]=key;else{add=Collision(key,Hashtable);Hashtable[add]=key;}}6.查找关键字在哈希表中的存储位置(SearchHash)int SearchHash(int key,int Hashtable[]){int add;add=Hash(key);if(Hashtable[add]==key)return add;while(Hashtable[add]!=key&&Hashtable[add]!=-1)add=Collision(key,Hashtable);return add;}7.输出哈希表(PrintHash)(帮助调试用)void PrintHash(int Hashtable[]){int i;for(i=0;i<LENGTH;i++)if(Hashtable[i]!=-1)printf("%3d:%d\n",i+1,Hashtable[i]);}8.求字符串长度(strlen)(函数库<string.h>包含)以及求整数的绝对值(abs)(函数库<math.h>包含)算法设计:1建立长度为LENGTH的哈希表Hash(LENGTH具体值由宏定义决定)。
数据结构课程设计哈希表实验报告
数据结构课程设计哈希表实验报告数据结构课程设计哈希表实验报告福建工程学院课程设计课程:算法与数据结构题目:哈希表专业:网络工程班级: xxxxxx班座号: xxxxxxxxxxxx姓名: xxxxxxx12 月 31 日实验题目:哈希表一、要解决的问题针对同班同学信息设计一个通讯录,学生信息有姓名,学号,电话号码等。
以学生姓名为关键字设计哈希表,并完成相应的建表和查表程序。
基本要求:姓名以汉语拼音形式,待填入哈希表的人名约30个,自行设计哈希函数,用线性探测再散列法或链地址法处理冲突;在查找的过程中给出比较的次数。
完成按姓名查询的操作。
运行的环境:Microsoft Visual C++ 6.0二、算法基本思想描述设计一个哈希表(哈希表内的元素为自定义的结构体)用来存放待填入的30个人名,人名为中国姓名的汉语拼音形式,用除留余数法构造哈希函数,用线性探查法解决哈希冲突。
建立哈希表而且将其显示出来。
经过要查找的关键字用哈希函数计算出相应的地址来查找人名。
经过循环语句调用数组中保存的数据来显示哈希表。
三、设计1、数据结构的设计和说明(1)结构体的定义typedef struct //记录NA name;NA xuehao;NA tel;}Record;录入信息结构体的定义,包含姓名,学号,电话号码。
typedef struct //哈希表{Record *elem[HASHSIZE]; //数据元素存储基址int count; //当前数据元素个数int size; //当前容量}HashTable;哈希表元素的定义,包含数据元素存储基址、数据元素个数、当前容量。
2、关键算法的设计(1)姓名的折叠处理long fold(NA s) //人名的折叠处理{char *p;long sum=0;NA ss;strcpy(ss,s); //复制字符串,不改变原字符串的大小写strupr(ss); //将字符串ss转换为大写形式p=ss;while(*p!='\0')sum+=*p++;printf("\nsum====================%d",sum);return sum;}(2)建立哈希表1、用除留余数法构建哈希函数2、用线性探测再散列法处理冲突int Hash1(NA str) //哈希函数{long n;int m;n=fold(str); //先将用户名进行折叠处理m=n%HASHSIZE; //折叠处理后的数,用除留余数法构造哈希函数return m; //并返回模值}Status collision(int p,int c) //冲突处理函数,采用二次探测再散列法解决冲突{。
数据结构查找实验报告
数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能比较,分析它们在不同数据规模和分布情况下的效率和适用场景。
二、实验环境本次实验使用的编程语言为 Python 38,开发环境为 PyCharm。
实验中所使用的数据集生成工具为 numpy 库。
三、实验原理1、顺序查找顺序查找是一种最简单的查找算法,它从数据结构的开头依次逐个比较元素,直到找到目标元素或遍历完整个数据结构。
其平均时间复杂度为 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中,利用哈希函数计算元素的存储位置,从而实现快速查找。
理想情况下,其平均时间复杂度为 O(1),但在存在哈希冲突时,性能可能会下降。
四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集,包括有序数据集、无序数据集和具有一定重复元素的数据集。
2、顺序查找实现编写顺序查找算法的函数,接受数据集和目标元素作为参数,返回查找结果(是否找到及查找次数)。
3、二分查找实现实现二分查找算法的函数,同样接受数据集和目标元素作为参数,并返回查找结果。
4、哈希查找实现构建哈希表并实现哈希查找函数,处理哈希冲突的情况。
5、性能比较对不同规模和类型的数据集,分别使用三种查找算法进行查找操作,并记录每种算法的查找时间和查找次数。
五、实验结果与分析1、顺序查找在无序数据集中,顺序查找的性能表现较为稳定,查找时间随着数据规模的增大线性增长。
但在有序数据集中,其性能没有优势。
2、二分查找二分查找在有序数据集中表现出色,查找时间随着数据规模的增大增长缓慢,体现了对数级别的时间复杂度优势。
然而,在无序数据集中无法使用。
哈希表的实验报告
哈希表的实验报告哈希表的实验报告哈希表是一种常见的数据结构,用于存储和查找数据。
在本次实验中,我们将探索哈希表的原理、实现和性能,并通过实验验证其效果。
一、实验目的本次实验的目的是探索哈希表的原理和实现方法,并通过实验测试不同哈希函数和哈希表大小对性能的影响。
二、实验原理哈希表是一种基于哈希函数的数据结构,它将数据存储在数组中,通过哈希函数将数据映射到数组的特定位置。
哈希函数将数据转换为数组的索引,使得数据可以快速存储和查找。
哈希函数的选择很重要,一个好的哈希函数应该具备以下特点:1. 均匀性:哈希函数应该将数据均匀地分布到不同的索引位置,以避免冲突。
2. 高效性:哈希函数应该具有高效的计算速度,以提高哈希表的性能。
3. 低冲突:哈希函数应该尽可能减少冲突的发生,以提高哈希表的查找效率。
三、实验方法1. 实现哈希表:我们首先需要实现一个基本的哈希表数据结构。
哈希表可以使用数组来存储数据,每个数组元素称为一个桶,每个桶可以存储多个数据项。
在实现哈希表时,我们需要考虑如何处理冲突,常见的方法有链地址法和开放地址法。
2. 实现哈希函数:我们需要实现不同的哈希函数,以测试它们的性能。
常见的哈希函数包括除余法、乘法和平方取中法等。
我们可以通过实验比较它们的性能,选择最合适的哈希函数。
3. 测试性能:我们需要设计一系列实验,测试不同哈希函数和哈希表大小对性能的影响。
可以通过插入、查找和删除等操作来评估哈希表的性能。
我们可以记录每个操作的平均时间复杂度和空间占用情况,并绘制图表来展示结果。
四、实验结果与分析通过实验,我们得到了不同哈希函数和哈希表大小下的性能数据。
我们可以观察到不同哈希函数对性能的影响,并选择最优的哈希函数。
同时,我们还可以观察到哈希表大小对性能的影响,选择合适的哈希表大小以平衡性能和空间占用。
五、实验总结本次实验我们深入了解了哈希表的原理和实现方法,并通过实验验证了不同哈希函数和哈希表大小对性能的影响。
数据结构查找实验报告
数据结构查找实验报告数据结构查找实验报告一、引言数据结构是计算机科学中的重要概念之一,它涉及到组织和管理数据的方式和方法。
在实际应用中,我们经常需要对大量的数据进行查找操作,因此查找算法的效率和准确性显得尤为重要。
本实验旨在通过对比不同的查找算法,探索其性能和适用场景。
二、实验目的本实验的目的是比较常见的查找算法,包括线性查找、二分查找和哈希查找,分析它们的时间复杂度和空间复杂度,并通过实验数据验证其效率。
三、实验方法1. 实验环境本实验使用C++语言进行编程,选择了Visual Studio作为开发环境,以保证实验结果的准确性和可靠性。
2. 实验步骤(1)线性查找线性查找是最简单直接的查找算法,它的原理是从头到尾逐个比较待查找元素和数组中的元素,直到找到目标元素或遍历完整个数组。
在实验中,我们随机生成一个包含一定数量元素的有序数组,并使用线性查找算法查找目标元素。
(2)二分查找二分查找是一种高效的查找算法,它基于有序数组的特点,通过不断缩小查找范围来快速定位目标元素。
在实验中,我们同样生成一个有序数组,并使用二分查找算法进行查找操作。
(3)哈希查找哈希查找是一种基于哈希表的查找算法,它通过将关键字映射到哈希表中的位置来实现快速查找。
在实验中,我们使用哈希查找算法对一个包含大量元素的数组进行查找。
四、实验结果与分析1. 时间复杂度通过实验数据统计,我们可以得到不同查找算法的平均时间复杂度。
线性查找的时间复杂度为O(n),其中n为数组的大小;二分查找的时间复杂度为O(logn),哈希查找的时间复杂度为O(1)。
可以看出,随着数据规模增大,二分查找和哈希查找的效率明显高于线性查找。
2. 空间复杂度线性查找的空间复杂度为O(1),即不需要额外的存储空间;二分查找的空间复杂度为O(1),哈希查找的空间复杂度为O(n),其中n为哈希表的大小。
因此,从空间复杂度的角度来看,线性查找和二分查找相对较优。
3. 实验结果通过多次实验,我们得到了不同查找算法的平均查找时间。
数据结构查找算法实验报告
数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能分析,比较它们在不同数据规模和分布情况下的效率和优劣。
二、实验环境操作系统:Windows 10编程语言:Python 3x开发工具:PyCharm三、实验原理1、顺序查找顺序查找是一种最简单的查找算法,从数据结构的起始位置开始,依次比较每个元素,直到找到目标元素或遍历完整个数据结构。
其时间复杂度在最坏情况下为 O(n),平均情况下也接近 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置,如果发生冲突则通过相应的解决冲突策略进行处理。
在理想情况下,其时间复杂度可以接近 O(1)。
四、实验内容及步骤1、顺序查找算法实现```pythondef sequential_search(arr, target):for i in range(len(arr)):if arri == target:return ireturn -1```2、二分查找算法实现```pythondef binary_search(arr, target):low = 0high = len(arr) 1while low <= high:mid =(low + high) // 2if arrmid == target:return midelif arrmid < target:low = mid + 1else:high = mid 1return -1```3、哈希查找算法实现(采用简单的线性探测解决冲突)```pythonclass HashTable:def __init__(self):selfsize = 10selftable = None selfsizedef hash_function(self, key):return key % selfsizedef insert(self, key):index = selfhash_function(key)while selftableindex is not None:index =(index + 1) % selfsize selftableindex = keydef search(self, key):index = selfhash_function(key)original_index = indexwhile selftableindex is not None:if selftableindex == key:return indexindex =(index + 1) % selfsizeif index == original_index:return -1return -1```4、生成不同规模和分布的数据进行测试```pythonimport random生成有序数据def generate_sorted_data(size):return i for i in range(size)生成随机分布数据def generate_random_data(size):return randomrandint(0, size 10) for _ in range(size)```5、性能测试与分析```pythonimport time测试不同算法在不同数据上的查找时间def test_search_algorithms(data, target):start_time = timetime()sequential_search(data, target)sequential_time = timetime() start_timestart_time = timetime()binary_search(sorted(data), target)binary_time = timetime() start_timeht = HashTable()for num in data:htinsert(num)start_time = timetime()htsearch(target)hash_time = timetime() start_timereturn sequential_time, binary_time, hash_time 进行多组实验并取平均值def perform_experiments():sizes = 100, 500, 1000, 5000, 10000 sequential_avg_times =binary_avg_times =hash_avg_times =for size in sizes:sequential_times =binary_times =hash_times =for _ in range(10):进行 10 次实验取平均值sorted_data = generate_sorted_data(size)random_data = generate_random_data(size)target = randomchoice(sorted_data)sequential_time, binary_time, hash_time =test_search_algorithms(random_data, target)sequential_timesappend(sequential_time)binary_timesappend(binary_time)hash_timesappend(hash_time)sequential_avg_timesappend(sum(sequential_times) /len(sequential_times))binary_avg_timesappend(sum(binary_times) / len(binary_times))hash_avg_timesappend(sum(hash_times) / len(hash_times))return sizes, sequential_avg_times, binary_avg_times, hash_avg_times sizes, sequential_avg_times, binary_avg_times, hash_avg_times =perform_experiments()```五、实验结果与分析通过对不同规模数据的实验,得到了以下平均查找时间的结果:|数据规模|顺序查找平均时间|二分查找平均时间|哈希查找平均时间|||||||100|0000123 秒|0000008 秒|0000005 秒||500|0000567 秒|0000021 秒|0000007 秒||1000|0001234 秒|0000035 秒|0000008 秒||5000|0005789 秒|0000123 秒|0000012 秒||10000|0012345 秒|0000234 秒|0000015 秒|从结果可以看出,在数据规模较小时,顺序查找和哈希查找的性能差距不大,二分查找由于需要先对数据进行排序,所以优势不明显。
数据结构实验报告(哈希表)
散列表的设计实验报告1、题目:散列表的设计:针对某个集体中人名设计一个散列表,使得平均查找长度不超过R,并完成相应的建表和查表程序。
2、基本要求:假设人名为中国人姓名的汉语拼音形式。
待填入哈希表的人名共30个,取平均查找长度上限为2,哈希函数用除留余数法构造,用伪随机探测再散列法处理冲突。
人名长度不超过20个字符。
可先对过长的人名作折叠处理。
3、设计思想:a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3)平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址H(key)=key MOD p,p<=m.b.哈希函数可以减少冲突,但不能避免。
通常用的处理冲突的方法有:(1)开放定址法,这种方法还包含三种形式,一种叫线性探测再散列,一种叫二次探测再散列,另一种叫伪随机探测再散列。
本实验采用的是第三种伪随机探测再散列。
求下一个开放地址的公式为:Hi=(H(k)+di)MOD m (Di=伪随机数序列)c.对哈希表的操作InitNameList() 操作结果:姓名(结构体数组)初始化CreateHashList() 操作结果:建立哈希表FindList() 操作结果:在哈希表中查找Display() 操作结果:显示哈希表4、程序结构图5、流程图6、数据测试7、程序清单#include<iostream>#include<string>using namespace std;#define HASH_LENGTH 50#define M 47#define NAME_NO 30typedef struct{ char *py;int k;}NAME;NAME NameList[HASH_LENGTH]; typedef struct{ char *py;int k;int si;//查找长度}HASH;HASH HashList[HASH_LENGTH]; void InitNameList(){ char *f;int r,s0,i;for (i=0; i<HASH_LENGTH; i++){NameList[i].py = new char[20];NameList[i].py[0] = 0;}strcpy(NameList[0].py, "lintingting"); strcpy(NameList[1].py, "chenxiaoping"); strcpy(NameList[2].py, "jianghaiyan"); strcpy(NameList[3].py, "wangtingting"); strcpy(NameList[4].py, "zhouhuihui"); strcpy(NameList[5].py, "zhuzhenguo"); strcpy(NameList[6].py, "wuqingwen"); strcpy(NameList[7].py, "chenzuopeng"); strcpy(NameList[8].py, "jinlining"); strcpy(NameList[9].py, "zhandakan"); strcpy(NameList[10].py, "linjiajia"); strcpy(NameList[11].py, "huangwenjun"); strcpy(NameList[12].py, "lizhongjing"); strcpy(NameList[13].py, "sushiding"); strcpy(NameList[14].py, "ouyangyaoyao"); strcpy(NameList[15].py, "chenwei");strcpy(NameList[16].py, "linxiaxiao"); strcpy(NameList[17].py, "zhanjie");strcpy(NameList[18].py, "baishujun"); strcpy(NameList[19].py, "gongqiaoqiao"); strcpy(NameList[20].py, "lvhaitao"); strcpy(NameList[21].py, "jiangqingsong"); strcpy(NameList[22].py, "gubaolong"); strcpy(NameList[23].py, "yehuaisong"); strcpy(NameList[24].py, "wangyuqin"); strcpy(NameList[25].py, "xuefeifei"); strcpy(NameList[26].py, "wujianshu"); strcpy(NameList[27].py, "zhanghuajiang"); strcpy(NameList[28].py, "zhengpan"); strcpy(NameList[29].py, "sudongdong");for(i=0;i<NAME_NO;i++){s0=0;f=NameList[i].py;for(r=0;*(f+r)!='\0';r++)s0=*(f+r)+s0;NameList[i].k=s0;}}void CreateHashList(){int i;for(i=0; i<HASH_LENGTH;i++){HashList[i].py=new char[20];HashList[i].py[0] = 0;HashList[i].k=0;HashList[i].si=0;}for(i=0;i<HASH_LENGTH;i++){int sum=0;int adr=(NameList[i].k)%M;int d=adr;if(HashList[adr].si==0) //如果不冲突{HashList[adr].k=NameList[i].k;HashList[adr].py=NameList[i].py;HashList[adr].si=1;}else //冲突{while (HashList[d].k!=0){d=(d+NameList[i].k%10+1)%M; //伪随机探测再散列法处理冲突sum=sum+1;};HashList[d].k=NameList[i].k;HashList[d].py=NameList[i].py;HashList[d].si=sum+1;}}}void FindList(){string name;int s0=0,r,sum=1,adr,d;cout<<"请输入人名的拼音:"<<endl;cin>>name;for(r=0;r<20;r++)s0+=name[r];adr=s0%M; //使用哈希函数d=adr;if(HashList[adr].k==s0)cout<<"姓名:"<<HashList[d].py<<endl<<"关键字:"<<s0<<endl<<"查找长度为: 1"<<endl;else if (HashList[adr].k==0)cout<<"无此记录!"<<endl;else{int g=0;while(g==0){d=(d+s0%10+1)%M;sum=sum+1;if(HashList[d].k==0){cout<<"无此记录!"<<endl;g=1;}if(HashList[d].k==s0){cout<<"姓名:"<<HashList[d].py<<endl<<"关键字:"<<s0<<endl<<"查找长度为:"<<sum<<endl;g=1;}};}}void Display(){int i;float average=0;cout<<"\n地址\t关键字\t\t搜索长度\tH(key)\t 姓名\n";for(i=0; i<50; i++){cout<<i<<" ";cout<<"\t"<<HashList[i].k<<" ";cout<<"\t\t"<<HashList[i].si<<" ";cout<<"\t\t"<<(HashList[i].k%M)<<" ";cout<<"\t "<<HashList[i].py<<" ";cout<<"\n";}for(i=0;i<HASH_LENGTH;i++)average+=HashList[i].si;average/=NAME_NO;cout<<"平均查找长度:ASL("<<NAME_NO<<")="<<average<<endl; }int main(){char x;InitNameList(); CreateHashList ();cout<<"d. 显示哈希表"<<endl<<"f. 查找"<<endl<<"任意键退出"<<endl<<"请选择:"<<endl;while(cin>>x){if(x=='d'){Display();cout<<endl;}else if(x=='f'){FindList();cout<<endl;}else break;}for (int i=0; i<HASH_LENGTH; i++){free(NameList[i].py);free(HashList[i].py);}return 0;}。
哈希查找的判断实验报告
数据结构与算法设计实验报告(2016 — 2017 学年第1 学期)实验名称:年级:专业:班级:学号:姓名:指导教师:成都信息工程大学通信工程学院一、实验目的验证哈希查找算法二、实验要求(1)先创建一个数组类型的顺序表,以—1作为结束。
从键盘输入一组数据元素后,按顺序表的遍历输出,并打印显示。
(2)再以哈希函数方式,将数据元素放入哈希表中,并将哈希表输出,并打印显示。
采用线性探测法处理冲突。
注意:哈希表的下标和数据内容都显示到屏幕上。
(3)输入需要查找的任意元素的关键字,查找并输出该元素的位置下标序列号。
若有冲突,显示它原来的下标位置和新的下标位置。
若没有,也将找不到的信息反馈出来。
注意:用线性探测法处理冲突。
三、实验步骤1、创建工程(附带截图说明)2、根据算法编写程序(参见第六部分源代码)3、编译4、调试四、实验结果图五、心得体会本次实验练习了哈希表的创建与查找,虽然在实验过程中遇到了一些困难,但还是在老师及同学的帮助下顺利完成了。
之前学习C语言的时候基础不是很好,经过几次上级实验以及自己私下的练习,编写程序的过程中已经不会出现语法上的错误,节约了很多时间去思考算法设计。
实验过程中,在设计处理冲突的算法时,出现的漏洞较大,加之自己的逻辑产生混乱,出了很多差错。
在查阅资料后,理清了设计思路,从而解决了问题。
六、源代码要求:粘贴个人代码,以便检查。
#include <stdio.h>#define MAXSIZE#define HASHSIZE 13#define DELFLAG -1/*******关键字*******/typedef struct{int key;}DataType;/*******顺序表*******/typedef struct{DataType items[HASHSIZE];int length;}sqList;/*******哈希表*******/typedef struct{DataType data;int times;}HashTable[HASHSIZE];/*******哈希函数*******/int HashFunc(int key){return key %HASHSIZE;}/*******线性探查法*******/int Collision(int d){return(d+1)%HASHSIZE;}/*******哈希表的查找*******/int HashSearch(HashTable ht,DataType item){int addr;addr=HashFunc(item.key);while(ht[addr].data.key!=NULL&&ht[addr].data.key!=item.key) {printf("\n【%d】冲突地址:%d",item.key,addr);addr=Collision(addr);}if(ht[addr].data.key==item.key){return addr;}else{return -addr;}}/*******哈希表的插入*******/int HashInsert(HashTable ht,DataType item){int addr;addr=HashSearch(ht,item);if(addr>0){return 0;}ht[-addr].data=item;ht[-addr].times=1;return 1;}/*******哈希表的创建*******/void CreatHash(HashTable ht,DataType items[],int n) {int i;for(i=0;i<HASHSIZE;i++){ht[i].data.key=NULL;ht[i].times=0;}for(i=0;i<n;i++){HashInsert(ht,items[i]);}}/*******哈希表的删除*******/int HashDelete(HashTable ht,DataType item) {int addr;addr=HashSearch(ht,item);if(addr>=0){ht[addr].data.key=DELFLAG;return 1;}return 0;}/*******哈希表的显示*******/void DisplayHash(HashTable ht){int i;printf("\n\n哈希表\n\n哈希地址:");for(i=0;i<HASHSIZE;i++){printf("%d\t",i);}printf("\n关键字:\t");for(i=0;i<HASHSIZE;i++){if(ht[i].data.key!=NULL){printf("%d\t",ht[i].data.key);}else{printf("\t");}}printf("\n");}void main(){int i;int addr;int choice;HashTable ht;DataType item;sqList L;for(i=0;i<HASHSIZE;i++){L.items[i].key=0;}L.length=0;printf("\n---------哈希查找-------\n");printf("\n请输入要建立哈希表的关键字序列,以空格分隔,以-1结束\n"); for(i=0;i<HASHSIZE;i++){scanf("%d",&L.items[i].key);if(L.items[i].key==-1){break;}L.length++;}while(1){printf("\n---------哈希查找-------\n");printf("1:哈希表操作\n");printf("0:退出\n");printf("------------------\n");printf("请选择:");scanf("%d",&choice);switch(choice){case 1:{printf("\n顺序表为:");for(i=0;i<L.length;i++){printf("%d ",L.items[i].key);}CreatHash(ht,L.items,L.length);DisplayHash(ht);printf("\n请输入查找元素:");scanf("%d",&item.key);addr=HashSearch(ht,item);if(addr>=0){printf("\n【%d】查找到的地址为:\t%d\n",item.key,addr);}else{printf("\n未找到!\n");}break;}case 0:exit(0);default:{printf("\n错误!请重新输入...\n");break;}}getchar();}}。
哈希查找数据结构试验报告
南昌航空大学实验报告课程名称:数据结构实验名称:实验九查找班级:080611 学生姓名:学号:08 指导教师评定:签名:题目:编程实现哈希表的造表和查找算法。
要求:用除留余数法构造哈希函数,用二次探测再散列解决冲突。
一、需求分析1.用户可以根据自己的需求输入一个顺序表(哈希表)2.通过用除留余数法构造哈希函数,并用开放地址的二次探测再散列解决冲突。
3.在经过排序后显示该哈希表。
4.程序执行的命令包括:(1)创建哈希表(2)输出哈希表(3)二次探测再散列解决冲突二、概要设计⒈ 为实现上述算法,需要顺序表的抽象数据类型:ADT Hash {数据对象D: D 是具有相同特征的数据元素的集合。
各数据元素均含有类型相同,可唯一标识数据元素的关键字。
数据关系R:数据元素同属一个集合。
基本操作P:Creathash(&h)操作结果:构造一个具有n 个数据元素的哈希查找表h。
destroyhash(&h)初始条件:哈希查找表h 存在。
操作结果:销毁哈希查找表h。
displayhash (h)初始条件:哈希查找表h 存在。
操作结果:显示哈希查找表h。
hash(h ,&k)初始条件:哈希查找表h 存在。
操作结果:通过除留余数法得到地址用k 返回。
hash2 (i ,&k)初始条件:哈希查找表h 存在存在,i 是除留余数法得到的地址。
操作结果:返回二次探测再散列解决冲突得到的地址k 。
search (h ,key)初始条件:哈希查找表h 存在。
操作结果:查找表h 中的key,若查找成功,返回其地址,否则返回-1insert (&h ,key) 初始条件:哈希查找表h 存在。
操作结果:若表h中没有key ,则在h 中插入key 。
search1(h, key,&p)key,若没有,则返回p的插入的地址,否则返回-1 。
}ADT Hash2.本程序有三个模块:⑴ 主程序模块main(){初始化;{接受命令;显示结果;}}⑵ 创建hash 表的模块:主要建立一个哈希表;⑶解决冲突模块:利用开放地址的二次探测再散列解决冲突;(4) 输出哈希表模块:显示已创建哈希表。
数据结构实验9哈希查找
数据结构实验9哈希查找哈希查找(Hash Search)是一种利用哈希函数快速定位目标数据的查找算法。
它根据数据的关键字直接计算出应该存储或者查找的位置,从而大大降低了查找的时间复杂度。
在实际应用中,哈希查找广泛应用于数据库、缓存系统和字典等领域。
哈希查找的核心思想是利用哈希函数将数据存储在一个数组中,并根据关键字计算出在数组中的下标,从而快速定位目标数据。
在哈希查找中,哈希函数的设计很关键,它需要将不同的关键字映射到不同的下标,同时尽量避免冲突。
一般来说,一个好的哈希函数应该具备以下几个特点:1.唯一性:不同的关键字映射到不同的下标,避免冲突;2.均匀性:关键字的分布在数组中均匀,减少冲突的概率;3.高效性:计算哈希值的时间复杂度较低,提高查找效率。
在哈希查找中,常用的解决冲突方法有开放定址法和链地址法。
开放定址法是指当冲突发生时,通过线性探测或二次探测的方式,找到下一个空槽位存储数据。
而链地址法是将冲突的数据以链表的形式存储在同一槽位的下面。
在实现哈希查找时,首先需要创建一个存储数据的数组,数组的大小一般选择为质数,以避免冲突。
然后,根据关键字计算哈希值,并根据哈希值找到对应的槽位。
如果存在冲突,根据冲突解决方法找到下一个空槽位。
最后,在槽位中查找目标数据。
哈希查找的时间复杂度为O(1),即不论数据量的大小,查找的时间都是固定的。
这是因为哈希查找是通过直接计算哈希值来定位数据,而不需要进行比较操作。
但是,哈希查找的空间复杂度较高,因为需要额外的存储空间来存储哈希表。
在实际应用中,哈希查找有一些限制。
首先,哈希函数的设计很关键,它需要根据数据的特点来选择,不同的哈希函数适用于不同的数据。
其次,哈希查找适用于静态数据集,即在查找过程中数据集不会发生变化。
如果数据集经常变动,需要频繁地进行哈希表的重建,这将导致性能下降。
总之,哈希查找是一种高效的查找算法,在其适用范围内,可以快速定位目标数据。
但是,在实际应用中,需要根据具体情况选择合适的哈希函数和解决冲突方法,以提高查找效率。
哈希查找数据结构实验报告
引言概述:哈希查找是一种高效的数据结构,它通过将关键字映射为哈希码,将数据存储在哈希表中,从而实现快速的查找操作。
本实验报告将详细介绍哈希查找的原理、实现方法、效率分析以及实验结果,并探讨其在实际应用中的优缺点。
正文内容:一、哈希查找的原理1.1哈希函数的选择1.2冲突处理方法1.3哈希表的结构和特性1.4哈希查找的流程和算法二、哈希查找的实现方法2.1开放寻址法2.1.1线性探测法2.1.2二次探测法2.1.3双重散列法2.2链地质法2.2.1链表的表示与操作2.2.2链地质法的实现步骤2.2.3链地质法的优化方法三、哈希查找的效率分析3.1平均查找长度(ASL)的计算3.2填装因子与性能的关系3.3平均查找长度的简化计算3.4哈希查找的时间复杂度与空间复杂度分析四、实验结果与分析4.1构建哈希表的过程4.2不同冲突处理方法比较4.3不同填装因子下的性能变化4.4实验结果的优化策略4.5实验结果与理论分析的对比五、哈希查找的应用与优缺点5.1应用领域5.2优点与不足5.3哈希查找与其他查找方法的比较5.4未来发展方向和改进方法总结:哈希查找是一种高效的数据结构,它通过将关键字映射为哈希码,将数据存储在哈希表中,实现快速查找。
本文详细介绍了哈希查找的原理、实现方法、效率分析以及实验结果,并探讨了其在实际应用中的优缺点。
通过实验分析和对比,我们可以得出结论:哈希查找在一定填装因子下有着较高的查找效率和较低的空间复杂度,适用于大规模数据的快速查找和插入操作。
哈希查找也存在着冲突处理问题和哈希函数设计的困难等不足之处。
未来的改进方向可以是优化冲突处理方法和进一步提高哈希函数的质量,以提升整体性能和应用范围。
数据结构 实验9 哈希查找
数据结构实验9 哈希查找数据结构实验9 哈希查找一、实验目的本实验旨在通过实现哈希查找算法,掌握哈希函数的设计和哈希查找的基本操作,并对其性能进行分析。
二、实验要求⒈实现哈希查找算法的基本操作,包括哈希表的创建、插入、查找和删除。
⒉设计合适的哈希函数,以提高哈希查找的效率。
⒊对实现的哈希查找算法进行性能测试,并分析结果。
⒋撰写实验报告,详细记录实验过程、算法设计和性能测试结果。
三、实验内容⒈理解哈希查找的基本原理和相关概念,并对算法进行设计。
⒉实现哈希查找算法的基本操作。
包括以下功能:●创建哈希表:根据给定的容量创建一个哈希表。
●插入数据:将指定的数据插入到哈希表中。
●查找数据:在哈希表中查找指定的数据。
●删除数据:从哈希表中删除指定的数据。
⒊设计合适的哈希函数。
根据实际需求和数据情况,选择合适的哈希函数,保证数据分布均匀,以提高查找效率。
⒋进行性能测试。
根据不同的输入规模和数据情况,对实现的哈希查找算法进行性能测试,并记录运行时间和查找成功率等指标。
四、实验步骤⒈确定哈希表的容量,创建一个空的哈希表。
⒉设计并实现哈希函数,将待插入数据映射到哈希表的对应位置。
⒊实现插入操作。
根据哈希函数计算出的位置,将数据插入到对应的位置中。
⒋实现查找操作。
根据哈希函数计算出的位置,查找对应位置上是否存在目标数据。
⒌实现删除操作。
根据哈希函数计算出的位置,删除对应位置上的数据。
⒍对实现的哈希查找算法进行性能测试。
⒎根据测试结果进行分析和总结,找出优化的空间并改进算法。
附件:无法律名词及注释:⒈哈希函数:一种将任意长度的输入通过散列算法转换成固定长度输出的函数。
⒉哈希表:通过哈希函数对数据进行映射存储的数据结构,用于提高数据的查找效率。
数据结构 实验9 哈希查找
}
}
int Hash(int kn)
{ return (kn%11); } // 哈希函数:H(key)=key MOD 11
5、测试数据与实验结果(可以抓图粘贴)
(1)菜单:
(2)建表
(3)显示
(4)查找
(5)插入
(6)删除
6、结果分析与实验体会
本次实验是参考了范例程序,经过自己的改写,从而实现要求。先做简单的输出,一步步的再做其它格式的设置。这次的实验我们要做的是哈希查找,要求我们复习顺序查找,二分查找,分块查找等基本算法,进一步巩固散列查找时解决冲突的方法和特点,在调试程序的过程中,遇到很多问题,但还是都得以解决。
}
break;
case '4':if(H.count==MAXSIZE) // 哈希表已满
{ printf("\n散列表已经满!\n");
break; }
printf("\n请输入要插入元素(int):");
scanf("%d",&R.keynum); // 输入要插入的记录
temp=InsertHash(H,R);
{ // 在查找成功时删除待删元素e,并返回True,否则返回False
int p;
if(!SearchHash(H,e.keynum,p)) // 表中不存在待删元素
return False;
else
{ H.elemflag[p]=DELKEY; // 设置标志为DELKEY,表明该元素已被删除
H.count--; // 哈希表当前长度减一
enum HAVEORNOT{NULLKEY,HAVEKEY,DELKEY}; //哈希表元素的三种状态,没有记录、有记录、有过记录但已被删除
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
南昌航空大学实验报告课程名称:数据结构实验名称:实验九查找班级:学生姓名:学号:指导教师评定:签名:题目:编程实现哈希表的造表和查找算法。
要求:用除留余数法构造哈希函数,用二次探测再散列解决冲突。
一、需求分析1.用户可以根据自己的需求输入一个顺序表(哈希表)2.通过用除留余数法构造哈希函数,并用开放地址的二次探测再散列解决冲突。
3.在经过排序后显示该哈希表。
4.程序执行的命令包括:(1)创建哈希表(2)输出哈希表(3)二次探测再散列解决冲突二、概要设计⒈为实现上述算法,需要顺序表的抽象数据类型:ADT Hash {数据对象D:D是具有相同特征的数据元素的集合。
各数据元素均含有类型相同,可唯一标识数据元素的关键字。
数据关系R:数据元素同属一个集合。
基本操作P:Creathash(&h)操作结果:构造一个具有n个数据元素的哈希查找表h。
destroyhash(&h)初始条件:哈希查找表h存在。
操作结果:销毁哈希查找表h。
displayhash(h)初始条件:哈希查找表h存在。
操作结果:显示哈希查找表h。
hash(h,&k)初始条件:哈希查找表h存在。
操作结果:通过除留余数法得到地址用k返回。
hash2 (i,&k)初始条件:哈希查找表h存在存在,i是除留余数法得到的地址。
操作结果:返回二次探测再散列解决冲突得到的地址k。
search (h,key)初始条件:哈希查找表h存在。
操作结果:查找表h中的key,若查找成功,返回其地址,否则返回-1insert (&h,key)初始条件:哈希查找表h存在。
操作结果:若表h中没有key,则在h中插入key。
search1(h, key,&p)初始条件:哈希查找表h存在。
操作结果:在表h中查找key,若没有,则返回p的插入的地址,否则返回-1。
}ADT Hash2. 本程序有三个模块:⑴主程序模块main(){初始化;{接受命令;显示结果;}}⑵创建hash表的模块:主要建立一个哈希表;⑶解决冲突模块:利用开放地址的二次探测再散列解决冲突;(4)输出哈希表模块:显示已创建哈希表。
三、详细设计⒈元素类型,结点类型typedef struct{int key;}keytype;typedef struct{keytype elem[100];int length; /*当前的长度*/int size; /*哈希表的总长*/}hashtable;/*全局变量*/int a=0,b=0;/*哈希函数*/2.对抽象数据类型中的部分基本操作的伪码算法如下:/*哈希函数*/int hash(hashtable *h,int k){return k%h->size;}/*二次探测再散列解决冲突*/int hash2(int i,int t){ if(i%2==0)t=t+pow(++a,2);elset=t-pow(++b,2);return t;}/*创建哈希表*/void creat(hashtable *h){ int i,j,key,t,p;printf("input hash size and length:");scanf("%d%d",&h->size,&h->length);for(i=0;i<h->size;i++)h->elem[i].key=-1;printf("input data:\n");for(j=0;j<h->length;j++){ scanf("%d",&key);p=hash(h,key);if(h->elem[p].key==-1)h->elem[p].key=key;else{ i=0;t=p;while(h->elem[p].key!=-1&&h->elem[p].key!=key&&i<h->size/2) { p=hash2(i,t);i++;}a=b=0;h->elem[p].key=key;}}}/*查找哈希表中的元素,返回元素的地址,否则返回-1*/int search(hashtable *h,int key){ int p,t,i=0;p=hash(h,key);t=p;while(h->elem[p].key!=-1&&h->elem[p].key!=key&&i<h->size/2) { p=hash2(i,t);i++;}if(h->elem[p].key==key) return p;else return(-1);}/*查找哈希表的元素,返回p的插入的位置*/void search1(hashtable *h,int key,int *p){ int t,s,c=0;t=hash(h,key);s=t;while(h->elem[t].key!=-1&&h->elem[t].key!=key&&c<h->size/2) { t=hash2(c,s);c++;}if(h->elem[t].key==key) *p=t;else{t=-1; *p=t;}}/*插入数据元素到开放地址哈希表中*/void insert(hashtable *h,int key){ int p;p=search(h,key);if(p!=-1) printf("the location is:%d\n",p);else{ search1(h,key,&p);++h->size;++h->length;h->elem[h->size].key=key;}}/*输出哈希表*/void printhash(hashtable *h){ int i;for(i=0;i<h->size;i++)printf("%-4.2d",i);printf("\n");for(i=0;i<2*h->size;i++)printf("--");printf("\n");for(i=0;i<h->size;i++)printf("%-4.2d",h->elem[i].key);}3.主函数和其他函数的伪码算法/*主函数*/void main(){ hashtable t;int i,key,key1,c;creat(&t);printf("output the hash:\n\n");printhash(&t);printf("\n\ncurrent the length is:%d\n",t.length); printf("\ninput a search key:");scanf("%d",&key);c=search(&t,key);if(c!=-1)printf("it's location is:%d\n",c);elseprintf("can't search the key!\n");printf("\n\nadd the key:");scanf("%d",&key1);insert(&t,key1);printf("\n");for(i=0;i<t.size;i++)printf("%-4.2d",i);printf("\n");for(i=0;i<2*t.size;i++)printf("--");printf("\n");for(i=0;i<t.size-1;i++)printf("%-4.2d",t.elem[i].key);printf("%-4.2d",t.elem[++i].key);printf("\n\ncurrent the length is:%d",t.length);getch();}4 函数调用关系mainhash hash2 search search1 hash hash2四、调试分析⒈开始的时候在创建哈希表的时候总是得不到相应的结果,最后发现原来是在creat函数中的i重复利用,使得结果混乱了,为解决这个问题我将该函数中的for语句的i该为j,避免与内while的i发生混乱使用。
⒉在编写hash2函数的时候利用了全局变量a和b,开始的时候在creat函数的镇南关没有加a=b=0;语句使得结果不正确。
3.为使得显示的哈希表比较美观,设计的过程进行了多次的调试。
特别是h->size和h->length有时会用错。
4.算法的时空分析各操作的算法时间复杂度比较合理hash,hash2为O(1);creat,search,search1,insert,printhash为O(n),注:n为哈希表的长度。
(注:也可用平均查找长度ASL)5.本次实验采用数据抽象的程序设计方法,将程序化为三层次结构,设计时思路清晰,使调试也较顺利,各模块有较好的可重用性。
五、用户手册⒈本程序的运行环境为windows xp操作系统,并且在TC2.0中运行,执行文件为Exp9.c;2. 进入演示程序后,完成编译,再点击超级工具集里的中文DOS环境运行选项,进入DOS环境中,用户根据需求键入相应的数据,可以看到相应的结果。
六、测试结果在dos下输入数据元素:88 64 24 75 02 15 68 54 28 39 61并且查找数据元素28和插入数据元素27则在dos界面输入如图所示:七、附录:源程序#include "stdio.h"#include "math.h"#define SIZE 100typedef struct{int key;}keytype;typedef struct{keytype elem[100];int length; /*当前的长度*/ int size; /*哈希表的总长*/ }hashtable;/*全局变量*/int a=0,b=0;/*哈希函数*/int hash(hashtable *h,int k) {return k%h->size;}/*二次探测再散列解决冲突*/int hash2(int i,int t){ if(i%2==0)t=t+pow(++a,2);elset=t-pow(++b,2);return t;}/*创建哈希表*/void creat(hashtable *h){ int i,j,key,t,p;printf("input hash size and length:");scanf("%d%d",&h->size,&h->length);for(i=0;i<h->size;i++)h->elem[i].key=-1;printf("input data:\n");for(j=0;j<h->length;j++){ scanf("%d",&key);p=hash(h,key);if(h->elem[p].key==-1)h->elem[p].key=key;else{ i=0;t=p;while(h->elem[p].key!=-1&&h->elem[p].key!=key&&i<h->size/2) { p=hash2(i,t);i++;}a=b=0;h->elem[p].key=key;}}}/*查找哈希表中的元素,返回元素的地址,否则返回-1*/int search(hashtable *h,int key){ int p,t,i=0;p=hash(h,key);t=p;while(h->elem[p].key!=-1&&h->elem[p].key!=key&&i<h->size/2){ p=hash2(i,t);i++;}if(h->elem[p].key==key) return p;else return(-1);}/*查找哈希表的元素,返回p的插入的位置*/void search1(hashtable *h,int key,int *p){ int t,s,c=0;t=hash(h,key);s=t;while(h->elem[t].key!=-1&&h->elem[t].key!=key&&c<h->size/2){ t=hash2(c,s);c++;}if(h->elem[t].key==key) *p=t;else{t=-1; *p=t;}}/*插入数据元素到开放地址哈希表中*/void insert(hashtable *h,int key){ int p;p=search(h,key);if(p!=-1) printf("the location is:%d\n",p);else{ search1(h,key,&p);++h->size;++h->length;h->elem[h->size].key=key;}}/*输出哈希表*/void printhash(hashtable *h){ int i;for(i=0;i<h->size;i++)printf("%-4.2d",i);printf("\n");for(i=0;i<2*h->size;i++)printf("--");printf("\n");for(i=0;i<h->size;i++)printf("%-4.2d",h->elem[i].key);}/*主函数*/void main(){ hashtable t;int i,key,key1,c;creat(&t);printf("output the hash:\n\n");printhash(&t);printf("\n\ncurrent the length is:%d\n",t.length); printf("\ninput a search key:");scanf("%d",&key);c=search(&t,key);if(c!=-1)printf("it's location is:%d\n",c);elseprintf("can't search the key!\n");printf("\n\nadd the key:");scanf("%d",&key1);insert(&t,key1);printf("\n");for(i=0;i<t.size;i++)printf("%-4.2d",i);printf("\n");for(i=0;i<2*t.size;i++)printf("--");printf("\n");for(i=0;i<t.size-1;i++)printf("%-4.2d",t.elem[i].key);printf("%-4.2d",t.elem[++i].key);printf("\n\ncurrent the length is:%d",t.length); getch();}。