大数据结构-实验8查找地算法
查找算法在数据处理中的应用

查找算法在数据处理中的应用在当今数字化的时代,数据处理成为了各个领域中至关重要的任务。
从大型企业的数据库管理到个人电脑中的文件搜索,查找算法都发挥着关键作用。
查找算法,简单来说,就是在一组数据中找到特定元素或者满足特定条件的元素的方法。
在日常生活中,我们经常会用到查找操作。
比如在手机的通讯录中查找某个联系人,在电脑的文件夹中查找某个文件,这些看似简单的操作背后,都有查找算法在默默工作。
不同的查找算法有着不同的特点和适用场景,下面我们就来详细了解一下几种常见的查找算法。
顺序查找算法是最简单直观的一种查找算法。
它的基本思想是从数据的一端开始,依次比较每个元素,直到找到目标元素或者遍历完整个数据集合。
这种算法的优点是实现简单,对于小型数据集合或者无序数据集合比较适用。
然而,它的缺点也很明显,当数据量较大时,查找效率会非常低,因为平均情况下需要比较大约一半的元素。
二分查找算法则是一种效率更高的查找算法,但它要求数据集合必须是有序的。
二分查找的基本思路是每次都将数据集合分成两部分,通过比较目标元素与中间元素的大小,确定目标元素所在的子集合,然后在该子集合中继续进行二分查找,直到找到目标元素或者确定目标元素不存在。
由于每次查找都能将搜索范围缩小一半,所以二分查找的时间复杂度为 O(log n),相比顺序查找有了显著的提高。
在实际应用中,二分查找常用于有序数组的查找,例如在已排序的考试成绩表中查找特定分数的学生。
哈希查找算法是一种通过计算哈希值来快速定位数据的方法。
它将数据元素通过一个特定的哈希函数映射到一个哈希表中,然后通过计算目标元素的哈希值,直接在哈希表中进行查找。
如果哈希函数设计得好,哈希查找的平均时间复杂度可以接近O(1),效率非常高。
但是,哈希函数可能会出现冲突,即不同的元素计算出相同的哈希值,这就需要通过一些解决冲突的方法来保证查找的正确性。
除了以上这些基本的查找算法,还有一些基于它们的改进和扩展算法,以及适用于特定数据结构的查找算法。
数据结构_查找原理及典型的查找算法

