哈希表查找的设计

合集下载

哈希表查找方法原理

哈希表查找方法原理

哈希表查找方法原理哈希表查找方法什么是哈希表•哈希表是一种常见的数据结构,也被称为散列表。

•它可以提供快速的插入、删除和查找操作,时间复杂度在平均情况下为O(1)。

•哈希表由数组组成,每个数组元素称为桶(bucket)。

•存储数据时,通过哈希函数将数据映射到对应的桶中。

哈希函数的作用•哈希函数是哈希表的核心部分,它将数据转换为哈希值。

•哈希函数应该具备以下特点:–易于计算:计算哈希值的时间复杂度应尽量低。

–均匀分布:哈希函数应能将数据均匀地映射到不同的桶中,以避免桶的过度填充或者空闲。

–独特性:不同的输入应该得到不同的哈希值,以尽量减少冲突。

哈希冲突及解决方法•哈希冲突指两个或多个数据被哈希函数映射到同一个桶的情况。

•常见的解决哈希冲突的方法有以下几种:–链地址法(Chaining):将相同哈希值的数据存储在同一个桶中,通过链表等数据结构来解决冲突。

–开放地址法(Open Addressing):当发生冲突时,通过特定的规则找到下一个可用的桶来存储冲突的数据,如线性探测、二次探测等。

–再哈希法(Rehashing):当发生冲突时,使用另一个哈希函数重新计算哈希值,并将数据存储到新的桶中。

哈希表的查找方法•哈希表的查找方法分为两步:1.根据哈希函数计算数据的哈希值,并得到对应的桶。

2.在桶中查找目标数据,如果找到则返回,否则表示数据不存在。

哈希表的查找性能•在理想情况下,哈希表的查找时间复杂度为O(1)。

•然而,由于哈希冲突的存在,查找时间可能会稍微增加。

•如果哈希函数设计得不好,导致冲突较多,可能会使查找时间复杂度接近O(n)。

•因此,选择合适的哈希函数和解决冲突的方法对于提高哈希表的查找性能非常重要。

总结•哈希表是一种高效的数据结构,适用于快速插入、删除和查找操作的场景。

•哈希函数的设计和解决冲突的方法直接影响哈希表的性能。

•在实际应用中,需要根据数据特点选择合适的哈希函数和解决冲突的方法,以提高哈希表的查找性能。

哈希表查找成功和不成功的算法

哈希表查找成功和不成功的算法

哈希表查找不成功怎么计算?解答:先建好表,然后可以算出每个位置不成功时的比较次数之和,再除以表空间个数!例如:散列函数为hash(x)=x MOD 13,用线性探测,建立了哈希表之后,如何求查找不成功时的平均查找长度!?地址:0 1 2 3 4 5 6 7 8 9 10 11 12数据: 39 1228154244 625-- 36- 38成功次数: 1 3 1 2 2 1 191 1不成功次数:98 7 65 4 3 2 1 1 2 110查找成功时的平均查找长度:ASL=(1+3+1+2+2+1+1+9+1+1)/10 =2.2查找不成功时的平均查找长度:ASL=(9+8+7+6+5+4+3+2+1+1+2+1+10)/13=4.54说明:第n个位置不成功时的比较次数为,第n个位置到第1个没有数据位置的距离。

至少要查询多少次才能确认没有这个值。

(1)查询hash(x)=0,至少要查询9次遇到表值为空的时候,才能确认查询失败。

(2)查询hash(x)=1,至少要查询8次遇到表值为空的时候,才能确认查询失败。

(3)查询hash(x)=2,至少要查询7次遇到表值为空的时候,才能确认查询失败。

(4)查询hash(x)=3,至少要查询6次遇到表值为空的时候,才能确认查询失败。

(5)查询hash(x)=4,至少要查询5次遇到表值为空的时候,才能确认查询失败。

(6)查询hash(x)=5,至少要查询4次遇到表值为空的时候,才能确认查询失败。

(7)查询hash(x)=6,至少要查询3次遇到表值为空的时候,才能确认查询失败。

(8)查询hash(x)=7,至少要查询2次遇到表值为空的时候,才能确认查询失败。

(9)查询hash(x)=8,至少要查询1次遇到表值为空的时候,才能确认查询失败。

(10)查询hash(x)=9,至少要查询1次遇到表值为空的时候,才能确认查询失败。

(11)查询hash(x)=10,至少要查询2次遇到表值为空的时候,才能确认查询失败。

hashtable底层原理

