大数据结构实验 二分查找
数据结构 查找 实验报告

数据结构查找实验报告数据结构查找实验报告1·实验目的本实验旨在研究不同的查找算法在不同数据结构下的性能表现,通过实验结果对比分析,选取最优算法来完成查找操作。
2·实验方法2·1 数据结构选择在本实验中,我们选择了常用的数据结构进行查找性能比较,包括线性表、二叉树、哈希表等。
2·2 查找算法选择我们选择了以下常用的查找算法进行实验:●顺序查找●二分查找●插值查找●二叉查找树●平衡二叉查找树(AVL树)●哈希查找3·实验过程3·1 实验环境设置首先,我们需要搭建合适的实验环境,包括编程语言选择、编译器、开发环境等。
在本次实验中,我们选择了C++编程语言,并使用了Visual Studio 2019作为开发环境。
3·2 实验步骤为了比较各个查找算法的性能,我们按照以下步骤进行实验: 1·创建用于查找的数据结构,并初始化数据集合。
2·调用每个查找算法进行查找,并记录查找耗时。
3·分析实验结果,比较各个查找算法的性能。
4·实验结果与分析根据实验步骤中记录的各个查找算法的耗时,我们得到了以下结果:●对于小规模数据集,顺序查找表现较好。
●对于有序数据集,二分查找和插值查找表现最佳。
●对于动态数据集,哈希表的查找效率最高。
5·结论根据实验结果与分析,我们得出以下结论:●不同的数据结构适用于不同的查找需求。
●在静态有序数据集中,二分查找和插值查找是较好的选择。
●在动态数据集中,哈希表具有较高的查找效率。
附件:附件1:实验数据集附件2:查找算法代码法律名词及注释:1·数据结构:数据之间的组织方式和关系,使得我们可以高效地进行数据的存储和操作。
2·查找算法:在给定某个目标值的情况下,在给定数据集内寻找目标值的算法。
3·顺序查找:逐个比较目标值和数据集内的元素,直到找到目标值或者遍历完整个数据集。
2分查找算法

2分查找算法二分查找算法,也称为折半查找算法,是计算机科学中一种常用的查找算法。
它的核心思想是将待查找的数据集合分成两半,然后通过与目标值的比较,确定目标值可能存在的范围,再逐步缩小范围,直到找到目标值或确定目标值不存在。
二分查找算法适用于有序的数据集合,可以快速定位目标值的位置,时间复杂度为O(logn)。
下面以二分查找算法为中心,详细阐述其原理和应用。
一、算法原理二分查找算法的原理非常简单,主要包含以下几个步骤:1.确定查找范围:将待查找的数据集合按照升序或降序排列,并确定查找范围的起始位置和结束位置。
2.计算中间位置:通过起始位置和结束位置计算出中间位置。
3.比较目标值:将目标值与中间位置的值进行比较。
-如果目标值等于中间位置的值,则查找成功,返回中间位置。
-如果目标值小于中间位置的值,则目标值可能在前半部分,将查找范围缩小到前半部分。
-如果目标值大于中间位置的值,则目标值可能在后半部分,将查找范围缩小到后半部分。
4.缩小查找范围:根据比较结果,缩小查找范围为前半部分或后半部分,并重复步骤2和步骤3,直到找到目标值或确定目标值不存在。
二、算法示例为了更好地理解二分查找算法,我们以一个具体的例子来说明:假设有一个按升序排列的数组[1,3,5,7,9,11,13,15,17, 19],我们要查找目标值为9的位置。
1.确定查找范围:起始位置为0,结束位置为9。
2.计算中间位置:(0+9)/2=4,中间位置为4。
3.比较目标值:目标值9大于中间位置的值7,所以目标值可能在后半部分。
4.缩小查找范围:将查找范围缩小到[9,11,13,15,17,19],起始位置更新为中间位置+1=5,结束位置不变。
5.重复步骤2和步骤3:计算新的中间位置(5+9)/2=7,中间位置为7。
目标值9小于中间位置的值15,所以目标值可能在前半部分。
6.缩小查找范围:将查找范围缩小到[9,11,13],起始位置更新为5,结束位置更新为中间位置-1=6。
二分搜索算法实验报告

二分搜索算法实验报告篇一:实验报告2--二分搜索技术注意:红色的部分需要用自己的代码或内容进行替换。
湖南涉外经济学院实验报告实验课程:算法设计与分析实验项目:二分搜索技术学院专业实验地点分组组号实验时间 XX年 3 月 10 日星期一第 12节指导老师【实验目的和要求】1. 理解分治法的原理和设计思想;2.要求实现二分搜索算法;3.要求交互输入一组关键字序列,输入需要查找的关键字;4. 要求显示结果。
【系统环境】操作系统:Windows XP 操作系统开发工具:VC++6.0英文企业版开发语言:C,C++【实验原理】1、问题描述给定已排好序的n个元素a[0…n-1],现要在这n个元素中找出一特定元素x。
2、实验原理二分搜索方法充分利用了元素间的次序关系(但也局限于此),采用分治策略,将n个元素分成个数大致相同的两半,取a[n/2]与x进行比较。
如果x=a[n/2],则找到x,算法终止。
如果xa[n/2],则只要在数组a的右半部继续搜索x。
【实验任务与步骤】1、实验步骤(可以根据自己的程序修改)(1) 实现顺序搜索。
(2) 实现二分搜索算法的递归算法。
(3) 实现二分搜索算法的非递归算法。
(4) 编写主函数,调用所写的三个算法进行测试,并进行输出。
2、源程序代码// 此处为解决问题的完整源程序,要求带注释,代码必须符合书写规范。
(1) 顺序搜索(2) 递归的二分搜索(3) 非递归的二分搜索(原文来自:小草范文网:二分搜索算法实验报告)……【实验结论(包括实验数据处理、问题与解决办法、心得体会、意见与建议等)】// 此处为程序运行的结果,要求有程序运行输入输出实例,要求至少有两组实验结果。
// 必须写心得体会、意见与建议等,或者遇到的问题、难题等。
……篇二:查找排序实验报告实验十:查找、排序计算机学院 12级2班 12110XX 李龙实验目的:1.掌握折半查找算法的思想。
2.实现折半查找的算法。
3.掌握常见的排序算法(插入排序、交换排序、选择排序等)的思想、特点及其适用条件。
二分法查找心得