3.对非线性(树)结构如何进行折半查找? 可借助二叉排序树来查找(属动态查找表形式)。
9.1.2 有序表的查找
折半查找过程可以描述为一棵二叉树
折半查找的判定树 如:(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
总之:
二叉排序树既有类似于折半查找的特性,又采用了链 表存储,它是动态查找表的一种适宜表示。
一、二叉排序树
(3)构造过程: 例:输入序列{45,12,37,3,53,100,24}
45
12
53
3
37
100
24
一、二叉排序树
(2)非递归查找过程 BiTree SearchBST(BiTree T,KeyType key){
CH9 查找
查找的基本概念 9.1 静态查找表
9.1.1 顺序查找 9.1.2 有序表的查找 9.1.3 索引顺序表的查找
9.2 动态查找表
9.2.1 二叉排序树和平衡二叉树 9.2.2 B-和B+树
9.3 哈希表
查找的基本概念
1.查找表 2.查找
关键字 主关键字 次关键字
}
9.2.1 二叉排序树和平衡二叉树
一、二叉排序树 二、平衡二叉树
一、二叉排序树
1.定义、特点、构造过程
(1)定义 二叉排序树或者是一棵空树,或是具有下列性质的二叉树:
若左子树非空,则左子树上所有结点的值均小于它的 根结点的值。
若右子树非空,则右子树上所有结点的值均大于它的 根结点的值。
有序/无序表 有序表
顺序/链式存 储
顺序存储
分块查找 介于二者之间 表中元素逐段有序 顺序/链式存储
数据结构中的查找算法总结

数据结构中的查找算法总结静态查找是数据集合稳定不需要添加删除元素的查找包括:1. 顺序查找2. 折半查找3. Fibonacci4. 分块查找静态查找可以⽤线性表结构组织数据,这样可以使⽤顺序查找算法,再对关键字进⾏排序就可以使⽤折半查找或斐波那契查找等算法提⾼查找效率,平均查找长度:折半查找最⼩,分块次之,顺序查找最⼤。
顺序查找对有序⽆序表均适⽤,折半查找适⽤于有序表,分块查找要求表中元素是块与块之间的记录按关键字有序动态查找是数据集合需要添加删除元素的查找包括: 1. ⼆叉排序树 2. 平衡⼆叉树 3. 散列表 顺序查找适合于存储结构为顺序存储或链接存储的线性表。
顺序查找属于⽆序查找算法。
从数据结构线形表的⼀端开始,顺序扫描,依次将扫描到的结点关键字与给定值k相⽐较,若相等则表⽰查找成功 查找成功时的平均查找长度为: ASL = 1/n(1+2+3+…+n) = (n+1)/2 ; 顺序查找的时间复杂度为O(n)。
元素必须是有序的,如果是⽆序的则要先进⾏排序操作。
⼆分查找即折半查找,属于有序查找算法。
⽤给定值value与中间结点mid的关键字⽐较,若相等则查找成功;若不相等,再根据value 与该中间结点关键字的⽐较结果确定下⼀步查找的⼦表 将数组的查找过程绘制成⼀棵⼆叉树排序树,如果查找的关键字不是中间记录的话,折半查找等于是把静态有序查找表分成了两棵⼦树,即查找结果只需要找其中的⼀半数据记录即可,等于⼯作量少了⼀半,然后继续折半查找,效率⾼。
根据⼆叉树的性质,具有n个结点的完全⼆叉树的深度为[log2n]+1。
尽管折半查找判定⼆叉树并不是完全⼆叉树,但同样相同的推导可以得出,最坏情况是查找到关键字或查找失败的次数为[log2n]+1,最好的情况是1次。
时间复杂度为O(log2n); 折半计算mid的公式 mid = (low+high)/2;if(a[mid]==value)return mid;if(a[mid]>value)high = mid-1;if(a[mid]<value)low = mid+1; 折半查找判定数中的结点都是查找成功的情况,将每个结点的空指针指向⼀个实际上不存在的结点——外结点,所有外界点都是查找不成功的情况,如图所⽰。
大数据查重算法-概述说明以及解释

大数据查重算法-概述说明以及解释1.引言1.1 概述大数据查重算法是针对大规模数据集中存在的重复数据进行检测和处理的一种技术方法。
随着互联网和信息技术的发展,大数据的规模和复杂性逐渐增加,其中大量数据的重复问题也日益突出。
重复数据不仅占用存储空间,也增加了数据处理和分析的困难度。
因此,研究和应用大数据查重算法具有重要意义。
大数据查重算法是通过比较大规模数据集中的各个数据元素之间的相似性,来判断是否存在重复数据的一种计算方法。
它可以应用于各个领域,比如互联网搜索引擎、数据清洗和数据挖掘等。
通过使用大数据查重算法,可以有效地去除重复数据,减少存储空间的占用,提高数据处理和分析的效率。
大数据查重算法主要包括两个重要步骤:特征提取和相似度计算。
特征提取是将原始数据转化为数值或二进制表示,以便进行比较和计算;相似度计算是通过比较数据之间的相似性来判断是否存在重复数据。
常用的相似度计算方法包括哈希算法、编辑距离算法和余弦相似度算法等。
虽然大数据查重算法在实际应用中取得了一定的成果,但仍然存在一些挑战和问题。
首先,大规模数据集的处理需要耗费大量的计算资源和存储空间,如何提高算法的效率和准确性是一个重要的研究方向。
其次,在不同领域的数据应用中,可能存在特定的查重需求和算法适用性问题。
总体而言,大数据查重算法是大数据处理和分析中的重要环节,对于提高数据质量和提升数据应用效果具有重要作用。
随着大数据技术的发展和算法研究的不断深入,相信大数据查重算法将在未来得到更广泛的应用和进一步的发展。
1.2 文章结构本文主要介绍大数据查重算法的相关内容。
首先,将概述大数据查重算法的基本概念和原理。
随后,探讨大数据查重算法在实际应用中的重要性,并对其应用背景进行详细分析。
接着,详细介绍大数据查重算法的实现过程和技术方法。
在此基础上,总结大数据查重算法的优势,包括提高数据处理速度、准确性和可扩展性等方面。
最后,展望大数据查重算法的未来发展,探讨可能的研究方向和应用领域。
数据结构-查找

数据结构-查找写在前⾯:这些内容是以考研的⾓度去学习和理解的,很多考试中需要⽤到的内容在实际应⽤中可能⽤不上,⽐如其中的计算问题,但是如果掌握这些东西会帮你更好的理解这些内容。
这篇关于查找的博客也只是⽤来记录以便于后续复习的,所以很多地⽅只是浅谈,并没有代码的实现如果有缘发现这篇⽂章想要深⼊了解或者因为作者表达能⼒差⽽看不懂以及有错的地⽅,欢迎留⾔指出来,我会尽快去完善的,期待有缘⼈内容多和杂,如果有机会我进⼀步进⾏梳理,将其重新梳理⼀⽚⽂章(会更注重于代码)本来只是想简单写⼀下的,但是不⼩⼼就get不到重点了本来打算等逐步完善和优化后再发出来的,但那样继续往前总感觉有所顾及,所以就先给这⼏天查找的复习暂时告⼀段落吧。
导学概览总体(⼀)概念查找:在数据集合中查找特定元素的过程查找表(查找结构):同⼀类型数据元素构成的集合静态查找表:只涉及查找,不存在修改适⽤:顺序查找,折半查找,散列查找等动态查找表:动态插⼊和删除,对查找表进⾏修改适⽤:⼆叉排序树,散列查找等所有数据结构都可以看作是查找表,对于折半查找和顺序查找这些都属于查找算法关键字:数据元素中唯⼀标识该元素的某数据项的值主关键字:此关键字能唯⼀表⽰⼀个数据元素次关键字:此关键字⽤以识别若⼲记录(⼀对多)说明:在查找表中每个数据元素就相当于⼀条记录,包含有不同的数据项,例如拿学⽣为例,⼀个学⽣作为数据元素,那么学号,⾝⾼,姓名就是这个元素中的数据项,每个学⽣都有特定的学号,因此学号可以作为关键字。
(当然如果数据项包含⾝份证号,你⽤⾝份证号⾛位关键字也可以)0x01平均查找长度(重点注意:作为查找算法效率衡量的主要指标,那么查找算法的性能分析肯定是重点分析平均查找长度的,因此必须熟练掌握。
提⼀嘴,算法效率的度量前⾯学过时间和空间复杂度,但是算法效率的度量不是只取决于时间和空间复杂度,针对不同的算法还可能会有其他⼀些辅助度量,如查找算法中的平均查找长度。
数据结构查找知识点总结

数据结构查找知识点总结查找是在一组数据中寻找特定元素或特定条件的操作。
1. 线性查找:从列表、数组或链表的头部开始逐个检查元素,直到找到目标元素或搜索结束。
最坏情况下需要遍历整个数据集。
- 特点:简单易懂但效率低。
- 时间复杂度:O(n)。
2. 二分查找:对有序的列表、数组或链表,采用分治思想,通过比较目标元素和中间元素的大小关系,缩小搜索范围,直到找到目标元素或搜索结束。
- 前提条件:数据必须有序。
- 特点:效率高,但要求数据有序,且适用于静态数据集。
- 时间复杂度:O(log n)。
3. 哈希查找:通过将元素进行哈希函数映射,将元素存储在哈希表中,以快速定位目标元素。
- 特点:查找速度快,适用于动态数据集。
- 时间复杂度:平均情况下是O(1),最坏情况下是O(n)(哈希冲突)。
4. 二叉查找树:一种有序的二叉树结构,左子树的所有节点的值都小于根节点的值,右子树的所有节点的值都大于根节点的值。
- 特点:可用于快速插入、删除和查找元素。
- 时间复杂度:平均情况下是O(log n),最坏情况下是O(n)(树退化为链表)。
5. 平衡二叉查找树:通过在二叉查找树的基础上对树进行平衡操作,使得树的高度保持在较小范围,从而提高查找效率。
- 特点:保持查找性能稳定,适用于动态数据集。
- 时间复杂度:平均情况下是O(log n),最坏情况下是O(log n)(由于树平衡操作的代价,最坏情况下仍可达到O(n))。
6. B树/B+树:一种多路搜索树,通过增加每个节点的子节点数目,减少树的高度,从而提高查找效率。
常用于磁盘索引等场景。
- 特点:适用于大规模数据集以及磁盘访问等场景,对于范围查找尤为高效。
- 时间复杂度:平均情况下是O(log n),最坏情况下是O(log n)。
7. 字典树(Trie树):一种通过字符串的前缀来组织和查找数据的树形数据结构。
- 特点:适用于按前缀匹配查找、排序等操作。
- 时间复杂度:查找操作的时间复杂度与字符串长度有关。
数据结构-查找分析

第八章查找一、填空题1.线性有序表(a1,a2,a3,…,a256)是从小到大排列的,对一个给定的值k,用二分法检索表中与k相等的元素,在查找不成功的情况下,最多需要检索次。
设有100个结点,用二分法查找时,最大比较次数是。
2.折半查找有序表(4,6,12,20,28,38,50,70,88,100),若查找表中元素20,它将依次与表中元素比较大小。
3. 在各种查找方法中,平均查找长度与结点个数n无关的查找方法是。
4、对线性表进行二分查找时,要求线性表必须以方式存储,且结点按关键字排列。
5.顺序查找n个元素的顺序表,若查找成功,则比较关键字的次数最多为_ __次;当使用监视哨时,若查找失败,则比较关键字的次数为__ 。
6.在有序表A[1..12]中,采用二分查找算法查等于A[12]的元素,所比较的元素下标依次为____ _____。
7. 在有序表A[1..20]中,按二分查找方法进行查找,查找长度为5的元素个数是_8. 已知二叉排序树的左右子树均不为空,则_______上所有结点的值均小于它的根结点值,________上所有结点的值均大于它的根结点的值。
9、中序遍历二叉排序树得到的序列是序列(填有序或无序)。
10、从有序表(10,16,25,40,61,28,80,93)中依次二分查找40和61元素时,其查找长度分别为和。
二、单项选择题()1.在表长为n的链表中进行顺序查找,它的平均查找长度为A. ASL=n; B. ASL=(n+1)/2;C. ASL=n+1; D. ASL≈log2(n+1)-1()2.折半查找有序表(4,6,10,12,20,30,50,70,88,100)。
若查找表中元素58,则它将依次与表中比较大小,查找结果是失败。
A.20,70,30,50 B.30,88,70,50C.20,50 D.30,88,50()3.对22个记录的有序表作折半查找,当查找失败时,至少需要比较次关键字。
数据结构的查找算法

数据结构的查找算法在计算机科学中,数据结构是用于组织和存储数据的一种方式。
查找算法是数据结构中的重要部分,它用于在数据集合中搜索特定元素或信息。
本文将介绍几种常见的数据结构查找算法,包括线性查找、二分查找、哈希查找以及树结构的查找算法。
1. 线性查找线性查找是一种简单直观的查找方法,适用于无序的数据集合。
其基本思想是从数据集合的第一个元素开始逐个比较,直到找到目标元素或者遍历完整个数据集合。
由于线性查找需要遍历所有元素,所以时间复杂度为O(n),其中n为数据集合的大小。
2. 二分查找二分查找是一种高效的查找算法,但它要求数据集合中的元素必须有序。
具体实现方式是将数据集合分为两半,然后与目标元素进行比较,不断缩小查找范围,直到找到目标元素或者确定目标元素不存在。
由于每次都将查找范围减小一半,所以时间复杂度为O(log n),其中n为数据集合的大小。
3. 哈希查找哈希查找利用哈希函数将目标元素映射到哈希表中的特定位置,从而快速定位目标元素。
哈希表是一种以键-值对形式存储数据的数据结构,可以快速插入和删除元素,因此在查找时具有良好的性能。
哈希查找的时间复杂度为O(1),但在处理哈希冲突时可能会影响性能。
4. 树结构的查找算法树是一种常见的数据结构,其查找算法主要包括二叉搜索树、平衡二叉搜索树以及B树和B+树。
二叉搜索树是一种有序的二叉树,左子树的所有节点值都小于根节点,右子树的所有节点值都大于根节点。
通过比较目标元素与节点的值,可以快速定位目标元素。
平衡二叉搜索树是为了解决二叉搜索树在某些情况下可能出现的退化情况,通过旋转操作保持树的平衡性。
B树和B+树是一种多路搜索树,它们可以减少磁盘I/O操作,适用于大规模数据的查找。
综上所述,数据结构的查找算法是计算机科学中的重要内容。
不同的查找算法适用于不同的场景,选择合适的算法可以提高查找效率。
在实际应用中,需要根据数据集合的特点及查找需求来选择合适的算法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
8.1 实现顺序查找的算法一,实验目的1.熟悉掌握各种查找方法,深刻理解各种查找算法及其执行的过程;2.学会分析各种查找算法的性能。
二,实验内容8.1 实现顺序查找的算法编写一个程序,输出在顺序表{3,6,2,10,1,8,5,7,4,9}中采用顺序查找法查找关键字5的结果。
8.2 实现折半查找算法编写一个程序,输出在顺序表{1,2,3,4,5,6,7,8,9,10}中采用折半查找方法查找关键字9的结果。
要求:(1)用非递归方法;(2)用递归方法。
8.3 实现二叉排序树的基本运算编写一个程序实现二叉排序树的基本运算,并在此基础上完成如下功能:(1)由{4,9,0,1,8,6,3,5,2,7}创建一个二叉排序树bt;(2)判断bt是否为一棵二叉排序树(提示:在遍历过程中检查是否符合二叉排序树定义);(3)采用非递归方法查找关键字为6的结点,并输出其查找路径(提示:查找过程中保留经过的结点信息,找到后顺序输出之)。
8.4 实现哈希表的相关运算编写一个程序,实现哈希表的相关运算,并在此基础上完成如下功能:(1)建立{16,74,60,43,54,90,46,31,29,88,77}哈希表A[0…12],哈希函数为H(k)=key % 11,并采用线性探测法解决冲突。
输出哈希表;(2)在上述哈希表中查找关键字为29的记录;(3)在上述哈希表中删除关键字为77的记录,再将其插入,然后输出哈希表。
要求:输出格式哈希地址:0 1 2 (12)关键字值:……………………三,源代码及结果截图8.1//实现顺序查找的算法#include <stdio.h>#define MAXL 100 //定义表中最多记录个数typedef int KeyType;typedef int InfoType;typedef struct{KeyType key; //KeyType为关键字的数据类型InfoType data; //其他数据} NodeType;typedef NodeType SeqList[MAXL]; //顺序表类型int Search(SeqList R,int n,KeyType k) //顺序查找算法{int i=0;while (i<n && R[i].key!=k){printf("%d ",R[i].key);i++; //从表头往后找}if (i>=n)return -1;else{printf("%d",R[i].key);return i;}}void main(){SeqList R;int n=10;KeyType k=5;InfoType a[]={3,6,2,10,1,8,5,7,4,9};int i;for (i=0;i<n;i++) //建立顺序表R[i].key=a[i];printf("查找结果:\n");if ((i=Search(R,n,k))!=-1)printf("\n元素%d的位置是:%d",k,i);elseprintf("\n元素%d不在表中\n",k);printf("\n");}8.2//实现折半查找算法#include <stdio.h>#define MAXL 100 //定义表中最多记录个数typedef int KeyType;typedef char InfoType[10];typedef struct{KeyType key; //KeyType为关键字的数据类型InfoType data; //其他数据} NodeType;typedef NodeType SeqList[MAXL]; //顺序表类型int BinSearch1(SeqList R,int n,KeyType k) //非递归二分查找算法{int low=0,high=n-1,mid,count=0;while (low<=high){mid=(low+high)/2;printf("第%d次查找:在[%d,%d]中查找到元素R[%d]:%d\n",++count,low,high,mid,R[mid].key);if (R[mid].key==k) //查找成功返回return mid;if (R[mid].key>k) //继续在R[low..mid-1]中查找high=mid-1;elselow=mid+1; //继续在R[mid+1..high]中查找}return -1;}int BinSearch2(SeqList R,KeyType k,int low,int high,int count) //递归二分查找算法{int mid;if(low<=high){mid=(low+high)/2;printf("第%d次查找:在[%d,%d]中查找到元素R[%d]:%d\n",++count,low,high,mid,R[mid].key);if (R[mid].key==k) //查找成功返回return mid;else if (R[mid].key>k) //继续在R[low..mid-1]中查找BinSearch2(R, k,low,mid-1,count);elseBinSearch2(R, k,mid+1,high,count); //继续在R[mid+1..high]中查找}else return -1;}void main(){SeqList R;KeyType k=9;int a[]={1,2,3,4,5,6,7,8,9,10},i,n=10;for (i=0;i<n;i++) //建立顺序表R[i].key=a[i];printf("用非递归方法:\n");if ((i=BinSearch1(R,n,k))!=-1)printf("元素%d的位置是%d\n",k,i);elseprintf("元素%d不在表中\n",k);printf("用递归方法:\n");if ((i=BinSearch2(R,k,0,9,0))!=-1)printf("元素%d的位置是%d\n",k,i);elseprintf("元素%d不在表中\n",k);}8.3//实现二叉排序树的基本运算#include<stdio.h> //EOF,NULL#include<stdlib.h> //atoi( )#include<iostream.h> //cout,cin typedef int Status;typedef struct BTNode{int key;struct BTNode *lchild;struct BTNode *rchild;}BTNode;//定义二叉排序树插入结点的算法int BSTInsert(BTNode *&T,int k) {if(T==NULL){T=(BTNode *)malloc(sizeof(BTNode));T->lchild=T->rchild=NULL;T->key=k;return 1;}else{if(k==T->key)return 0;else if(k<T->key)return BSTInsert(T->lchild, k);elsereturn BSTInsert(T->rchild, k);}}//定义二叉排序树的创建算法BTNode *createBST(int k[],int n){BTNode *T;T=NULL;for(int i=0;i<=n-1;i++){BSTInsert(T,k[i]);}return T;}//判断是否为二叉排序树Status Judge(BTNode *&T){if(T==NULL)return 1;else if((T>T->lchild)&&(T<T->rchild)) {Judge(T->lchild);Judge(T->rchild);}else return 0;}//定义二叉排序树的查找算法BTNode *BSTSearch(BTNode *&T,int k) {if(T==NULL)return NULL;else{ printf("%d ",T->key);if(T->key==k)return T;else if(k<T->key){return BSTSearch(T->lchild, k);}else{return BSTSearch(T->rchild, k);}}}void main(){int a[50]={4,9,0,1,8,6,3,5,2,7};BTNode *bt=createBST(a,10);if(Judge(bt)==0) cout<<"bt不是二叉排序树"<<endl;else cout<<"bt是二叉排序树"<<endl;cout<<"查找关键字6的查找路径:"<<endl;BTNode *t=BSTSearch(bt,6);cout<<endl;}8.4//实现哈希表的相关运算#include <stdio.h>#define MaxSize 100 //定义最大哈希表长度#define NULLKEY 0 //定义空关键字值#define DELKEY -1 //定义被删关键字值typedef int KeyType; //关键字类型typedef char * InfoType; //其他数据类型typedef struct{KeyType key; //关键字域InfoType data; //其他数据域int count; //探查次数域} HashTable[MaxSize]; //哈希表类型void InsertHT(HashTable ha,int *n,KeyType k,int p) //将关键字k插入到哈希表中{int i,adr;adr=k % p;if (ha[adr].key==NULLKEY || ha[adr].key==DELKEY) //x[j]可以直接放在哈希表中{ha[adr].key=k;ha[adr].count=1;}else //发生冲突时采用线性探查法解决冲突{i=1; //i记录x[j]发生冲突的次数do{adr=(adr+1) % p;i++;} while (ha[adr].key!=NULLKEY && ha[adr].key!=DELKEY);ha[adr].key=k;ha[adr].count=i;}n++;}void CreateHT(HashTable ha,KeyType x[],int n,int m,int p) //创建哈希表{int i,n1=0;for (i=0;i<m;i++) //哈希表置初值{ha[i].key=NULLKEY;ha[i].count=0;}for (i=0;i<n;i++)InsertHT(ha,&n1,x[i],p);}int SearchHT(HashTable ha,int p,KeyType k) //在哈希表中查找关键字k {int i=0,adr;adr=k % p;while (ha[adr].key!=NULLKEY && ha[adr].key!=k){i++; //采用线性探查法找下一个地址adr=(adr+1) % p;}if (ha[adr].key==k) //查找成功return adr;else //查找失败return -1;}int DeleteHT(HashTable ha,int p,int k,int *n) //删除哈希表中关键字k {int adr;adr=SearchHT(ha,p,k);if (adr!=-1) //在哈希表中找到该关键字{ha[adr].key=DELKEY;n--; //哈希表长度减1return 1;}else //在哈希表中未找到该关键字return 0;}void DispHT(HashTable ha,int n,int m) //输出哈希表{float avg=0;int i;printf(" 哈希表地址:\t");for (i=0;i<m;i++)printf(" %3d",i);printf(" \n");printf(" 哈希表关键字:\t");for (i=0;i<m;i++)if (ha[i].key==NULLKEY || ha[i].key==DELKEY) printf(" "); //输出3个空格elseprintf(" %3d",ha[i].key);printf(" \n");printf(" 搜索次数:\t");for (i=0;i<m;i++)if (ha[i].key==NULLKEY || ha[i].key==DELKEY) printf(" "); //输出3个空格elseprintf(" %3d",ha[i].count);printf(" \n");for (i=0;i<m;i++)if (ha[i].key!=NULLKEY && ha[i].key!=DELKEY) avg=avg+ha[i].count;avg=avg/n;printf(" 平均搜索长度ASL(%d)=%g\n",n,avg);}void main(){int x[]={16,74,60,43,54,90,46,31,29,88,77};int n=11,m=13,p=13,i,k=29;HashTable ha;CreateHT(ha,x,n,m,p);printf("\n");DispHT(ha,n,m);printf(" 查找关键字29:\n");i=SearchHT(ha,p,k);if (i!=-1)printf(" ha[%d].key=%d\n",i,k);elseprintf(" 未找到%d\n",k);k=77;printf(" 删除关键字%d\n",k);DeleteHT(ha,p,k,&n);DispHT(ha,n,m);i=SearchHT(ha,p,k);if (i!=-1)printf(" ha[%d].key=%d\n",i,k);elseprintf(" 未找到%d\n",k);printf(" 插入关键字%d\n",k);InsertHT(ha,&n,k,p);DispHT(ha,n,m);printf("\n");}四,实验小结1、通过本次实验,加深了我对查找表的认识。