hashtable底层原理

hashtable底层原理Hashtable底层原理Hashtable是一种常见的数据结构,它可以快速地进行数据的查找和插入操作。

在Java中,Hashtable是一个非常常用的类,它的底层实现是基于哈希表的。

本文将从哈希表的基本原理、哈希函数的设计、哈希冲突的处理以及Hashtable的实现等方面来介绍Hashtable的底层原理。

一、哈希表的基本原理哈希表是一种基于数组的数据结构,它通过哈希函数将数据映射到数组的某个位置上。

哈希函数的设计是哈希表的关键,它决定了数据在数组中的位置。

哈希表的基本操作包括插入、查找和删除。

插入操作将数据插入到哈希表中,查找操作根据关键字查找数据,删除操作将数据从哈希表中删除。

二、哈希函数的设计哈希函数的设计是哈希表的关键,它决定了数据在数组中的位置。

哈希函数的设计需要满足以下几个条件:1. 映射范围:哈希函数需要将数据映射到数组的某个位置上,因此哈希函数的返回值需要在数组的范围内。

2. 均匀性:哈希函数需要将数据均匀地映射到数组的各个位置上,这样可以避免哈希冲突的发生。

3. 碰撞概率:哈希函数需要尽可能地减少哈希冲突的发生,这样可以提高哈希表的效率。

常见的哈希函数包括直接寻址法、除留余数法、数字分析法、平方取中法、折叠法等。

三、哈希冲突的处理哈希冲突是指不同的数据经过哈希函数映射到数组的同一个位置上。

哈希冲突的发生是不可避免的,因此需要采取一些方法来处理哈希冲突。

常见的哈希冲突处理方法包括开放地址法和链地址法。

开放地址法是指当哈希冲突发生时,继续寻找数组中的下一个空位置,直到找到为止。

链地址法是指将哈希冲突的数据存储在链表中,每个数组位置上存储一个链表头指针,指向链表的第一个节点。

四、Hashtable的实现Hashtable是Java中的一个非常常用的类,它的底层实现是基于哈希表的。

Hashtable的实现采用了链地址法来处理哈希冲突。

当哈希冲突发生时,将数据存储在链表中,每个数组位置上存储一个链表头指针,指向链表的第一个节点。

哈希查找的时间复杂度

哈希查找的时间复杂度

哈希查找的时间复杂度哈希查找(Hash Search)是一种常用的快速查找算法,通过将数据存储在哈希表中,可以快速地定位到需要查找的元素。

在哈希查找中,关键字的哈希值将决定其在哈希表中的位置,从而实现了快速查找的目的。

本文将探讨哈希查找算法的时间复杂度及其影响因素。

一、哈希查找算法概述哈希查找算法主要分为两个步骤:哈希函数的构造和哈希冲突的处理。

具体步骤如下:1. 哈希函数的构造:根据待查找的关键字的特点,设计一个哈希函数,将关键字映射为哈希值,并将其存储在哈希表中。

2. 哈希冲突的处理:由于哈希函数的映射可能存在冲突(即不同的关键字可能映射到相同的哈希值),需要设计一种冲突解决方法,如开放地址法、链地址法等。

二、哈希查找的时间复杂度分析在理想情况下,哈希查找的时间复杂度为O(1),即常数时间。

这是因为通过哈希函数,可以直接计算得到待查找元素在哈希表中的位置,不需要遍历整个表格,从而实现了快速查找。

然而,在实际应用中,哈希函数的设计和哈希冲突的处理可能会影响查找效率。

如果哈希函数设计得不好,或者哈希表的装载因子过高,会导致哈希冲突的发生频率增加,从而影响查找性能。

三、影响哈希查找时间复杂度的因素1. 哈希函数的设计:好的哈希函数应该能够将关键字均匀地映射到哈希表的各个位置,从而降低哈希冲突的概率。

常用的哈希函数包括除留余数法、平方取中法等。

2. 哈希表的装载因子:装载因子是指哈希表中已存储元素个数与哈希表总大小的比值。

装载因子过高会增加哈希冲突的概率,从而降低查找性能。

通常情况下,装载因子的取值应控制在0.7以下。

3. 哈希冲突的处理方法:常见的哈希冲突解决方法有开放地址法和链地址法。

开放地址法通过线性探测、二次探测等方式寻找下一个可用位置,链地址法则使用链表或其他数据结构存储具有相同哈希值的关键字。

四、总结哈希查找是一种高效的查找算法,可以在常数时间内完成查找操作。