二分法查找心得
二分法查找,也称为折半查找,是一种在已排序数组中高效查找目标值的算法。
通过反复将数组一分为二,不断缩小查找范围,直到找到目标值或确定目标值不存在。
以下是我在使用二分法查找算法时的一些心得:
1. 前提条件:二分法查找要求数组必须是有序的,这是算法能够正确工作的前提。
在使用二分法查找之前,需要确保输入的数组已经按照升序或降序进行了排序。
2. 递归思想:二分法查找通过递归的方式实现,每次将数组一分为二,缩小查找范围。
理解和运用递归的思想对于理解和实现二分法查找至关重要。
3. 边界情况处理:在递归过程中,需要注意边界情况的处理。
当查找范围缩小到只有一个元素时,需要进行特殊处理,返回找到的目标值或确定目标值不存在。
4. 时间复杂度:二分法查找的时间复杂度为 O(log n),其中 n 是数组的长度。
这意味着对于大型数组,二分法查找的效率要远远高于顺序查找。
5. 空间复杂度:二分法查找的空间复杂度为 O(1),它只使用了固定的额外空间来存储中间结果,因此在空间复杂度上具有优势。
6. 应用场景:二分法查找适用于有序数组的查找操作,特别是在数组较大且需要高效查找的情况下。
它可以应用于各种领域,如数据库查询、数值计算等。
总的来说,二分法查找是一种简单而高效的算法,它充分利用了数组的有序性,通过不断缩小查找范围来提高查找效率。
在实际应用中,理解和掌握二分法查找算法可以帮助我们解决很多查找问题。
实验十二实现顺序和二分查找算法

实验十二实现顺序和二分查找算法实验十二:顺序和二分查找算法的实现一、引言在计算机科学中,查找是一种常见且重要的操作。
查找算法通过在数据集合中查找指定元素的位置,以及判断该元素是否存在,并返回相应的结果。
顺序查找和二分查找是两种常见的查找算法。
本实验将详细介绍并实现这两种算法。
二、顺序查找算法顺序查找算法,也称为线性查找算法,是一种简单直观的查找方法。
它逐个比较待查找的元素与数据集合中的每个元素,直到找到所需元素或遍历完整个数据集合。
以下是顺序查找算法的伪代码实现:1.初始化一个计数器i为0,用于记录当前查找的元素的索引位置。
2.从数据集合的第一个元素开始,逐个与待查找元素进行比较。
3.若找到所需元素,返回元素索引i。
4.若遍历完整个数据集合仍未找到所需元素,返回-1,表示未找到。
以下是使用Python编写的顺序查找算法的实现示例:```def sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1```以上代码通过遍历列表中的每一个元素,逐个与目标元素进行比较,若找到则返回目标元素的索引,若未找到则返回-1、这是顺序查找算法的基本思想。
二分查找算法是一种高效的查找算法,也称为折半查找。
它要求待查找的数据集合必须有序排列。
算法的基本思想是通过将待查找区间反复划分为两半,然后确定目标元素存在的区间,最终找到所需元素或判断其不存在。
以下是二分查找算法的伪代码实现:1. 初始化一个左指针left指向数据集合的第一个元素,一个右指针right指向数据集合的最后一个元素。
2. 取中间位置middle,计算出该位置对应的元素mid_value。
3. 若mid_value等于目标元素target,则返回middle。
4. 若mid_value大于目标元素target,则将右指针right移动到middle-1的位置。
数据结构之二分法查找、快速排序思想与实现

数据结构之⼆分法查找、快速排序思想与实现最近总是在想着,如何去设计,如何更好的编码,更充分地体会⾯向对象的思想,也刻意往这⽅⾯去学习。
写了⼏年代码,也改总结总结,发现最重要的还是在与思考。
重温了⼀下《程序设计实践》这本书,进⼀步规范反思下⾃⼰写的代码风格、质量、性能、可移植性等。
对了数据结构这⽅⾯的知识与算法进⼀步巩固。
下⾯写笔试经常遇见的算法:⼆分法查找、快速排序算法。
实现算法其关键在于实现的思想。
(⼀)⼆分法查找⼆分法查找其实就是折半查找,⼀种效率较⾼的查找⽅法。
针对有需数组来查找的。
主要思想是:(设查找的数组期间为array[low, high])(1)确定该期间的中间位置K(2)将查找的值T与array[k]⽐较。
若相等,查找成功返回此位置;否则确定新的查找区域,继续⼆分查找。
区域确定如下:a.array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……,K-1]b.array[k]<T 类似上⾯查找区间为array[k+1,……,high]。
每⼀次查找与中间值⽐较,可以确定是否查找成功,不成功当前查找区间缩⼩⼀半。
递归找,即可。
时间复杂度:O(log2n);代码实现:/// <summary>/// ⼆分法查找/// </summary>/// <param name="array">⽬标数组(已经排序好了)</param>/// <param name="a">查找的数</param>/// <returns>⽬标数的索引</returns>public int BinarySearch(int[] array, int T){int low, high, mid;low = 0;high = array.Length - 1;while (low <= high){mid = (low + high) / 2;if (array[mid] < T){low = mid + 1;}else if (array[mid]>T){high = mid - 1;}else{return mid;}}return -1;}(⼆)快速排序算法快速排序是尽量避免额外计算的极好例⼦.其⼯作⽅式是在数组中划分出⼩的和⼤的元素基本思想是:从数组中取出⼀个元素作为基准值把其他元素分为两组:“⼩的”是那些⼩于基准值的元素。
二分查找法实现及时间复杂度解析

