实验八各种查找算法性能比较
查找的实验报告
实验名称:查找算法性能分析实验目的:比较不同查找算法的效率,并分析其性能。
实验时间:2022年3月15日实验地点:计算机实验室实验器材:计算机、实验软件一、实验背景随着计算机技术的发展,数据量越来越大,查找算法在数据处理中的应用越来越广泛。
查找算法的效率直接影响到数据处理的速度,因此研究不同查找算法的性能具有重要意义。
本实验旨在比较几种常见的查找算法的效率,并分析其性能。
二、实验内容1. 算法介绍(1)顺序查找顺序查找是一种最简单的查找方法,其基本思想是从线性表的第一个元素开始,依次将线性表中的元素与要查找的元素进行比较,直到找到目标元素或者查找结束。
(2)二分查找二分查找是一种效率较高的查找方法,其基本思想是将待查找的序列分为两半,每次将中间位置的元素与要查找的元素进行比较,如果相等,则查找成功;如果中间位置的元素大于要查找的元素,则将查找范围缩小到左半部分;如果中间位置的元素小于要查找的元素,则将查找范围缩小到右半部分。
重复此过程,直到找到目标元素或者查找结束。
(3)散列查找散列查找是一种基于散列函数的查找方法,其基本思想是将要查找的元素通过散列函数映射到散列表中的一个位置,然后直接访问该位置,如果找到目标元素,则查找成功;如果未找到,则查找失败。
2. 实验步骤(1)生成随机数据使用实验软件生成一组随机数据,包括顺序查找和二分查找的数据。
(2)编写查找算法根据上述算法介绍,编写顺序查找、二分查找和散列查找的代码。
(3)测试算法性能分别对三种查找算法进行测试,记录查找成功和失败的情况,统计查找成功和失败的平均时间。
三、实验结果与分析1. 顺序查找(1)查找成功实验结果显示,顺序查找在查找成功的情况下,平均查找时间为0.1秒。
(2)查找失败实验结果显示,顺序查找在查找失败的情况下,平均查找时间为0.2秒。
2. 二分查找(1)查找成功实验结果显示,二分查找在查找成功的情况下,平均查找时间为0.05秒。
通过八数码问题比较搜索算法的性能
中 图法分 类号 : P 8 T l
文献标 识码 : A
文章编 号 :0 07 2 2 0) 120 ・4 10 -04(0 7 l.5 50
ifr t ng iac,sc e et・r ac ( S n e ra t・rte c ( F ) nomai dn e u h sh phf ss rh DF )a dh edhf ssa h B S.Mo e sac g rh s aeis o u at d i te t b i r dm r h lo tms e t tge e a i u s r
( e a met f o ue c n e Z o gh n i r t Gun z o 12 5 C ia D p r n mp t S i c, h n sa v sy t oC r e Un e i , agh u 7 , hn) 5 0
Ab ta t s r c :Th s e t l f e r ha g r h e sa l h e t f e r hsr t g e .T a i o a e c l o i ms s ae i s t o t ee s n i s a c l o i ms s h tb i m n s a c t e is r d t n l a ha g rt ao t it e s o a i sr h es t g e h u u r t wi
wi e i a c f n o a in wh c r a ld h u it e r h a g rt ms eg t eA a g rt m . dfe e t e c tae iswi tt d hh g u n eo f r t , i m o i h a ec l e rsi s a c l o h , . . h e c i lo h i i r n a h s tg e l sr r l
各种查找算法的性能比较测试(顺序查找、二分查找)
{
int High,Low,Mid;//定义了整形变量High,Low,Mid
Low=0,High=n-1;//选择查找的最大的范围
(4)While ( low<=high and index=-1)
(5)If k<[mid]
(6){high=mid-1
(7)Low=high-2*pos1}
(8)Else if x>a[mid]
(9)Low=mid+1
(10)High=low+2*pos2
(11)Else index=mid
(12)Return index
int key=59;
srand((unsigned)time(NULL)); /*初始化随机函数种子,這句是拿系统时间作为种子,由于时间是变化的,种子变化,可以产生不相同的随机数*/
for(int i=0;i<n;i++)//初始化变量i的值为0,当i=0时执行循环,在每次循环后i执行加1操作
{
a[i]=rand()%100; //随机数的取值从0到100之间
{
i=n;//从后往前把表中的元素与要查找的元素进行比较
while (i>0 && r[i]!=k)
i--;
return i;//i的值为0则没找到,为非0则i为要查找元素的位置
}
算法:二分查找(递归)法
目的:在给定的集合(或者是多重集,允许多个元素具有相同的值)中找寻一个给定的值。
学年论文几种查找算法的比较与总结
学年论文题目:几种查找算法的比较与总结学院:计算机科学与工程专业:计算机科学与技术班级: 12级计师1班学生姓名:马有华学号: 201271030132指导教师:曹素珍摘要查找是在大量的信息中寻找一个特定的信息元素,在计算机应用中,查找是常用的基本运算。
文中介绍四种查找算法.分别是顺序查找、二分查找、二叉排序树查找和哈希查找。
并用JAVA语言编写了相应程序代码,比较了查找同一个数据的时间复杂度和空间复杂度。
关键词: 查找算法;时间复杂度;空间复杂度AbstractSearching is a commonly basic operation that can find a number of information in computer applications.In this paper,four tapyes of searching algorithm are introduced.They are squential earch,binar y search tree,and bash search.The progarm’s codes based on java are complied. The time complexity and space complexity to look for the same data and compared.Key words: Searching Algorithm;Timecomplexity;Spacecomplexity目录摘要 (1)1 算法概述 (1)1.1引言 (1)1.2顺序查找 (2)1.3二分查找 (2)1.3.1二分查找要求 (2)1.3.2优缺点 (2)1.3.3算法思想 (3)1.3.4算法复杂度 (3)1.4分块查找 (3)1.4.1方法描述 (3)1.4.2操作步骤 (4)1.5哈希表查找 (4)1.5.1基本原理 (4)1.5.2函数构造 (5)1.5.3冲突处理 (5)1.5.4支持运算 (5)2 算法实现 (8)2.1顺序查找 (8)2.1.1方法分类 (8)2.2二分查找 (9)2.2.1算法要求 (9)2.2.2算法复杂度 (9)2.2.3代码示例 (10)2.2.4递归实现 (12)2.3分块查找 (17)2.3.1方法描述 (17)2.3.2操作步骤 (18)2.4哈希表查找 (19)2.4.1操作步骤 (19)2.4.2解决冲突 (20)3 比较与总结 (23)3.1分类查找的依据 (23)3.2效率比较 (23)参考文献 (25)1 算法概述1.1引言用关键字标识一个数据元素,查找时根据给定的某个值,在表中确定一个关键字的值等于给定值的记录或数据元素。
查找算法实验报告
查找算法实验报告查找算法实验报告一、引言查找算法是计算机科学中的一个重要概念,它在数据处理和信息检索中起着关键作用。
本实验旨在探究几种常见的查找算法,并对它们的性能进行比较和分析。
二、顺序查找算法顺序查找算法是最简单直观的一种查找方法,它逐个比较待查找元素与数据集中的元素,直到找到匹配项或遍历完整个数据集。
该算法的时间复杂度为O(n),其中n为数据集的大小。
尽管顺序查找算法的效率较低,但在小规模数据集或无序数据集中仍然具有一定的应用价值。
三、二分查找算法二分查找算法是一种高效的查找算法,它要求数据集必须是有序的。
该算法通过将待查找元素与数据集的中间元素进行比较,从而将查找范围缩小一半。
如果中间元素与待查找元素相等,则查找成功;如果中间元素大于待查找元素,则在左半部分继续查找;如果中间元素小于待查找元素,则在右半部分继续查找。
通过不断缩小查找范围,二分查找算法的时间复杂度为O(log n),其中n为数据集的大小。
二分查找算法在大规模有序数据集中具有较高的查找效率。
四、哈希查找算法哈希查找算法是一种基于哈希表的查找方法,它通过将待查找元素映射到哈希表中的一个位置,从而快速定位到目标元素。
哈希查找算法的时间复杂度为O(1),即常数级别。
然而,哈希查找算法对哈希函数的选择和哈希冲突的处理有一定的要求。
如果哈希函数设计不合理或哈希冲突过多,可能会导致查找效率下降。
五、比较与分析在本实验中,我们对上述三种查找算法进行了性能比较和分析。
实验结果表明,在小规模数据集或无序数据集中,顺序查找算法的效率较高;而在大规模有序数据集中,二分查找算法的效率最高。
哈希查找算法虽然具有常数级别的时间复杂度,但在哈希函数和哈希冲突处理上需要额外的开销。
因此,在实际应用中,我们需要根据具体需求选择合适的查找算法。
六、实验总结通过本次实验,我们深入了解了查找算法的原理和应用。
顺序查找算法、二分查找算法和哈希查找算法各具特点,在不同场景下有不同的优劣势。
常见查找算法的优缺点分析
常见查找算法的优缺点分析在计算机科学中,查找算法是一种用于在数据集合中查找特定元素的方法。
不同的查找算法在时间复杂度、空间复杂度和适用场景等方面存在差异。
下面我们就来详细分析几种常见查找算法的优缺点。
首先是顺序查找算法。
这是最简单也是最直观的一种查找方法。
它的基本思路是从数据集合的开头,依次比较每个元素,直到找到目标元素或者遍历完整个集合。
顺序查找的优点在于实现简单,理解容易,对于小型数据集或者无序数据集来说,是一种可行的选择。
而且,它不需要对数据进行预处理,如排序等操作。
然而,其缺点也很明显。
当数据量较大时,顺序查找的效率非常低,因为它的平均时间复杂度为 O(n),其中 n 是数据集合的元素个数。
这意味着,随着数据量的增加,查找所需的时间会线性增长。
接下来是二分查找算法。
这种算法要求数据集合是有序的。
它通过不断将数据集一分为二,比较目标元素与中间元素的大小,从而缩小查找范围,逐步逼近目标元素。
二分查找的优点十分突出。
它的时间复杂度为 O(log n),效率比顺序查找高得多。
在大型有序数据集上,能够显著减少查找时间。
但二分查找也有其局限性。
首先,它要求数据集必须是有序的,如果数据集经常变动,维护有序性的成本可能会很高。
其次,对于小型数据集,由于其实现相对复杂,可能不如顺序查找来得直接和高效。
然后是哈希查找算法。
哈希查找通过将关键码值映射到一个特定的地址,从而实现快速查找。
哈希查找的最大优点就是查找速度极快,平均时间复杂度接近O(1),无论数据集的大小如何。
只要哈希函数设计得好,能够有效地避免冲突,就可以在常数时间内完成查找。
不过,哈希查找也并非完美。
哈希函数的设计是一个关键问题,如果设计不当,可能会导致大量的冲突,从而影响查找效率。
而且,当数据量增加时,可能需要重新调整哈希表的大小,这会带来一定的额外开销。
再说说插值查找算法。
它是二分查找的一种改进,根据要查找的关键字与查找表中最大最小关键字的比较结果,来选择合适的中间值进行比较。
比较常用查找算法的性能与应用场景
比较常用查找算法的性能与应用场景关键信息项1、所涉及的常用查找算法名称2、每种查找算法的性能指标(时间复杂度、空间复杂度等)3、不同应用场景的特点与需求4、各查找算法在不同场景下的优劣对比1、引言11 查找算法在计算机科学中的重要性查找算法是计算机程序设计中经常使用的基本操作之一,它在数据处理、数据库管理、搜索系统等领域都有着广泛的应用。
高效的查找算法能够显著提高程序的运行效率和性能。
12 协议目的本协议旨在对常用的查找算法进行性能比较,并分析它们在不同应用场景中的适用性,为开发者在选择合适的查找算法时提供参考依据。
2、常用查找算法概述21 顺序查找顺序查找是一种最简单的查找算法,它从数组的一端开始,逐个元素进行比较,直到找到目标元素或遍历完整个数组。
211 算法步骤依次比较数组中的每个元素与目标元素,若相等则查找成功,否则继续下一个元素。
212 时间复杂度在最坏情况下,时间复杂度为 O(n),其中 n 是数组的长度。
213 空间复杂度O(1),只需要常数级的额外空间。
22 二分查找二分查找适用于有序数组,通过不断将数组中间的元素与目标元素进行比较,缩小查找范围,直到找到目标元素。
221 算法步骤首先将数组中间的元素与目标元素进行比较,如果相等则查找成功;如果目标元素小于中间元素,则在左半部分继续查找;否则在右半部分继续查找。
重复这个过程,直到找到目标元素或确定目标元素不存在。
222 时间复杂度O(log n),其中 n 是数组的长度。
223 空间复杂度O(1)23 哈希查找哈希查找通过将元素映射到一个哈希表中,利用哈希函数快速定位目标元素。
231 算法步骤计算目标元素的哈希值,在哈希表中查找对应的位置,如果该位置存在元素且与目标元素相等,则查找成功;否则可能发生哈希冲突,需要通过解决冲突的方法进一步查找。
232 时间复杂度在理想情况下,平均时间复杂度为 O(1),但在处理哈希冲突时可能会增加时间复杂度。
查找的算法实验报告
一、实验目的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. 顺序查找算法简单易实现,但效率较低,适用于数据量较小的场景。
数据结构中的排序与查找算法的性能比较与优化
数据结构中的排序与查找算法的性能比较与优化在计算机科学与软件工程领域中,排序与查找算法是非常重要的基础知识。
数据结构中的排序算法用于将一组数据按照特定的顺序进行排列,而查找算法则用于在给定的数据集中寻找特定的元素。
本文将比较不同排序与查找算法的性能,并探讨如何优化这些算法。
一、排序算法的性能比较与优化1. 冒泡排序冒泡排序是一种简单但效率较低的排序算法。
它通过多次比较相邻的元素,并交换位置,将大的元素逐渐“冒泡”到序列的末尾。
这个过程迭代进行,直到整个序列排序完成。
2. 插入排序插入排序主要通过构建有序序列,对未排序的元素进行插入操作。
具体做法是将当前元素与已排序序列进行逐一比较,找到合适的位置插入。
这个过程会不断扩大已排序序列的长度,直到所有元素都被插入到有序序列中。
3. 选择排序选择排序也是一种简单但效率较低的排序算法。
它通过每次找到当前未排序序列中的最小元素,并将其放到已排序序列的末尾。
这个过程迭代进行,直到整个序列排序完成。
4. 快速排序快速排序是一种高效的排序算法。
它采用分治的思想,通过选择一个基准元素,将整个序列分成两个子序列,并递归地对子序列进行排序。
具体做法是将小于基准元素的所有元素移动到基准元素的左侧,将大于基准元素的所有元素移动到基准元素的右侧,然后对左右子序列进行递归排序,最终得到有序序列。
5. 归并排序归并排序是一种稳定的排序算法。
它也采用分治的思想,通过将整个序列分成两个子序列,并递归地对子序列进行排序。
然后,将两个有序子序列合并成一个有序序列。
归并排序的关键步骤是合并操作,需要额外的空间来存储中间结果。
根据以上对排序算法的性能比较,我们可以发现快速排序和归并排序在平均情况下具有较好的性能,并且它们都属于基于比较的排序算法。
然而,对于某些特定的数据集,不同的排序算法可能会表现出不同的性能。
因此,对排序算法进行优化是很有必要的。
在优化排序算法时,我们可以考虑以下几个方面:1. 选择合适的排序算法。
常用查找算法及其实践应用
常用查找算法及其实践应用查找算法是计算机科学中的一类基本算法,用于在一组数据中快速查找目标值。
本文将介绍常用的查找算法及其实践应用,并讨论它们的优缺点。
一、线性查找算法线性查找算法,也称作顺序查找算法,是最简单直接的查找算法之一。
它通过逐个比较数据元素,直到找到目标值或搜索整个数据集。
实践应用:线性查找算法适用于数据量较小且无序的情况。
例如,在一个未排序的数组中查找一个特定的值。
二、二分查找算法二分查找算法,也称作折半查找算法,是一种高效的查找算法。
它将目标值与数据集的中间值进行比较,根据比较结果将搜索范围缩小一半,以此类推,直到找到目标值或搜索范围为空。
实践应用:二分查找算法适用于已排序的数据集。
比如,在一个有序数组中查找一个特定的值。
三、哈希查找算法哈希查找算法通过哈希函数将数据映射到一个固定的位置,然后在该位置进行查找。
它的平均查找时间复杂度为O(1),具有高效的查找速度。
实践应用:哈希查找算法适用于查找大规模数据集中的特定值。
它常被用于数据库索引、缓存系统等。
四、二叉查找树算法二叉查找树算法,也称作二叉搜索树算法,是一种基于二叉树的查找算法。
它具有以下特点:左子树的所有节点小于根节点,右子树的所有节点大于根节点。
通过比较目标值与根节点的大小关系,可以快速缩小搜索范围。
实践应用:二叉查找树算法适用于频繁插入和删除操作的场景。
它常被用于实现字典、关联数组等数据结构。
五、平衡查找树算法平衡查找树算法,如红黑树、AVL树等,是对二叉查找树的改进。
它通过调整节点的颜色和旋转操作来保持树的平衡,以确保查找效率的稳定性。
实践应用:平衡查找树算法适用于高效地处理大规模数据集的查找、插入和删除操作。
它常被用于数据库索引、编译器等领域。
六、后缀树算法后缀树算法是一种用于字符串查找的数据结构。
它将目标字符串的所有后缀都表示为树的节点,通过遍历树来查找目标字符串的子串。
实践应用:后缀树算法适用于文本搜索、模式匹配等领域。
数据结构查找算法实验报告
数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能分析,比较它们在不同数据规模和分布情况下的效率和优劣。
二、实验环境操作系统: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.引言在计算机科学中,查找算法是一种用于在数据集合中寻找特定元素的算法。
查找算法在各种应用中广泛使用,例如数据库检索,关键字搜索等。
本次实验旨在研究和探索不同的数据结构查找算法,如线性查找、二分查找、哈希查找等,并比较它们的性能和适用场景。
2.线性查找2.1 算法原理线性查找又称为顺序查找,它从数据集合的起始位置开始,逐个比较元素直到找到目标元素或遍历完整个集合。
线性查找是最简单的查找算法,但效率较低,时间复杂度为O(n)2.2 算法步骤●从数组的第一个元素开始遍历,依次比较元素与目标元素是否相等。
●如果相等,返回目标元素的索引值。
●如果遍历完整个数组仍未找到目标元素,返回未找到的标志。
2.3 算法实现```function linearSearch(arr, target) {for (let i = 0。
i < arr.length。
i++) {if (arri === target) {return i。
}}return -1。
}```3.二分查找3.1 算法原理二分查找是一种高效的查找算法,要求数据集合必须有序。
它通过重复将数据集合一分为二,直到找到目标元素或确定目标元素不存在。
二分查找的时间复杂度为O(log n)3.2 算法步骤●将数据集合的起始位置和结束位置分别设为low和high。
●计算中间位置mid,并将mid元素与目标元素进行比较。
●如果mid元素等于目标元素,则返回mid。
●如果mid元素大于目标元素,则将high设为mid-1。
●如果mid元素小于目标元素,则将low设为mid+1。
●重复以上步骤,直到low大于high或找到目标元素。
3.3 算法实现```function binarySearch(arr, target) {let low = 0。
查找排序算法实验报告(3篇)
第1篇一、实验目的1. 熟悉常见的查找和排序算法。
2. 分析不同查找和排序算法的时间复杂度和空间复杂度。
3. 比较不同算法在处理大数据量时的性能差异。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 开发工具:PyCharm三、实验内容1. 实现以下查找和排序算法:(1)查找算法:顺序查找、二分查找(2)排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序2. 分析算法的时间复杂度和空间复杂度。
3. 对不同算法进行性能测试,比较其处理大数据量时的性能差异。
四、实验步骤1. 实现查找和排序算法。
2. 分析算法的时间复杂度和空间复杂度。
3. 创建测试数据,包括小数据量和大数据量。
4. 对每种算法进行测试,记录运行时间。
5. 分析测试结果,比较不同算法的性能。
五、实验结果与分析1. 算法实现(1)顺序查找def sequential_search(arr, target): for i in range(len(arr)):if arr[i] == target:return ireturn -1(2)二分查找def binary_search(arr, target):low, high = 0, 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)冒泡排序def bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j](4)选择排序def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i](5)插入排序def insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = key(6)快速排序def quick_sort(arr):if len(arr) <= 1:pivot = arr[len(arr) // 2]left = [x for x in arr if x < pivot]middle = [x for x in arr if x == pivot]right = [x for x in arr if x > pivot]return quick_sort(left) + middle + quick_sort(right)(7)归并排序def merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = merge_sort(arr[:mid])right = merge_sort(arr[mid:])return merge(left, right)def merge(left, right):result = []i = j = 0while i < len(left) and j < len(right):if left[i] < right[j]:result.append(left[i])i += 1else:result.append(right[j])result.extend(left[i:])result.extend(right[j:])return result2. 算法时间复杂度和空间复杂度分析(1)顺序查找:时间复杂度为O(n),空间复杂度为O(1)。
查找算法之顺序、二分、二叉搜索树、红黑树详细比较总结一派胡言
查找算法之顺序、二分、二叉搜索树、红黑树详细比较总结一派胡言前言一般用符号表来储存键值对,就好像字典那样,通过索引来查找值,若键重复则覆盖值。
我们能希望找到一种高效的查找算法使在平均情况和最差情况下,时间复杂度都能达到O(logn)。
下面会逐步介绍四种算法,最终达到我们的目的。
顺序查找用链表实现,无法索引数据,必须遍历找数据,速度比较慢,查找插入时间复杂度都为O(n),而且无法保证有序。
但是实现简单,适用于小型数据。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 public class SequentialSearchST<Key,Value> {private Node head;private int size=0;public void put(Key key,Value v){Node p=head;while(p!=null){if(p.key.equals(key)){p.v=v;return;}p=p.next;}head=new Node(key,v,head);size++;}public Value get(Key key){Node p=head;while (p!=null){if(p.key.equals(key)){return p.v;}26 27 28 29 30 31 p=p.next;}return null;}}二分查找用数组保存数据,保证有序。
二分查找速度很快,但是仅限于查找。
因为插入的时候要保证有序,所以要往后移动数据以便插入。
查找复杂度O(logn),插入复杂度O(n)。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 public class BinarySearch<Key extends Comparable,Value> {public void put(Key key,Value value){int index=rank(key);//键相等则覆盖值if(keys[index]!=null&&pareTo(keys[index])==0){ values[index]=value;return;}//把数据往后移,以便插入for(int i=size+1;i>index;i--){keys[i]=keys[i-1];values[i]=values[i-1];}keys[index]=key;values[index]=value;size++;}public Value get(Key key){int index=rank(key);//二分查找if(keys[index]!=null && pareTo(keys[index])==0){ return values[index];}return null;}public int rank(Key key){return rank(key,0,size);}public int rank(Key key,int l,int h){32 33 34 35 36 37 38 39 40 41 42 43 if(l>h) return l;int mid = (l+h)/2;int cmp=0;if(keys[mid]!=null)cmp=pareTo(keys[mid]);if(cmp<0)return rank(key,l,mid-1);else if(cmp>0)return rank(key,mid+1,h);return mid;}}二叉搜索树通过前面两个算法,我们可以知道链表能快速删除插入,而二分能快速查找。
排序查找算法性能比较
课程设计报告1.排序算法比较**利用随机函数产生30000个随机整数,利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序,并统计每一种排序上机所花费的时间。
提示:用顺序存储结构。
a)需求分析:1.建立顺序表结构体2.建立插入排序函数,参数为顺序表指针。
3.建立选择排序函数,参数为顺序表指针。
4.建立起泡排序函数,参数为顺序表指针。
5.建立快速排序函数,参数为顺序表指针,起始数据位置,结束数据位置。
6.主函数中使用循环结构给顺序表每个元素随机赋值,排序前后测定时间,并统计。
b)概要设计1.void SelectSort(SqList *L)此函数主要比较两个关键字的大小,将元素从一个位置移动至另一个位置。
首先,在待排序序列中选择出最小的记录,然后将这个最小的数据元素与第一个记录交换,第一个记录到位,这叫做第一趟排序;第二趟,就是从第二个记录到最后一个记录中选择最小的记录,之后将最小的记录与第二个记录交换,第二个记录到位;以此类推,进行n-1趟,序列就有序了。
2.void InsertSort(SqList *L)在一个已排好序的记录子集的基础上,每一步将下一个待排序的记录有序地插入到已排好序的记录子集中,直到将所有待排记录全部插入为止。
3.void QSort(SqList *L, int s, int t)(1) 先从数列中取出一个数作为基准数(该记录称为枢轴)。
(2) 将比基准数大的数全放到它的右边,小于或等于基准数的全放到它的左边。
(3) 再对左右两部分重复第(2)步,直到各区间只有一个数,达到整个序列有序。
4.void BubbleSort(SqList *L)每趟不断将记录两两比较,并按“前小后大”(或“前大后小”)规则交换。
每趟结束时,不仅能挤出一个最大值到最后面位置,还能同时部分理顺其他元素;一旦下趟没有交换发生,还可以提前结束排序。
5.void main()在主函数里建立顺序表。
实验八各种查找算法性能比较
《数据结构》课程设计课程设计题目: 各种查找算法性能比较姓名: 宋京院系: 计算机学院专业:软件工程年级: 12级学号: E01214018指导教师: 王爱平2014年 11月2日目录1课程设计的目的 (3)2 需求分析 (3)3.1概要设计 (3)3.2详细设计 (4)3.3源程序 (4)3.3调试分析 (8)3.4运行结果 (9)4 小结 (9)5 参考文献 (9)1.课程设计的目的(1) 熟练使用 C 语言编写程序,解决实际问题;(2) 了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(3) 初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(4) 提高综合运用所学的理论知识和方法独立分析和解决问题的能力;2.需求分析程序通过使用不同查找算法在2000个随机数中查找一个数,比较不同算法的查找时间,从而得出算法性能。
使用的算法有二分查找算法、二叉查找算法、散列查找算法。
3.1概要设计使用数组来存放产生的2000个随机数并随机产生一个需查找的随机数,使用静态查找、动态查找、散列查找查找算法的函数3.2详细设计3.3源程序#include<iostream>#include<stdlib.h>#include<time.h>using namespace std;template<class T>int Find_s(T data[], int n,T key,int &num)//顺序查找(从n维数组中查找key,并且给出比较的次数icmp {num=0;for(int i=0;i<n;i++){num++;if(data[i]==key)return i;}return -1;}template<class T>int Find_t(T data[], int n,T key,int &num)//二分查找(从n维数组中查找key,并且给出比较的次数icmp{int i=0,j=n-1;num=0;while(data[(i+j)/2]!=key&&i<=j){num++;if(data[(i+j)/2]>key)j=(i+j)/2-1;elsei=(i+j)/2+1;}if(i>j)return -1;return (i+j)/2;}///以下是二叉查找树查找法template<class T>class BintreeNode{public:T data;BintreeNode* left;BintreeNode*right;BintreeNode():left(0),right(NULL){}BintreeNode(T item):data(item),left(NULL),right(NULL){}~BintreeNode(){if(left!=0)delete left;if(right!=0)delete right;}};template<class T>class Bintree{public:int num1;BintreeNode<T>* root;BintreeNode<T>* Find_bt(T key,int &num,int itype=0)//一个二叉树查找算法,itype=1时有插入功能(不同的值时){num=0;if(root==0){num++;if(itype==0)return NULL;else{num1++;return root=new BintreeNode<T>(key);}}else{BintreeNode<T>* ptr=root,*p;while(ptr!=NULL){num++;p=ptr;if(ptr->data==key)return ptr;else{if(ptr->data>key)ptr=ptr->left;elseptr=ptr->right;}}if(itype){num1++;if(p->data>key)return p->left=new BintreeNode<T>(key);elsereturn p->right=new (BintreeNode<T>)(key);}return NULL;}//else}//Find_btBintree():root(0),num1(0){}~Bintree(){delete root;}};int compare(const void* a,const void* b){return *(int *)a-*(int *)b;}template<class T>class Link{public:T data;Link<T>* next;Link<T>():next(0){}Link<T>(T item):data(item),next(0){}~Link<T>(){if(next) delete next;}};template<class T>class LinkList{public:Link<T>* first;LinkList<T>():first(0){}~LinkList<T>(){if(first)delete first;}Link<T>* Find_hash(T key,int &num,int ntype=0)//查找与插入,当ntype=1时为插入{num=0;if(first==0){num++;if(ntype)return first=new Link<T>(key);elsereturn NULL;}else{Link<T>*ptr=first,*p;while(ptr!=NULL){num++;p=ptr;if(ptr->data==key)return ptr;ptr=ptr->next;}if(ntype)return p->next=new Link<T>(key);return NULL;}}};template<class T>class Hash{public:LinkList<T>* hashlist;int size;Hash<T>(int n=113):size(n){hashlist=new LinkList<T>[n];}~Hash<T>(){delete []hashlist;}void init_hash(T data[],int n)//初始化哈希查找表-----拉链法冲突调节{int t;for(int i=0;i<n;i++){int pos=data[i]%size;hashlist[pos].Find_hash(data[i],t,1);}}Link<T>* Find_hash(T key,int &num)//查找关键词采用除法杂凑函数{int pos=key%size;return hashlist[pos].Find_hash(key,num);}};int main(){srand(time(0));do{int n=rand()%100000+1000;int *a=new int[n];for(int i=0;i<n;i++)a[i]=rand()%100000;int key=rand()%n;int num;int j=Find_s(a,n,key,num);//使用顺序查找法查找key值的位置cout<<"数据总数:"<<n<<"\t查找关健字key:"<<key<<"\t查找比较次数:num\n顺序查找法:\npos:"<<j<<"\tdata:"<<a[j]<<" num:"<<num<<endl;Bintree<int> btree;for(int k=0;k<n;k++)btree.Find_bt(a[k],num,1);//未排序之前插入到二叉查找树中qsort(a,n,sizeof(int),compare);//对数组进行升序排序cout<<"二分查找法:"<<endl;cout<<"pos:"<<Find_t(a,n,key,num)<<"\tnum:";//使用二分查找法查找key值的位置cout<<num<<endl;cout<<"二叉查找树:"<<endl;cout<<"data:"<<(btree.Find_bt(key,num)==NULL?-1:btree.Find_bt( key,num)->data );cout<<"\tnum:"<<num<<endl;//"\tnum:"<<btree.num<<endl;Hash<int > hash(1000);hash.init_hash(a,n);cout<<"哈希表查找:"<<endl;cout<<"data:"<<((hash.Find_hash(key,num)==NULL)?-1:(hash.Find_ hash(key,num))->data);cout<<"\tnum:"<<num<<endl;}while(getchar()-'0');//直到输入为'0'时结束,一直按Enter可以继续进行运算return 0;}3.4调试分析通过调用三种函数、三种查找算法对随机数的查找可以得出性能由高到底以此为散列查找、二分法查找、二叉查找法。
编程实验报告基于Python的数据结构与算法实现与性能比较
编程实验报告基于Python的数据结构与算法实现与性能比较编程实验报告: 基于Python的数据结构与算法实现与性能比较引言:“在编程的世界里,数据结构和算法是我们构建强大程序的基石。
” - Steve Jobs数据结构和算法在计算机科学和编程中扮演着重要的角色。
本实验报告旨在使用Python编程语言实现不同的数据结构和算法,并对它们的性能进行比较。
通过这个实验,我们可以深入了解数据结构和算法的原理,以及在不同场景下的应用和优劣势。
实验一:数组(Array)数组是计算机中最简单的数据结构之一。
我们使用Python编写了一个数组类,并进行了性能比较。
在实验中,我们分别测量了数组的插入、删除和查找操作的时间复杂度。
结果显示,在大多数情况下,数组的性能是很好的,特别是在直接访问元素方面。
实验二:链表(Linked List)链表是另一种常见的数据结构,相对于数组而言,链表在动态插入和删除操作中具有更好的性能。
我们使用Python实现了单向链表和双向链表,并进行了性能比较。
实验结果表明,链表在插入和删除操作方面的性能明显优于数组,尤其是在元素较多的情况下。
实验三:栈(Stack)栈是一种具有特定操作顺序(先进后出)的数据结构。
我们使用Python编写了栈,并与数组和链表进行了性能对比。
实验结果显示,栈的性能在某些方面略优于数组和链表,特别是在需要快速插入和删除操作的情况下。
实验四:队列(Queue)队列是一种具有特定操作顺序(先进先出)的数据结构。
我们实现了队列的不同变体(如普通队列和优先级队列)并进行了性能比较。
实验结果显示,队列在处理需要按特定顺序进行操作的情况下,性能相对较好,尤其是对于优先级队列。
实验五:二叉树(Binary Tree)二叉树是一种由节点和边组成的层次结构数据结构。
我们使用Python实现了二叉树,并对其性能进行了比较。
实验结果表明,在平衡状态下,二叉树在搜索和插入操作方面具有良好的性能。
对各种查找算法进行计较
对各种查找算法进行计较一、实验目的:1、了解和掌握各种查找算法。
2、学会计算各种查找算法的平均时间复杂度。
3、了解各种算法的优势。
二、实验内容:对各种查找算法进行比较三、实验要求:(1)任意输入1组有序数据;(2)对顺序查找、折半查找、分块查找的查找次数进行比较并输出比较结果。
四、算法分析:顺序查找:由顺序表的后面往前遍历,一个一个元素与待查找的数比较,找到待查找的数的位置;折半查找:每一次都用表的中间元素与待查找的数进行比较,根据结果所要查找表的范围缩小一半,反复执行以上的操作,找到待查数为止;分块查找:把表分为n块,用一个顺序表记录每一块的最大值和起始位置,待查找的元素先与顺序表比较,判断它所在的块,在快中利用折半查找找到其位置。
顺序查找的平均查找长度为:ASL=(n+1)/2;折半查找的平均查找长度为:ASL=log2(n+1)-1;分块查找的平均查找长度为:ASL=(n/m+1)/2+log2(m+1)-1.五、程序代码://#include "stdafx.h"#include"iostream"using namespace std;typedef int Key;typedef struct{Key key;}Rec;typedef struct{Key key;int a;}R;int srch(Rec r[],int n,Key k){int i=n,j=0;r[0].key=k;while(r[i].key!=k){i--;j++;}cout<<"顺序查找比较次数为:"<<j+1<<"次,";if(i!=0)cout<<"查找的数在顺序表的第"<<i<<"位"<<endl;else cout<<"查找失败!"<<endl;return(i);}int bisrch(Rec r[],int n,Key k){int low,hig,mid,j=0;low=1;hig=n;while(low<=hig){mid=(low+hig)/2;j++;if(k==r[mid].key){cout<<"折半查找比较次数为:"<<j<<"次,";cout<<"查找的数在顺序表的第"<<mid<<"位"<<endl;return(mid);}else if (k<r[mid].key)hig=mid-1;else low=mid+1;}cout<<"折半查找比较次数为"<<j<<"次"<<"查找失败!"<<endl;return 0;}int search(Rec r[],R t[],int n,int m,Key k){int i=1,j=0;while((t[i].key<k)&&(i<=m)){i++;j++;}if(t[i].key==k){j++;cout<<"分块查找比较次数为:"<<j<<"次,";cout<<"查找的数在顺序表的第"<<t[i].a+n/m-1<<"位"<<endl;return(0);}else if(i<=m){int e=t[i].a;int low,hig,mid;low=e;hig=n/m+e-1;while(low<=hig){mid=(low+hig)/2;j++;if(k==r[mid].key){cout<<"分块查找比较次数为: "<<j<<"次,";cout<<"查找的数在顺序表的第"<<mid<<"位"<<endl;return(mid);}else if (k<r[mid].key)hig=mid-1;else low=mid+1;}cout<<"分块查找比较次数为: "<<j<<"次"<<endl;return 0;}else return 0;};set(Rec r[],R a[],int n,int m){int u=n/m;a[0].a=0;a[0].key=0;for(int i=1;i<=u;i++){a[i].a=(i-1)*u+1;a[i].key=r[i*u].key;}return 0;}int main(){ int n,d,m;cout<<"输入顺序表的元素个数:"<<endl;cin>>n;int *we=new int[n+1];we[0]=0;Rec *r=new Rec[n+1];cout<<"输入有序顺序表的值:"<<endl;for(int i=1;i<=n;i++){cin>>we[i];r[i].key=we[i];}cout<<"输入分块查找块数:"<<endl;cin>>m;cout<<"输入查找的数:"<<endl;cin>>d;R* a=new R[n/m+1];set(r,a,n,m);srch( r,n,d);bisrch( r,n,d);search(r,a,n,m,d);return 0;}六、运行结果:。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《数据结构》课程设计课程设计题目: 各种查找算法性能比较姓名: 宋京院系: 计算机学院专业:软件工程年级: 12级学号: E01214018指导教师: 王爱平2014年 11月2日目录1课程设计的目的 (3)2 需求分析 (3)3.1概要设计 (3)3.2详细设计 (4)3.3源程序 (4)3.3调试分析 (8)3.4运行结果 (9)4 小结 (9)5 参考文献 (9)1.课程设计的目的(1) 熟练使用 C 语言编写程序,解决实际问题;(2) 了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(3) 初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(4) 提高综合运用所学的理论知识和方法独立分析和解决问题的能力;2.需求分析程序通过使用不同查找算法在2000个随机数中查找一个数,比较不同算法的查找时间,从而得出算法性能。
使用的算法有二分查找算法、二叉查找算法、散列查找算法。
3.1概要设计使用数组来存放产生的2000个随机数并随机产生一个需查找的随机数,使用静态查找、动态查找、散列查找查找算法的函数3.2详细设计3.3源程序#include<iostream>#include<stdlib.h>#include<time.h>using namespace std;template<class T>int Find_s(T data[], int n,T key,int &num)//顺序查找(从n维数组中查找key,并且给出比较的次数icmp {num=0;for(int i=0;i<n;i++){num++;if(data[i]==key)return i;}return -1;}template<class T>int Find_t(T data[], int n,T key,int &num)//二分查找(从n维数组中查找key,并且给出比较的次数icmp{int i=0,j=n-1;num=0;while(data[(i+j)/2]!=key&&i<=j){num++;if(data[(i+j)/2]>key)j=(i+j)/2-1;elsei=(i+j)/2+1;}if(i>j)return -1;return (i+j)/2;}///以下是二叉查找树查找法template<class T>class BintreeNode{public:T data;BintreeNode* left;BintreeNode*right;BintreeNode():left(0),right(NULL){}BintreeNode(T item):data(item),left(NULL),right(NULL){}~BintreeNode(){if(left!=0)delete left;if(right!=0)delete right;}};template<class T>class Bintree{public:int num1;BintreeNode<T>* root;BintreeNode<T>* Find_bt(T key,int &num,int itype=0)//一个二叉树查找算法,itype=1时有插入功能(不同的值时){num=0;if(root==0){num++;if(itype==0)return NULL;else{num1++;return root=new BintreeNode<T>(key);}}else{BintreeNode<T>* ptr=root,*p;while(ptr!=NULL){num++;p=ptr;if(ptr->data==key)return ptr;else{if(ptr->data>key)ptr=ptr->left;elseptr=ptr->right;}}if(itype){num1++;if(p->data>key)return p->left=new BintreeNode<T>(key);elsereturn p->right=new (BintreeNode<T>)(key);}return NULL;}//else}//Find_btBintree():root(0),num1(0){}~Bintree(){delete root;}};int compare(const void* a,const void* b){return *(int *)a-*(int *)b;}template<class T>class Link{public:T data;Link<T>* next;Link<T>():next(0){}Link<T>(T item):data(item),next(0){}~Link<T>(){if(next) delete next;}};template<class T>class LinkList{public:Link<T>* first;LinkList<T>():first(0){}~LinkList<T>(){if(first)delete first;}Link<T>* Find_hash(T key,int &num,int ntype=0)//查找与插入,当ntype=1时为插入{num=0;if(first==0){num++;if(ntype)return first=new Link<T>(key);elsereturn NULL;}else{Link<T>*ptr=first,*p;while(ptr!=NULL){num++;p=ptr;if(ptr->data==key)return ptr;ptr=ptr->next;}if(ntype)return p->next=new Link<T>(key);return NULL;}}};template<class T>class Hash{public:LinkList<T>* hashlist;int size;Hash<T>(int n=113):size(n){hashlist=new LinkList<T>[n];}~Hash<T>(){delete []hashlist;}void init_hash(T data[],int n)//初始化哈希查找表-----拉链法冲突调节{int t;for(int i=0;i<n;i++){int pos=data[i]%size;hashlist[pos].Find_hash(data[i],t,1);}}Link<T>* Find_hash(T key,int &num)//查找关键词采用除法杂凑函数{int pos=key%size;return hashlist[pos].Find_hash(key,num);}};int main(){srand(time(0));do{int n=rand()%100000+1000;int *a=new int[n];for(int i=0;i<n;i++)a[i]=rand()%100000;int key=rand()%n;int num;int j=Find_s(a,n,key,num);//使用顺序查找法查找key值的位置cout<<"数据总数:"<<n<<"\t查找关健字key:"<<key<<"\t查找比较次数:num\n顺序查找法:\npos:"<<j<<"\tdata:"<<a[j]<<" num:"<<num<<endl;Bintree<int> btree;for(int k=0;k<n;k++)btree.Find_bt(a[k],num,1);//未排序之前插入到二叉查找树中qsort(a,n,sizeof(int),compare);//对数组进行升序排序cout<<"二分查找法:"<<endl;cout<<"pos:"<<Find_t(a,n,key,num)<<"\tnum:";//使用二分查找法查找key值的位置cout<<num<<endl;cout<<"二叉查找树:"<<endl;cout<<"data:"<<(btree.Find_bt(key,num)==NULL?-1:btree.Find_bt( key,num)->data );cout<<"\tnum:"<<num<<endl;//"\tnum:"<<btree.num<<endl;Hash<int > hash(1000);hash.init_hash(a,n);cout<<"哈希表查找:"<<endl;cout<<"data:"<<((hash.Find_hash(key,num)==NULL)?-1:(hash.Find_ hash(key,num))->data);cout<<"\tnum:"<<num<<endl;}while(getchar()-'0');//直到输入为'0'时结束,一直按Enter可以继续进行运算return 0;}3.4调试分析通过调用三种函数、三种查找算法对随机数的查找可以得出性能由高到底以此为散列查找、二分法查找、二叉查找法。