然而,其性能受到哈希函数的设计、哈希表的装载因子和哈希冲突的处理方式的影响。

哈希表——线性探测法、链地址法、查找成功、查找不成功的平均长度

哈希表——线性探测法、链地址法、查找成功、查找不成功的平均长度

哈希表——线性探测法、链地址法、查找成功、查找不成功的平均长度⼀、哈希表1、概念哈希表(Hash Table)也叫散列表,是根据关键码值(Key Value)⽽直接进⾏访问的数据结构。

它通过把关键码值映射到哈希表中的⼀个位置来访问记录,以加快查找的速度。

这个映射函数就做散列函数,存放记录的数组叫做散列表。

2、散列存储的基本思路以数据中每个元素的关键字K为⾃变量,通过散列函数H(k)计算出函数值,以该函数值作为⼀块连续存储空间的的单元地址,将该元素存储到函数值对应的单元中。

3、哈希表查找的时间复杂度哈希表存储的是键值对,其查找的时间复杂度与元素数量多少⽆关,哈希表在查找元素时是通过计算哈希码值来定位元素的位置从⽽直接访问元素的,因此,哈希表查找的时间复杂度为O(1)。

⼆、常⽤的哈希函数1. 直接寻址法取关键字或者关键字的某个线性函数值作为哈希地址,即H(Key)=Key或者H(Key)=a*Key+b(a,b为整数),这种散列函数也叫做⾃⾝函数.如果H(Key)的哈希地址上已经有值了,那么就往下⼀个位置找,知道找到H(Key)的位置没有值了就把元素放进去.2. 数字分析法分析⼀组数据,⽐如⼀组员⼯的出⽣年⽉,这时我们发现出⽣年⽉的前⼏位数字⼀般都相同,因此,出现冲突的概率就会很⼤,但是我们发现年⽉⽇的后⼏位表⽰⽉份和具体⽇期的数字差别很⼤,如果利⽤后⾯的⼏位数字来构造散列地址,则冲突的⼏率则会明显降低.因此数字分析法就是找出数字的规律,尽可能利⽤这些数据来构造冲突⼏率较低的散列地址.3. 平⽅取中法取关键字平⽅后的中间⼏位作为散列地址.⼀个数的平⽅值的中间⼏位和数的每⼀位都有关。

因此,有平⽅取中法得到的哈希地址同关键字的每⼀位都有关,是的哈希地址具有较好的分散性。

该⽅法适⽤于关键字中的每⼀位取值都不够分散或者较分散的位数⼩于哈希地址所需要的位数的情况。

4. 折叠法折叠法即将关键字分割成位数相同的⼏部分,最后⼀部分位数可以不同,然后取这⼏部分的叠加和(注意:叠加和时去除进位)作为散列地址.数位叠加可以有移位叠加和间界叠加两种⽅法.移位叠加是将分割后的每⼀部分的最低位对齐,然后相加;间界叠加是从⼀端向另⼀端沿分割界来回折叠,然后对齐相加.5. 随机数法选择⼀个随机数,去关键字的随机值作为散列地址,通常⽤于关键字长度不同的场合.6. 除留余数法取关键字被某个不⼤于散列表表长m的数p除后所得的余数为散列地址.即H(Key)=Key MOD p,p<=m.不仅可以对关键字直接取模,也可在折叠、平⽅取中等运算之后取模。

数据结构课程设计报告——哈希表实现电话号码查询

数据结构课程设计报告——哈希表实现电话号码查询

数据结构课程设计报告一、需求分析1问题描述:根据需要设计出合理的Hash函数,并由此建立相应的Hash表。

要求:1)每个电话用户信息包括(姓名,电话,住址)信息。

2)可以使用姓名与地址查找相应的用户信息。

3)使用Hash表实现。

使用开放定址法解决冲突。

2 基本要求:1)记录每个用户的姓名、地址和电话。

2)从键盘输入,以姓名和地址为关键字分别建立Hash表。

3)用开放地址法解决冲突。

4)分别按姓名和地址查找并显示电话号码。

二、概要设计三、详细设计typedef struct //定义结构Hash表{定义Hash表内的所有成员}HashTable[MaxSize];int Key(char x[])//关键字转换为数值{求字符数组x每个字符对应的asc值的绝对值之和,并返回最后结果}void CreateHT(HashTable ha)//创建Hash表{创建Hash表,并初始化它}void InsertHTna(HashTable ha,int &n,KeyType k,int d) //按姓名插入{以姓名为关键字,调用关键字转换函数将对应的电话号码存储到相应的存储空间。