二分查找法实现及时间复杂度解析二分查找法,也称折半查找法,是一种高效的查找算法。
它的基本思想是将查找区间逐步缩小,直到找到目标元素或确认目标元素不存在。
在本文中,我们将介绍二分查找法的详细实现方法,并对其时间复杂度进行解析。
一、二分查找法的实现二分查找法适用于有序数组,它通过不断地将目标元素与数组中间的元素进行比较,以确定目标元素在数组中的位置。
下面是二分查找法的实现算法:1. 首先,确定查找的起始位置start和结束位置end。
一般情况下,start为数组的第一个元素的下标,end为数组的最后一个元素的下标。
2. 计算中间位置mid,mid的值等于(start + end) / 2。
3. 比较中间位置的元素与目标元素的大小关系。
如果中间位置的元素等于目标元素,则查找成功;如果中间位置的元素大于目标元素,则在左半部分继续查找;如果中间位置的元素小于目标元素,则在右半部分继续查找。
4. 如果找到目标元素,则返回目标元素所在的位置;如果数组中不存在目标元素,则返回-1表示查找失败。
5. 如果中间位置的元素与目标元素不相等,并且查找区间仍然存在,重复以上步骤。
6. 当start > end时,表示查找区间不存在,查找失败。
二、时间复杂度解析二分查找法的时间复杂度是O(logn),其中n是数组的长度。
这是因为每次查找都将查找区间缩小一半,所以需要进行logn次查找。
在最坏的情况下,即要查找的目标元素位于数组的两头,需要进行logn次查找。
在平均情况下,二分查找法的时间复杂度依然是O(logn)。
需要注意的是,二分查找法只适用于有序数组。
如果数组是无序的,需要先进行排序,然后再进行二分查找。
三、总结二分查找法是一种高效的查找算法,适用于有序数组。
通过将查找区间逐步缩小,可以快速定位目标元素的位置。
同时,它的时间复杂度为O(logn),在大规模数据查找时能够有效提高查找效率。
当然,二分查找法也有一些限制:首先,它要求数组是有序的;其次,数组的大小不能动态改变。
数据结构实验二分查找

数据结构实验二分查找二分查找是一种在有序数组中查找给定元素的高效算法,也称为二分或折半查找。
它的基本思想是在每一次比较中,将待查找区间分成两部分,并将目标值与中间元素进行比较。
如果目标值小于中间元素,则在前半部分继续查找;如果目标值大于中间元素,则在后半部分查找;如果相等,则找到了目标值。
重复这个过程,直到找到目标值或者待查找区间为空。
二分查找算法的时间复杂度为O(log n),其中n是数组的长度。
这是因为每一次比较都将待查找区间减半,直到找到目标值或者待查找区间为空。
因此,无论数组的大小有多大,二分查找都能在较短的时间内找到目标值。
以下是一个使用二分查找算法在有序数组中查找元素的示例代码:```pythondef binary_search(arr, target):left = 0right = len(arr) - 1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid - 1return -1arr = [1, 3, 5, 7, 9]target = 5result = binary_search(arr, target)if result != -1:print("元素在数组中的索引为", result)else:print("元素不在数组中")```在上述示例代码中,我们首先定义了一个`binary_search`函数,该函数接收一个有序数组`arr`和一个目标值`target`作为输入参数。
然后,我们使用两个指针`left`和`right`来表示待查找区间的左右边界。
初始时,`left`指向数组的第一个元素,`right`指向数组的最后一个元素。
二分查找 数据结构 面试题

二分查找数据结构面试题
二分查找是一种在有序数组中查找特定元素的搜索算法。
搜索过程从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜索过程结束;如果某一特定元素大于或者小于中间元素,则在数组大于或小于中间元素的那一半中查找,而且跟开始一样从中间元素开始比较。
如果在某一步骤数组为空,则代表找不到。
这种搜索算法每一次比较都使搜索范围缩小一半。
以下是几个关于二分查找的面试题:
1. 请解释一下二分查找的工作原理。
2. 如果你有一个无序数组,你会如何使用二分查找?
3. 能否给出二分查找的一个非递归实现?
4. 在什么情况下二分查找可能不是最佳选择?
5. 你能描述一下二分查找的时间复杂度和空间复杂度吗?
6. 在二分查找中,如何处理查找元素不存在的情况?
7. 你能写一个在Python中实现二分查找的代码吗?
8. 在二分查找中,如何处理数组中有重复元素的情况?
9. 你能解释一下为什么二分查找在平均情况下比线性查找更快吗?
10. 你能给出一些使用二分查找的实际应用场景吗?
以上就是一些关于二分查找的面试题,希望对你有所帮助。
数据结构实验五查找算法应用