若该位置已经被存储,则向后移一位(当移到最后一位,就移到头部继续)。

若还有冲突重复上一步。

当所有空间都查过一遍,发现没有空位,则输出“没有存储空间”。

}void InsertHTadd(HashTable ha,int &n,KeyType k,int d)//按地址插入{以地址为关键字,调用关键字转换函数将对应的电话号码存储到相应的存储空间。

若该位置已经被存储,则向后移一位(当移到最后一位,就移到头部继续)。

若还有冲突重复上一步。

当所有空间都查过一遍,发现没有空位,则输出“没有存储空间”。

}void InserHT(HashTable ha)//Hash表插入{输入用户姓名、地址和电话,分别调用按姓名插入和按地址插入函数进行插入。

c实现的hash表-概述说明以及解释

c实现的hash表-概述说明以及解释

c实现的hash表-概述说明以及解释1.引言1.1 概述在计算机科学中,哈希表(Hash Table),又被称为散列表,是一种常用的数据结构。

它能够以常数时间复杂度(O(1))来实现插入、删除和查找等操作,因此具有高效的特性。

哈希表通过哈希函数将键(key)映射到一个固定大小的数组(通常称为哈希表)。

通过这种映射关系,我们可以在数组中快速访问到对应的值(value)。

常见的应用场景包括缓存系统、数据库索引、编译器符号表等。

相对于其他数据结构,哈希表具有以下优点:1. 高效的插入、删除和查找操作:哈希表在插入、删除和查找数据时以常数时间复杂度进行操作,无论数据量大小,都能快速地完成操作。

2. 高效的存储和检索:通过哈希函数的映射关系,哈希表能够将键值对存储在数组中,可以通过键快速地找到对应的值。

3. 空间效率高:哈希表通过哈希函数将键映射到数组下标,能够充分利用存储空间,避免冗余的存储。

然而,哈希表也存在一些局限性:1. 冲突问题:由于哈希函数的映射关系是将多个键映射到同一个数组下标上,可能会导致冲突。

解决冲突问题的常见方法包括链地址法(Chaining)和开放定址法(Open Addressing)等。

2. 内存消耗:由于哈希表需要维护额外的空间来存储映射关系,所以相比于其他数据结构来说,可能会占用较多的内存。

本篇长文将重点介绍C语言实现哈希表的方法。

我们将首先讨论哈希表的定义和实现原理,然后详细介绍在C语言中如何实现一个高效的哈希表。

最后,我们将总结哈希表的优势,对比其他数据结构,并展望哈希表在未来的发展前景。

通过本文的学习,读者将能够深入理解哈希表的底层实现原理,并学会如何在C语言中利用哈希表解决实际问题。

1.2 文章结构本文将围绕C语言实现的hash表展开讨论,并按照以下结构进行组织。

引言部分将对hash表进行概述,介绍hash表的基本概念、作用以及其在实际应用中的重要性。

同时,引言部分还会阐述本文的目的,即通过C语言实现的hash表,来探讨其实现原理、方法以及与其他数据结构的对比。

pit表查找算法

pit表查找算法

pit表查找算法
PIT(Programming Interpreter Table)查找算法是一种基于哈希表的查找算法,用于在程序中快速查找符号表。

PIT查找算法的基本思想是将符号表中的每个符号映射到一个哈希值,然后使用该哈希值作为索引在哈希表中查找对应的符号。

PIT查找算法的步骤如下:
1. 计算符号的哈希值:将符号作为输入,计算其哈希值。

哈希函数应该将符号映射到一个唯一的整数。

2. 查找符号:使用计算出的哈希值作为索引,在哈希表中查找对应的符号。

如果找到了符号,则返回该符号。

如果没找到,则说明该符号不存在于符号表中。

3. 处理哈希冲突:由于哈希函数可能将不同的符号映射到相同的哈希值,因此可能会出现哈希冲突。

为了解决哈希冲突,可以使用链地址法或开放地址法。

链地址法是将具有相同哈希值的符号链接到一个链表中。

开放地址法是在发生冲突时重新计算哈希值,直到找到一个可用的位置。

4. 插入符号:如果需要在符号表中插入一个新符号,首先计算该符号的哈希值,然后使用相应的处理哈希冲突的方法在哈希表中插入该符号。

PIT查找算法的时间复杂度为O(1),即平均情况下可以在常数时间内完成查找操作。

这是因为哈希表的大小是固定的,并且每个符号的哈希值是唯一的,因此可以在常数时间内完成查找操作。

但是,如果哈希函数设计不当或数据分布不均匀,可能会导致哈希冲突过多,从而影响查找效率。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

哈希表查找的设计一.问题描述:哈希表查找的设计:设哈希表长为20,用除留余数法构造一个哈希函数,以开放定址法中的线性探测再散列法作为解决冲突的方法,编程实现哈希表查找、插入和建立算法。

二.需求分析:程序可实现用户与计算机的交互过程。

在计算机显示提示信息后,可由用户键入运算命令以实现对应的功能,包含数据的录入、查找、删除、显示等功能。

本程序旨在实现哈希函数的构造与处理存储冲突,因而指定哈希表存储的数据类型为简单的整型数字,在实用性上还有所欠缺。

但根据用户需求的变化,可以对程序的基本数据类型进行改造,以实现更为丰富的功能,进而体现哈希表在查找数据时的优越性。

三.算法思想:在设定哈希表的抽象数据类型时,要有查找数据元素的操作。

另外,插入操作和删除操作也要用到查找数据元素操作,以查看该数据元素是否存在,因此可以设计查找元素操作包括插入和删除操作的查找。

因此,查找操作就有两种情况:一种情况是插入操作时寻找空闲单元的查找;另一种情况是在查找和删除操作时寻找该元素是否在哈希表中已存在的查找。

插入操作时寻找空闲单元查找的特征是哈希表中不存在该对象,设计此时查找函数返回该空闲单元位置的“正”值;查找和删除操作时寻找该元素是否在哈希表中已存在的特征是哈希表中已存在该数据元素,设计此时查找函数返回该数据单元位置的“负”值。

进而执行后续操作。

为了区分哈希表中每一个表元素的当前状态,为每一个表元素设置一个“标志”定为tag。

tag=0表示该元素为空;tag=1表示该元素以存放有数据元素;tag=-1表示该元素中存放的数据元素已被删除。

判断当tag为0或-1时都可以进行插入操作。

四.概要设计:1. 哈希表抽象数据类型的定义:ADT HashT able{数据对象:D={ai|ai∈ElemSet, i=1,2,...n, n≥0}数据关系:R1={<ai-1,ai>|ai-1∈D, i=1,2,...n}基本操作:Initiate( &h )操作结果:构造一个空的哈希表h。

SearchHash( h, x, p )初始条件:哈希表h已存在;p为除留余数法中除数,由用户指定。

操作结果:查找表中元素与指定数据x比较。

元素已存在时返回其所在位置的负数下标、不存在时返回其位置的正数下标、遍历哈希表后未查找到时返回表长。

Insert( &h, x, p )初始条件:哈希表h已存在。

操作结果:查找操作后插入元素x至哈希表。

若元素已存在或哈希表已满时插入操作失败,返回值为0。

Delete(&h, x, p )初始条件:哈希表h已存在。

操作结果:查找操作后从哈希表中删除元素x。

若元素不在表中时删除操作失败,返回值为0。

Print( h )初始条件:哈希表h已存在。

操作结果:显示哈希表中元素及存储状态。

Clear( &h )初始条件:哈希表h已存在。

操作结果:清空哈希表。

}ADT HashT able2. 程序模块:Hash.h——头文件,包含哈希表抽象数据类型。

Hash.cpp——主程序,为哈希表操作面板。