数据结构实验五查找算法应用查找算法是计算机科学中一个基础且重要的问题。
在实际应用中,查找算法的效率直接影响了程序的执行效率。
在本次实验中,我们将探讨不同的查找算法,并研究这些算法在各种应用场景中的具体应用。
1.线性查找算法线性查找是最简单的查找算法之一,它的基本思想是从头到尾依次遍历待查找的元素,直到找到目标元素或遍历完所有元素。
线性查找算法的时间复杂度为O(n),其中n为待查找元素的个数。
线性查找算法适用于元素无序的列表,例如无序数组、链表等。
它的一个典型应用场景是在一个无序数组中查找一些元素,并返回其下标。
它还常用于对一个无序数组进行去重操作,即对数组中的元素进行遍历,删除重复的元素。
2.二分查找算法二分查找算法是一种高效的查找算法,它的前提条件是数组已经按照升序或降序排列。
算法的基本思想是每次将待查找区间缩小一半,直到找到目标元素或区间为空。
二分查找算法的时间复杂度为O(logn),其中n 为待查找元素的个数。
二分查找算法适用于元素有序的列表,例如有序数组。
它的一个典型应用场景是在一个有序数组中查找一些元素,并返回其下标。
二分查找算法还可以用于在一个有序数组中查找第一个等于目标值的元素或最后一个等于目标值的元素。
3.平衡二叉树(AVL树)平衡二叉树是一种二叉树的扩展,它通过对树的节点进行平衡操作来保持树的高度平衡。
平衡二叉树的平衡操作包括左旋、右旋、左右旋和右左旋。
通过平衡操作,平衡二叉树能够保证树的高度为logn,从而使得查找操作的时间复杂度为O(logn)。
平衡二叉树适用于需要频繁进行插入、删除和查找操作的场景。
一个典型的应用场景是字典的实现,通过将所有单词按照字母顺序插入到平衡二叉树中,就能够实现高效的单词查找。
4.哈希查找算法哈希查找算法是一种基于哈希表的查找算法,它的基本思想是将待查找的键映射到哈希表的桶中,并在桶中进行查找。
哈希查找算法的时间复杂度为O(1),但是需要额外的内存空间来存储哈希表。
数据结构查找实验报告

数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能比较,分析它们在不同数据规模和分布情况下的效率和适用场景。
二、实验环境本次实验使用的编程语言为 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. 如果中间值等于目标值,则搜索成功,返回结果;4. 如果中间值大于目标值,则目标值在左子列表中,将右边界缩小为中间值的前一个位置;5. 如果中间值小于目标值,则目标值在右子列表中,将左边界扩大为中间值的后一个位置;6. 重复以上步骤,直到找到目标值或搜索范围为空。
二、实验设计为了验证二分搜索算法的效率和准确性,我们设计了两个实验:一是对已排序的列表进行搜索,二是对随机生成的列表进行搜索。
1. 实验一:对已排序的列表进行搜索我们首先生成一个已排序的列表,将其作为实验对象。
然后,我们随机选择一个目标值,并使用二分搜索算法进行搜索。
记录下搜索的次数和搜索所花费的时间。
重复实验多次,取平均值作为结果。
2. 实验二:对随机生成的列表进行搜索为了模拟实际应用场景,我们生成了一个随机列表,并进行排序。
然后,我们随机选择一个目标值,并使用二分搜索算法进行搜索。
同样地,记录下搜索的次数和搜索所花费的时间,重复实验多次,取平均值作为结果。
三、实验结果经过多次实验,我们得到了如下结果:1. 实验一:对已排序的列表进行搜索在已排序的列表中,二分搜索算法的效率非常高。
平均搜索次数为log2(n),其中n为列表的长度。
搜索时间与搜索次数成正比,因此搜索时间也非常短暂。
2. 实验二:对随机生成的列表进行搜索在随机生成的列表中,二分搜索算法的效率相对较低。
虽然搜索次数仍然是log2(n),但由于列表本身的无序性,搜索时间会有所增加。
然而,与线性搜索算法相比,二分搜索算法仍然具有明显的优势。
【数据结构】查找算法:二分查找、顺序查找

【数据结构】查找算法:二分查找、顺序查找查找算法查找算法是在存在的序列(list)中查找特定的目标(target),要求序列中每个记录必须与一个关键词(key)关联才能进行查找。
查找算法通常需要两个输入:1、被查找的序列2、要查找的关键词查找算法的输出参数和返回值:1、返回类型为 Error_code 的值用以表示是否查找成功2、如果查找成功,返回success,输出参数position 定位到目标所在位置3、如果查找失败,返回 not present,输出参数可能是未定义或不同于已有位置的任何值顺序查找算法顺序查找算法的思路很简单:从表的第一个元素开始一个一个向下查找,如果有和目标一致的元素,查找成功;如果到最后一个元素仍没有目标元素,则查找失败。
【实验说明】题目:编写一个程序,对顺序表{3,6,2,10,1,8,5,7,4,9},采用顺序查找关键字5的过程。
要求输出:1)原顺序表;2)查找到关键字的位置;3)进行比较的次数。
1.首先要编写类表List。
需要满足最基本的操作插入insert(),获取retrieve(),以及得到大小size()。
2.我们观察题目要求,表中虽然存储的是简单的整数,但如果我们使用List<int>对象显然无法记录比较次数,所以我们自己写一个类Key通过其内部int类型的数据成员来记录存于表中的值,并模仿int基本的逻辑操作,即编写重载逻辑运算符,同时增加一个静态数据成员comparisons用于记录其比较操作的次数。
3.准备工作做好之后开始编写顺序查找算法。
算法的思路很简单,也较易实现,从表中第一个元素开始比较,发现目标则返回元素所在表中位置;若遍历之后没有目标,则查找失败,返回-1表示表中没有目标元素。
4.按题目要求编写最后的输出函数。
【相关代码】函数 sequential_search[cpp]view plaincopy1.int sequential_search(const List<int> &the_list,2.const Key &target)3./*Post: If an entry in the_list is equal to target, thenreturn the position4. of this entry.5. Otherwise return -16.*/7.{8.int position;9.int s=the_list.size();10.for(position=0;position<s;position++){11.int data;12. the_list.retrieve(position,data);13.if(data==target){14.return position;15. }16. }17.return -1;18.}二分查找算法二分查找前提是表是按递增或递减顺序的规范表。
数据结构查找算法实验报告