五.程序代码:——————Hash.h文件——————#include<malloc.h>#include<iostream.h>#include<iomanip.h>#include<process.h>#include<ctype.h>#define T ableSize 20 //哈希表长20#define SUCCESS 1#define UNSUCCESS 0typedef int Status;typedef struct{//定义元素关键字类型int key;}Elemtype;typedef struct{//定义哈希表中基本单元,包含数据与标志两部分Elemtype elem; //数据部分,存放关键字int tag; //标志部分,tag=0表示表单元为空,//tag=1表示表单元已存放数据元素,//tag=-1表示表单元中存放的数据已被删除}HashItem;typedef struct{//定义哈希表,包含表单元数组与当前存储量HashItem table[T ableSize];int currentSize; //当前哈希表存储量}HashT able;Status Initiate(HashT able *h){//初始化操作int i;for(i=0; i<T ableSize; i++){(*h).table[i].tag=0; //tag标志置为0(*h).table[i].elem.key=NULL; //空单元默认值设为NULL}(*h).currentSize=0;return SUCCESS;}int SearchHash(HashT able h, Elemtype x, int p){//查找元素操作int i=x.key%p; //除留余数法定哈希地址,主程序中定义一不大于表长的素数pint j=i;while(h.table[j].tag==1 && h.table[j].elem.key!=x.key){//冲突时j=(j+1)%T ableSize; //开放定址法,线性探测再散列,求出新位置jif(j==i){cout<<"哈希表中未查找到"<<x.key<<endl;return T ableSize; //全表遍历后未搜索到所给元素,返回表长}}if(h.table[j].tag==1) //元素已存在时返回其位置的负数下标{cout<<"该元素在哈希表的第"<<j<<"位"<<endl; return -j;}else //元素不存在时返回其位置的下标{cout<<"哈希表中未查找到"<<x.key<<endl; return j;}}Status Insert(HashT able *h, Elemtype x, int p){//插入元素操作int i=SearchHash(*h, x, p); //先调用查找操作if(i<0) //元素已存在时,插入失败{cout<<x.key<<"元素已存在,无法再录入,操作失败!"<<endl<<endl;return UNSUCCESS;}else{if(i!=T ableSize && (*h).table[i].tag!=1) //哈希表有剩余空间时,进行插入操作{(*h).table[i].elem.key=x.key; //插入元素(*h).table[i].tag=1; //tag标志置为1(*h).currentSize++; //表存储量加1cout<<"录入成功!"<<endl<<endl;return SUCCESS;}elseif(i==T ableSize) //哈希表已满时,插入失败{cout<<"哈希表已满,无法再插入"<<x.key<<",操作失败!"<<endl<<endl;return UNSUCCESS;}}}Status Delete(HashT able *h, Elemtype x, int p){//删除元素操作int i=SearchHash(*h, x, p); //先调用查找操作if(i<=0) //查找成功,元素存在时,进行删除操作{(*h).table[-i].elem.key=NULL; //单元值设为NULL(*h).table[-i].tag=-1; //tag标志置为-1(*h).currentSize--; //表存储量减1cout<<"删除成功!"<<endl;return SUCCESS;}elsecout<<"删除失败!"<<endl;return UNSUCCESS;}Status Print(HashT able h){//打印表操作cout<<endl<<"哈希表序数存储情况存储元素"<<endl;for(int i=0;i<T ableSize;i++){cout<<setw(4)<<i<<setw(10)<<h.table[i].tag<<setw(10)<<h.table[i].elem.key<<endl;} cout<<endl<<"表中非空元素个数:"<<h.currentSize<<endl<<endl;return SUCCESS;}Status Clear(HashT able *h){//置空表操作for(int i=0;i<T ableSize;i++){(*h).table[i].tag=0; (*h).table[i].elem.key=NULL;}(*h).currentSize=NULL;cout<<"哈希表已全部置空!"<<endl;return SUCCESS;}——————Hash.cpp文件——————int main( ){cout<<endl<<"******** HashT able T est File********"<<endl<<endl;HashT able h;Initiate(&h);int prime;cout<<"请输入一个小于20的质数:";cin>>prime;char choice;while(1){cout<<"————————————————————————"<<endl;cout<<"按a 输出哈希表"<<endl;cout<<"按b 查找指定元素在表中的位置"<<endl;cout<<"按c 录入元素"<<endl;cout<<"按d 删除元素"<<endl;cout<<"按e 清空哈希表"<<endl;cout<<"按其他键退出"<<endl<<endl<<"请选择:";cin>>choice;cout<<"————————————————————————"<<endl;switch(choice){case'a':{ Print(h); break;}case'b':{ cout<<"请输入需要查找的元素的值:";Elemtype a;cin>>a.key;SearchHash(h,a,prime);break;}case'c':{ cout<<"请输入需要输入的元素个数(1~20):";int n,i;cin>>n;Elemtype *pi=0;pi=(Elemtype*)malloc(n*sizeof(Elemtype));cout<<"请依次输入"<<n<<"个元素的值:"<<endl;for(i=0;i<n;i++){ cin>>pi[i].key; Insert(&h,pi[i],prime);}break;}case'd':{ cout<<"请输入需要删除的元素的值:";Elemtype c;cin>>c.key;Delete(&h,c,prime);break;}case'e':{ Clear(&h); break; }default:{return 0;}}}}六.运行结果:程序运行,先按要求输入一小于20的质数作为除留余数法的除数因子。

相关文档
最新文档