数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能分析,比较它们在不同数据规模和分布情况下的效率和优劣。
二、实验环境操作系统: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、理解递归得概念;3、掌握设计有效算法得分治策略;4、通过二分搜索技术学习分治策略设计技巧;二.实验内容及要求1. 使用二分搜索算法查找任意N个有序数列中得指定元素。
2.通过上机实验进行算法实现。
3. 保存与打印出程序得运行结果,并结合程序进行分析,上交实验报告。
4、至少使用两种方法进行编程。
三.实验原理二分搜索算法也称为折半查找法,它充分利用了元素间得次序关系,采用分治策略,可在最坏得情况下用O(log n)完成搜索任务。
【基本思想】将n个元素分成个数大致相同得两半,取a[n/2]与欲查找得x作比较,如果x=a[n/2]则找到x,算法终止。
如果x<a[n/2],则我们只要在数组a得左半部继续搜索x(这里假设数组元素呈升序排列)。
如果x>a[n/2],则我们只要在数组a得右半部继续搜索x。
二分搜索法得应用极其广泛,而且它得思想易于理解。
第一个二分搜索算法早在1946 年就出现了,但就是第一个完全正确得二分搜索算法直到1962年才出现。
Bentley在她得著作《Writing Correct Programs》中写道,90%得计算机专家不能在2小时内写出完全正确得二分搜索算法。
问题得关键在于准确地制定各次查找范围得边界以及终止条件得确定,正确地归纳奇偶数得各种情况,其实整理后可以发现它得具体算法就是很直观得。
✧方法一:直接查找穷举法遍历✧方法二:递归查找#include<stdio、h>#define MAX30intBinarySearch(inta[],int &x,int left,int right){if(left>right){return-1;}else{left=(left+right)/2;if(x==a[left])returnleft;else{if(x>a[left])BinarySearch(a,x,left+1,right);elseBinarySearch(a,x,left*2-right,left+1);}}}main(){inta[MAX];int found,x,n,i,j,p;printf("输得个数\n");scanf("%d",&n);printf("数组数据\n");for(i=0;i<n;i++){scanf("%d",&a[i]);}for(i=0;i<n-1;i++){p=i;for(j=i+1;j<n;j++)if(a[p]>a[j])p=j;if (p!=j){x=a[p];a[p]=a[i];a[i]=x;}}for(i=0;i<n;i++){printf("%d ",a[i]);}printf("输入要查找得数\n");scanf("%d",&x);found=BinarySearch(a,x,0,n);if(found==-1){printf("未找到\n");}else{printf("要查找得数在第%d个\n",found+1);}}方法三:迭代查找#include<stdio、h>#define MAX30int BinarySearch(inta[],int &x,int n){int left =0;int right=n-1;int middle;while(left<=right){middle=(left+right)/2;if(x==a[middle])returnmiddle;if(x>a[middle])left=middle+1;elseright=middle-1;}return-1;}main(){int a[MAX];int found,x,n,i,j,p;printf("数得个数\n");scanf("%d",&n);printf("数组数据\n");for(i=0;i<n;i++){scanf("%d",&a[i]);}for (i=0;i<n-1;i++){p=i;for(j=i+1;j<n;j++)if (a[p]>a[j])p=j;if (p!=j){x=a[p];a[p]=a[i];a[i]=x;}}for(i=0;i<n;i++){printf("%d ",a[i]);}printf("输入要查找得数\n");scanf("%d",&x);found=BinarySearch(a,x,n);if(found==-1){printf("未找到\n");}else{printf("要查找得数在第%d 个\n",found+1);}}四.程序代码变量定义说明:BinarySearch()算法: a->数组key->要查找得元素left->左标志right->右标志(n->数据个数)Main()主函数: ﻩound->就是否找到标志,-1表示未找到,找到其值为下标x->要查找得元素n->元素个数i,j,p->循环控制变量(1)、递归查找#include<stdio、h>#defineMAX 30int BinarySearch(int a[],int key,int left,int right){intmid=(right-right)/2+left;if(a[mid]==key){returnmid;}if(left>=right) {return -1;}else if(key>a[mid]) {returnBinarySearch(a,key,mid+1,right);}else if(key<a[mid]){return BinarySearch(a,key,left,mid-1);}return -1;}int main(void){int a[MAX];intfound,x,n,i,j,p;printf("数据个数:");scanf("%d",&n);printf("输入数据:\n");for(i=0;i<n;i++){printf("请输入第%d个数据:",i);scanf("%d",&a[i]);}for (i=0;i<n-1;i++) //选择排序{p=i;ﻩﻩfor(j=i+1;j<n;j++)ﻩﻩif(a[p]>a[j])ﻩﻩp=j;ﻩﻩif(p!=j)ﻩ{x=a[p];a[p]=a[i];ﻩa[i]=x;}}printf("排序后得数据如下:");for(i=0;i<n;i++){printf("%d ",a[i]);}printf("\n");printf("输入要查找得数:");scanf("%d",&x);int left=0,right=n;found=BinarySearch(a,x,left,right);if(found==-1){printf("未找到\n");}else{printf("要查找得数在第%d个\n",found+1);}}(2)、非递归查找#include<stdio、h>#defineMAX30int BinarySearch(inta[],int key,intlen){ﻩint mid=len/2;if (key==a[mid]) {return mid;}int left=0;intright=len-1;while(left<=right){ ﻩ//迭代查找mid=(right+left)/2;if(key<a[mid]) {right=mid-1;}else if(key>a[mid]) {left=mid+1;}else{return mid;}}return -1;}int main(void){int a[MAX];int found,x,n,i,j,p;printf("数据个数:");scanf("%d",&n);printf("输入数据:\n");for(i=0;i<n;i++){ﻩprintf("请输入第%d个数据:",i);scanf("%d",&a[i]);}for (i=0;i<n-1;i++)ﻩﻩ//选择排序{ﻩﻩp=i;ﻩfor(j=i+1;j<n;j++)if(a[p]>a[j])p=j;if(p!=j)ﻩ{x=a[p];a[p]=a[i];ﻩﻩa[i]=x;}}printf("排序后得数据如下:");for(i=0;i<n;i++){printf("%d ",a[i]);}printf("\n");printf("输入要查找得数:");scanf("%d",&x);int left=0,right=n;found=BinarySearch(a,x,n);if(found==-1){printf("未找到\n");}else{printf("要查找得数在第%d个\n",found+1);}}五.结果运行与分析找到要查找得数据:未找到要查找得数据:六.心得与体会通过这次实验,巩固了自己对二分搜索算法得理解,它就是分治法得一个特殊例子,由此也对分治法有了更深一层次得认识。
数据结构实验七-二分排序

1
void main() {
rec A; int j,n,i; printf("\n\n 输入初始数据(每个数据一空格隔开,-1结束):"); n=0; scanf("%d", &j); while(j!=-1) {
n++; A[n]=j; scanf("%d",&j); } printf("插入排序\n\n排序前\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); InsertSort1(A,n); printf("\n\n排序后\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); }
2
数据结构实验报告七
班级:
姓名: 吴前斌
学号:
课程名称
数据结构
实验项目 排序
实验项目类型 验演综设 证示合计
指导掌握二分排序的基本概念,掌握二分排序的基本思想和算法实现。
二、实验内容 设计一个算法用二分查找实现插入排序的“寻找插入位置”操作。
三、实验要求 二分查找:在有序表中进行,先确定表的中点位置,再通过比较确定下一步查找哪个半区。
四、实验过程及结果:
# include "stdio.h" # define Max 20 typedef int elemtype; typedef elemtype rec[Max];
void InsertSort1(rec A,int n) {
int i,j,low,high,mid,now; for(i=2; i<=n; i++) {
数据结构50:二分查找法(折半查找法)

数据结构50:⼆分查找法(折半查找法)折半查找,也称⼆分查找,在某些情况下相⽐于顺序查找,使⽤折半查找算法的效率更⾼。
但是该算法的使⽤的前提是静态查找表中的数据必须是有序的。
例如,在{5,21,13,19,37,75,56,64,88 ,80,92}这个查找表使⽤折半查找算法查找数据之前,需要⾸先对该表中的数据按照所查的关键字进⾏排序:{5,13,19,21,37,56,64,75,80,88,92}。
在折半查找之前对查找表按照所查的关键字进⾏排序的意思是:若查找表中存储的数据元素含有多个关键字时,使⽤哪种关键字做折半查找,就需要提前以该关键字对所有数据进⾏排序。
折半查找算法对静态查找表{5,13,19,21,37,56,64,75,80,88,92}采⽤折半查找算法查找关键字为 21 的过程为:图 1 折半查找的过程(a)如上图 1 所⽰,指针 low 和 high 分别指向查找表的第⼀个关键字和最后⼀个关键字,指针 mid 指向处于 low 和 high 指针中间位置的关键字。
在查找的过程中每次都同 mid 指向的关键字进⾏⽐较,由于整个表中的数据是有序的,因此在⽐较之后就可以知道要查找的关键字的⼤致位置。
例如在查找关键字 21 时,⾸先同 56 作⽐较,由于21 < 56,⽽且这个查找表是按照升序进⾏排序的,所以可以判定如果静态查找表中有 21这个关键字,就⼀定存在于 low 和 mid 指向的区域中间。
因此,再次遍历时需要更新 high 指针和 mid 指针的位置,令 high 指针移动到 mid 指针的左侧⼀个位置上,同时令 mid 重新指向 low 指针和 high 指针的中间位置。
如图 2 所⽰:图 2 折半查找的过程(b)同样,⽤ 21 同 mid 指针指向的 19 作⽐较,19 < 21,所以可以判定 21 如果存在,肯定处于 mid 和 high 指向的区域中。
所以令 low 指向 mid 右侧⼀个位置上,同时更新 mid 的位置。
数据结构查找算法实验报告-无删减范文

数据结构查找算法实验报告数据结构查找算法实验报告1. 引言数据结构查找算法是计算机科学中的重要部分,它涉及在给定的数据集中搜索特定元素的算法。
在本实验中,我们将研究和比较两种常见的查找算法:顺序查找和二分查找。
通过实验,我们将评估它们在不同数据规模下的性能表现,并分析其时间复杂度和空间复杂度。
2. 实验目的- 研究和理解顺序查找算法和二分查找算法的原理;- 实现顺序查找算法和二分查找算法并进行性能比较;- 分析不同数据规模下两种算法的时间复杂度和空间复杂度。
3. 实验方法和实验步骤3.1 实验环境本实验使用以下实验环境进行开发和测试:- 操作系统:Windows 10- 编程语言:Python 3.9.13.2 顺序查找算法顺序查找算法是一种简单直接的查找方法,它逐个比较数据集中的元素,直到找到目标元素或遍历完整个数据集。
以下是顺序查找算法的实现步骤:1. 从数据集的第一个元素开始,逐个比较元素与目标元素是否相等;2. 如果相等,则返回目标元素的位置索引;3. 如果遍历完整个数据集仍未找到目标元素,则返回-1表示未找到。
以下是顺序查找算法的代码实现:```pythondef sequential_search(data, target):for i in range(len(data)):if data[i] == target:return ireturn -1```3.3 二分查找算法二分查找算法是一种高效的查找方法,它要求数据集已经有序。
以下是二分查找算法的实现步骤:1. 初始化左右两个指针,分别指向数据集的第一个元素和最后一个元素;2. 计算中间元素的位置索引,并与目标元素进行比较;3. 如果中间元素等于目标元素,则返回中间元素的位置索引;4. 如果中间元素大于目标元素,则将右指针移动到中间元素的前一个位置;5. 如果中间元素小于目标元素,则将左指针移动到中间元素的后一个位置;6. 重复上述步骤,直到找到目标元素或左指针大于右指针为止;7. 如果未找到目标元素,则返回-1。
(完整版)冒泡排序和二分查找实验报告

冒泡排序和二分查找实验报告一实验题目: 基于冒泡排序的二分查找二实验要求:2.1: 输出在顺序表中利用二分的方法查找关键字 9 的过程。
2.2:实现冒泡排序的过程,并输出{9,8,7,6,5,4,3,2,1,0}的过程三实验内容:3.1 动态查找表的抽象数据类型:ADT DynamicSearchTable {数据对象D:D是具有相同特性的数据元素的集合。
各个数据元素均含有类型相同,可唯一标识数据元素的关键字数据关系R:数据元素同属一个集合。
基本操作 P:InitDSTable(&DT);操作结果:构造一个空的动态查找表DT。
DestroyDSTable(&DT)初始条件:动态查找表DT存在。
操作结果:销毁动态查找表DT。
SearchDSTable(DT,key);初始条件:动态查找表DT存在,key为和关键字类型相同的给定值。
操作结果:若DT中存在其关键字等于key的数据元素,则函数值为该元素的值或在表中的位置,否则为“空”。
InsertDSTable(&DT,e);初始条件:动态查找表DT存在,e为待插入的数据元素。
操作结果:若DT中不存在其关键字等于e.key的数据元素,则插入e到DT。
DeleteDSTable(&DT,key);初始条件:动态查找表DT存在,key为和关键字类型相同的给定值。
操作结果:若DT中存在其关键字等于key的数据元素,则删除之。
TraverseDSTable(DT,visit());初始条件:动态查找表DT存在,visit是对结点操作的应用函数。
操作结果:按某种次序对DT的每个结点调用函数visit()一次且至多一次,一旦visit() 失败,则操作失败。
}ADT DynamicSearchTable3.2存储结构的定义;///二分查找#define maxn 100typedef struct{int key;char data[10];}NodeType;typedef NodeType SeqList[maxn];///冒泡排序#define maxn 20typedef struct{int key;char data[10];} RecType;3.3基本操作实现:int BinSearch(SeqList R, int n ,int k){int l = 0, r = n - 1,mid , count = 0;while(l <= r){mid = (l + r)/2;printf(" 第%d 次比较:在[ %d , %d ] 中比较元素R[%d]: %d\n",++count,l,r,mid,R[mid].key);if(R[mid].key == k){return mid;}else if(R[mid].key > k){r = mid - 1;}else{l = mid + 1;}}return -1;}void BubbleSort(RecType R[],int n){int i, j, k;RecType temp;for(i = 0;i < n - 1; ++i){for(j = n - 1; j > i; --j){if(R[j].key < R[j - 1].key){temp = R[j];R[j] = R[j - 1];R[j - 1] = temp;}}printf("i = %d ,冒出的最小关键字: %d ,结果为:",i, R[i].key); for(k = 0;k < n; ++k)printf("%2d",R[k].key);printf("\n");}}3.4解题思路:二分查找:因为原本便是顺序表,是递增序列,所以在一个区间中,我们只要每次判断中间节点和被查找的关键字的大小关系,就可以判断被查找的节点在那一段区间了,然后再进行二分即可。
数据结构实验二分查找

数据结构实验二分查找一、实验目的通过本次实验,我们了解二分查找算法的原理以及实现方法,掌握如何使用二分查找算法在有序数组中查找目标元素。
二、实验原理二分查找,也称折半查找,是一种基于有序数组的查找算法。
它将目标元素与数组中间的元素进行比较,如果相等则返回目标元素的索引;如果目标元素小于中间元素,则在左半部分数组中进行查找;如果目标元素大于中间元素,则在右半部分数组中进行查找。
通过不断缩小查找范围,最终可以找到目标元素。
二分查找的步骤如下:1. 定义起始索引start为0,结束索引end为数组长度减一2. 将目标值与中间元素进行比较,如果相等则返回中间索引;如果目标值小于中间元素,则将结束索引end设置为中间索引减一,并重复步骤2;如果目标值大于中间元素,则将起始索引start设置为中间索引加一,并重复步骤23.如果起始索引大于结束索引,则目标元素不存在于数组中。
三、实验步骤1.创建一个有序数组,用于存放待查找的元素。
2. 定义一个函数binarySearch,接收一个目标值和有序数组作为参数,返回目标值在数组中的索引,如果不存在则返回-13. 在binarySearch函数中,定义起始索引start为0,结束索引end为数组长度减一4. 使用while循环,在起始索引小于等于结束索引时进行查找。
5. 在while循环中,计算中间索引mid,将目标值与中间元素进行比较。
6.如果目标值等于中间元素,则返回中间索引。
7. 如果目标值小于中间元素,则将结束索引end设置为中间索引减一8. 如果目标值大于中间元素,则将起始索引start设置为中间索引加一9. 当while循环结束时,表示目标元素不存在于数组中,返回-1四、实验代码```#include <iostream>using namespace std;int binarySearch(int target, int arr[], int size)int start = 0;int end = size - 1;while (start <= end)int mid = start + (end - start) / 2;if (arr[mid] == target)return mid;} else if (arr[mid] > target)end = mid - 1;} elsestart = mid + 1;}}return -1;int maiint arr[] = {1, 3, 5, 7, 9, 11};int target = 5;int size = sizeof(arr) / sizeof(arr[0]);int result = binarySearch(target, arr, size);if (result != -1)cout << "目标元素在数组中的索引为:" << result << endl; } elsecout << "目标元素不存在于数组中" << endl;}return 0;```五、实验结果对于有序数组{1,3,5,7,9,11}和目标元素5,使用二分查找算法可以找到目标元素的索引为2六、实验总结通过本次实验,我们了解了二分查找算法的原理和实现方法,在有序数组中成功找到目标元素。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课程题目:
数据结构实验
学院:
班级:
姓名:
学号:
●实验题目:查找的应用
●实验内容:二分查找
●实验目的:掌握查找法的工作原理及应用过程,利用其工作原理完成上述实验题目中的内容。
●实验要求:为了使学生更好的掌握与理解课堂上老师所讲的概念与原理,实验前每个学生要认真预习所做的实验内容及编写源程序伪码(写在纸上及盘中均可) 以便在实验课中完成老师所布置的实验内容。
●实验学时:4学时
●设计原理:二分查找(Binary Search) 又称折半查找,它是一种效率比较高的查找方法。
但是,这种查找方法的前提是:“已经排序好的线性表”。
我们的一维数组就是线性表。
一位数组中的成员数据必须已经排序好了,才能用二分法来进行查找操作。
排序可以是升序,也可是降序。
二分查找法也是一种通过关键字比较的查找方法。
他的原理就是用关键字与被查找数据集(如一维数组)的中间位置(以下均是指下标)的数据比较。
我们假设有一个20个数据的一位数组,升序。
[a1,a2,a3,........,a20] 我们要查找的数据值为Key 。
中间位置的计算方法为:mid=(首+尾)/2的底。
“首”是指第一个数组成员的下标数组成员的下标值,“尾”在易语言自然是命令“取数组成员数(数组)”的值。
“底”相当于易语言中的“取整”命令如本例mid=(1+20)/2=10.5 取底mid=10 则首先Key与数组的第10个
成员进行比较。
如果Key>a10,那么我们要找的数据就可能在数组的第11到20成员之间,反之,Key<a10,我们要找的数据就可能在数组的1到9之间。
这样就确定了定了新的寻找范围。
重复以上步骤,直到寻找结束。
最后的结果是:找到|| 未找到。
●详细程序清单及注释说明:
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配增量typedefstruct
{
int *elem; //存储空间基址
int length; //当前长度
int listsize; //当前分配的存储空间(以sizeof(ElemType)为单位) }Sqlist;
void initlist_sq(Sqlist &l)
{
l.elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
l.length=0; //空表长度为0
l.listsize=LIST_INIT_SIZE; //初始存储容量
}
void amount(Sqlist &l)
{//输入数组长度以及每个数组元素的值int a,b,c;
loop:printf("请输入数字的个数:");
scanf("%d",&b);
if(b<=0)
{
printf("输入错误!请重新输入!\n");
goto loop;
}
printf("\n");
l.length=l.length+b; //确定表长
printf("请输入数组元素!\n");
for(a=1;a<=l.length;a++)
{
printf("输入第%d个数:",a);
printf("\n");
scanf("%d",&c);
l.elem[a]=c;
}
}
void order(Sqlist &l)
{//按照冒泡排序法为数组中的元素排序(升序) int i,j,k;
for(i=1;i<=l.length;i++)
for(j=1;j<=l.length-i;j++)
if(l.elem[j]>l.elem[j+1])
{
k=l.elem[j];
l.elem[j]=l.elem[j+1];
l.elem[j+1]=k;
}
}
void output(Sqlist &l)
{//将排序后的数组元素输出
printf("经排序后的数组元素:");
for(int i=1;i<=l.length;i++)
{
printf("%d",l.elem[i]);
printf(" ");
}
printf("\n");
}
int Search_Bin(Sqlist l,int k ey)
{
int low=1; //置区间初值
int high=l.length; //置区间初值
int mid;
while(low<=high)
{
mid=(low+high)/2;
if(key==l.elem[mid]) return mid; //找到待查元素
else if(key<l.elem[mid]) high=mid-1;
// Key<l.elem[mid],继续在前半区间进行查找
else low=mid+1; //Key>l.elem[mid],继续在后半区间进行查找}
return 0; //顺序表中不存在待查元素
}
main()
{
int m,n,v;
Sqlist l;
initlist_sq(l);
amount(l);
order(l);
output(l);
loop1:printf("请输入要查找的元素:");
scanf("%d",&m);
printf("\n");
n=Search_Bin(l,m);
if(n==0)
{
printf("数组中没有此元素!");
printf("\n");
printf("是否继续??(输入1继续/输入0结束)");
scanf("%d",&v);
if(v==0) return 0;
else if(v==1) goto loop1;
}
else
{
printf("数组中找到此元素!");
printf("\n");
printf("是否继续??(输入1继续/输入0结束)");
scanf("%d",&v);
if(v==0) return 0;
else if(v==1) goto loop1;
}
}
●运行测试结果:
●实验中所遇的问题及解决方法:
①、实验过程中会遇到在查找数组的头元素或者尾元素时,程序显示数组中没有此元素。
原因:在放置数组元素时,使用了0号单元,但经过验算,发现使用0号单元时会出现边界值的bug,导致程序出现异常。
在放弃使用0号单元后,程序能正常使用。