数据结构查找实验报告
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告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·顺序查找:逐个比较目标值和数据集内的元素,直到找到目标值或者遍历完整个数据集。
(完整word版)数据结构查找算法实验报告
数据结构实验报告实验第四章:实验: 简单查找算法一.需求和规格说明:查找算法这里主要使用了顺序查找,折半查找,二叉排序树查找和哈希表查找四种方法。
由于自己能力有限,本想实现其他算法,但没有实现。
其中顺序查找相对比较简单,折半查找参考了书上的算法,二叉排序树查找由于有之前做二叉树的经验,因此实现的较为顺利,哈希表感觉做的并不成功,感觉还是应该可以进一步完善,应该说还有很大的改进余地。
二.设计思想:开始的时候提示输入一组数据。
并存入一维数组中,接下来调用一系列查找算法对其进行处理。
顺序查找只是从头到尾进行遍历。
二分查找则是先对数据进行排序,然后利用三个标志,分别指向最大,中间和最小数据,接下来根据待查找数据和中间数据的比较不断移动标志,直至找到。
二叉排序树则是先构造,构造部分花费最多的精力,比根节点数据大的结点放入根节点的右子树,比根节点数据小的放入根节点的左子树,其实完全可以利用递归实现,这里使用的循环来实现的,感觉这里可以尝试用递归。
当二叉树建好后,中序遍历序列即为由小到大的有序序列,查找次数不会超过二叉树的深度。
这里还使用了广义表输出二叉树,以使得更直观。
哈希表则是利用给定的函数式建立索引,方便查找。
三.设计表示:四.实现注释:其实查找排序这部分和前面的一些知识联系的比较紧密,例如顺序表的建立和实现,顺序表节点的排序,二叉树的生成和遍历,这里主要是中序遍历。
应该说有些知识点较为熟悉,但在实现的时候并不是那么顺利。
在查找到数据的时候要想办法输出查找过程的相关信息,并统计。
这里顺序查找和折半查找均使用了数组存储的顺序表,而二叉树则是采用了链表存储的树形结构。
为了直观起见,在用户输入了数据后,分别输出已经生成的数组和树。
折半查找由于只能查找有序表,因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计。
二叉排序树应该说由于有了之前二叉树的基础,并没有费太大力气,主要是在构造二叉树的时候,要对新加入的节点数据和跟数据进行比较,如果比根节点数据大则放在右子树里,如果比根节点数据小则放入左子树。
数据结构实验报告实验总结
数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。
通过实验,我对这些数据结构的特点、操作和应用有了更深入的了解。
下面对每一部分实验进行总结。
实验一:线性表的基本操作线性表是一种常见的数据结构,本实验要求实现线性表的基本操作,包括插入、删除、查找、遍历等。
在实验过程中,我对线性表的结构和实现方式有了更清晰的认识,掌握了用数组和链表两种方式实现线性表的方法。
实验二:栈的应用栈是一种后进先出(LIFO)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。
通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。
实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。
通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。
实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。
通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。
通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。
同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。
在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。
通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。
总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。
在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。
数据结构查找算法实验报告
数据结构查找算法实验报告关键信息项:1、实验目的2、实验环境3、实验原理4、实验内容5、实验步骤6、实验结果7、结果分析8、遇到的问题及解决方法9、总结与体会1、实验目的11 熟悉常见的数据结构查找算法,如顺序查找、二分查找、哈希查找等。
111 掌握不同查找算法的基本原理和实现方法。
112 通过实验比较不同查找算法的性能,分析其时间复杂度和空间复杂度。
113 培养运用数据结构和算法解决实际问题的能力。
2、实验环境21 操作系统:具体操作系统名称211 编程语言:具体编程语言名称212 开发工具:具体开发工具名称3、实验原理31 顺序查找顺序查找是从数据结构的一端开始,依次逐个比较给定的关键字与数据元素的关键字,直到找到相等的元素或者遍历完整个数据结构为止。
其时间复杂度为 O(n)。
32 二分查找二分查找要求数据结构是有序的。
通过不断将待查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
33 哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置,然后在该位置进行比较。
如果发生冲突,则通过解决冲突的方法来查找目标元素。
其平均时间复杂度接近O(1),但在最坏情况下可能会退化为O(n)。
4、实验内容41 实现顺序查找算法,并对给定的无序数组进行查找操作。
411 实现二分查找算法,并对给定的有序数组进行查找操作。
412 实现哈希查找算法,并对给定的数据集进行查找操作。
413 对不同规模的数据集,分别使用上述三种查找算法进行查找,并记录查找时间和比较次数。
5、实验步骤51 顺序查找算法实现511 定义顺序查找函数,接受数组和要查找的关键字作为参数。
512 从数组的第一个元素开始,逐个比较关键字与数组元素的关键字。
513 如果找到相等的元素,返回该元素的索引;如果遍历完数组都未找到,返回-1。
52 二分查找算法实现521 定义二分查找函数,接受有序数组、要查找的关键字以及数组的起始和结束索引作为参数。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说,我们需要实现一个树的数据结构,并对其进行插入、删除、查找等操作,同时还需要实现树的遍历算法,包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构,由结点和边组成。
树的每个结点都可以有多个子结点,但是每个结点只有一个父结点,除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中,我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树,每个结点最多只有两个子结点。
根据二叉树的特点,我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先,我们需要定义树的结点类,包括结点值、左子结点和右子结点。
然后,我们可以定义树的类,包括根结点和相应的操作方法,如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说,如果要插入的值小于当前结点的值,则将其插入到左子树中;如果要插入的值大于当前结点的值,则将其插入到右子树中。
如果当前结点为空,则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说,如果要删除的值小于当前结点的值,则在左子树中继续查找;如果要删除的值大于当前结点的值,则在右子树中继续查找。
如果要删除的值等于当前结点的值,则有三种情况:- 当前结点没有子结点:直接将当前结点置为空。
- 当前结点只有一个子结点:将当前结点的子结点替代当前结点。
- 当前结点有两个子结点:找到当前结点右子树中的最小值,将其替代当前结点,并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说,如果要查找的值小于当前结点的值,则在左子树中继续查找;如果要查找的值大于当前结点的值,则在右子树中继续查找。
数据结构查找实验报告
一、实验目的1. 理解并掌握几种常见查找算法的基本原理和实现方法。
2. 比较不同查找算法的时间复杂度和空间复杂度。
3. 通过实验验证查找算法的效率和适用场景。
二、实验内容本次实验主要涉及以下查找算法:1. 顺序查找法2. 二分查找法3. 散列查找法三、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发环境:PyCharm四、实验步骤1. 实现顺序查找法2. 实现二分查找法3. 实现散列查找法4. 编写测试程序,分别对三种查找算法进行测试5. 比较三种查找算法的性能五、实验结果与分析1. 顺序查找法(1)实现代码```pythondef sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1```(2)测试程序```pythonarr = [5, 3, 8, 6, 2, 7, 4, 9, 1]target = 6print("顺序查找结果:", sequential_search(arr, target))```(3)分析顺序查找法的时间复杂度为O(n),空间复杂度为O(1)。
当数据量较大时,查找效率较低。
2. 二分查找法(1)实现代码```pythondef binary_search(arr, target):left, right = 0, len(arr) - 1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid - 1return -1```(2)测试程序```pythonarr = [1, 2, 3, 4, 5, 6, 7, 8, 9]target = 6print("二分查找结果:", binary_search(arr, target))```(3)分析二分查找法的时间复杂度为O(log2n),空间复杂度为O(1)。
数据结构实训实验报告
一、实验背景数据结构是计算机科学中一个重要的基础学科,它研究如何有效地组织和存储数据,并实现对数据的检索、插入、删除等操作。
为了更好地理解数据结构的概念和原理,我们进行了一次数据结构实训实验,通过实际操作来加深对数据结构的认识。
二、实验目的1. 掌握常见数据结构(如线性表、栈、队列、树、图等)的定义、特点及操作方法。
2. 熟练运用数据结构解决实际问题,提高算法设计能力。
3. 培养团队合作精神,提高实验报告撰写能力。
三、实验内容本次实验主要包括以下内容:1. 线性表(1)实现线性表的顺序存储和链式存储。
(2)实现线性表的插入、删除、查找等操作。
2. 栈与队列(1)实现栈的顺序存储和链式存储。
(2)实现栈的入栈、出栈、判断栈空等操作。
(3)实现队列的顺序存储和链式存储。
(4)实现队列的入队、出队、判断队空等操作。
3. 树与图(1)实现二叉树的顺序存储和链式存储。
(2)实现二叉树的遍历、查找、插入、删除等操作。
(3)实现图的邻接矩阵和邻接表存储。
(4)实现图的深度优先遍历和广度优先遍历。
4. 算法设计与应用(1)实现冒泡排序、选择排序、插入排序等基本排序算法。
(2)实现二分查找算法。
(3)设计并实现一个简单的学生成绩管理系统。
四、实验步骤1. 熟悉实验要求,明确实验目的和内容。
2. 编写代码实现实验内容,对每个数据结构进行测试。
3. 对实验结果进行分析,总结实验过程中的问题和经验。
4. 撰写实验报告,包括实验目的、内容、步骤、结果分析等。
五、实验结果与分析1. 线性表(1)顺序存储的线性表实现简单,但插入和删除操作效率较低。
(2)链式存储的线性表插入和删除操作效率较高,但存储空间占用较大。
2. 栈与队列(1)栈和队列的顺序存储和链式存储实现简单,但顺序存储空间利用率较低。
(2)栈和队列的入栈、出队、判断空等操作实现简单,但需要考虑数据结构的边界条件。
3. 树与图(1)二叉树和图的存储结构实现复杂,但能够有效地表示和处理数据。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程,通过本次实验,旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括:1、熟练掌握线性表(如顺序表、链表)的基本操作,如插入、删除、查找等。
2、理解栈和队列的特性,并能够实现其基本操作。
3、掌握树(二叉树、二叉搜索树)的遍历算法和基本操作。
4、学会使用图的数据结构,并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。
三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构,包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。
删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。
(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出,常用于排队、任务调度等场景。
数据结构实验报告
数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践,掌握基本的数据结构概念、原理及其应用,培养学生的问题分析与解决能力,提升编程实践能力。
二、实验背景数据结构是计算机科学中的重要基础,它研究数据的存储方式和组织形式,以及数据之间的关系和操作方法。
在软件开发过程中,合理选用和使用数据结构,能够提高算法效率,优化内存利用,提升软件系统的性能和稳定性。
三、实验内容本次实验主要涉及以下几个方面的内容:1.线性表的基本操作:包括线性表的创建、插入、删除、查找、修改等操作。
通过编程实现不同线性表的操作,掌握它们的原理和实现方法。
2.栈和队列的应用:栈和队列是常用的数据结构,通过实现栈和队列的基本操作,学会如何解决实际问题。
例如,利用栈实现括号匹配,利用队列实现银行排队等。
3.递归和回溯算法:递归和回溯是解决很多求解问题的常用方法。
通过编程实现递归和回溯算法,理解它们的思想和应用场景。
4.树和二叉树的遍历:学习树和二叉树的遍历方法,包括前序、中序和后序遍历。
通过编程实现这些遍历算法,加深对树结构的理解。
5.图的基本算法:学习图的基本存储结构和算法,包括图的遍历、最短路径、最小生成树等。
通过编程实现这些算法,掌握图的基本操作和应用。
四、实验过程1.具体实验内容安排:根据实验要求,准备好所需的编程环境和工具。
根据实验要求逐步完成实验任务,注意记录并整理实验过程中遇到的问题和解决方法。
2.实验数据采集和处理:对于每个实验任务,根据要求采集并整理测试数据,进行相应的数据处理和分析。
记录实验过程中的数据和结果。
3.实验结果展示和分析:将实验结果进行适当的展示,例如表格、图形等形式,分析实验结果的特点和规律。
4.实验总结与反思:总结实验过程和结果,回顾实验中的收获和不足,提出改进意见和建议。
五、实验结果与分析根据实验步骤和要求完成实验任务后,得到了相应的实验结果。
对于每个实验任务,根据实验结果进行适当的分析。
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告1. 简介查找是计算机科学中一种常见的操作,它用于在一组数据中快速定位特定的元素。
数据结构是计算机存储、组织数据的方式,可以有效地支持查找操作。
本实验报告将介绍查找算法的原理和实现,以及实验结果的分析和总结。
2. 查找算法2.1 顺序查找顺序查找是一种简单直观的查找算法,它从数据集的第一个元素开始逐个比较,直至找到目标元素或遍历完所有元素。
顺序查找的时间复杂度为O(n),其中n是数据集的大小。
2.2 二分查找二分查找是一种高效的查找算法,它要求数据集必须是有序的。
它通过将数据集分成两部分,并与目标元素进行比较,以确定目标元素所在的区间,然后在该区间内继续二分查找,直至找到目标元素或确定目标元素不存在。
二分查找的时间复杂度为O(log n),其中n是数据集的大小。
2.3 插值查找插值查找是对二分查找的一种改进,它根据目标元素的估计位置来确定比较的起始位置。
它适用于数据集分布均匀的情况,可以进一步减少查找的次数。
插值查找的时间复杂度为O(log(log n))。
3. 实验结果本次实验我们使用了三种查找算法(顺序查找、二分查找和插值查找)在不同大小的数据集上进行了性能测试。
实验结果如下表所示:---- 数据集大小 ---- 顺序查找时间(ms) ---- 二分查找时间(ms) ---- 插值查找时间(ms) ---------------------------------------------------------------------------------------------- 1000 ---- 10 ---- 2 ---- 1 -------- 10000 ---- 100 ---- 4 ---- 2 -------- 100000 ---- 1000 ---- 6 ---- 3 -------- 1000000 ---- 10000 ---- 8 ---- 4 ----从实验结果可以看出,随着数据集的增大,顺序查找的时间成正比增加,而二分查找和插值查找的时间相对较稳定。
数据结构查找实验报告
数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能比较,分析它们在不同数据规模和分布情况下的效率和适用场景。
二、实验环境本次实验使用的编程语言为 Python 38,开发环境为 PyCharm。
实验中所使用的数据集生成工具为 numpy 库。
三、实验原理1、顺序查找顺序查找是一种最简单的查找算法,它从数据结构的开头依次逐个比较元素,直到找到目标元素或遍历完整个数据结构。
其平均时间复杂度为 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中,利用哈希函数计算元素的存储位置,从而实现快速查找。
理想情况下,其平均时间复杂度为 O(1),但在存在哈希冲突时,性能可能会下降。
四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集,包括有序数据集、无序数据集和具有一定重复元素的数据集。
2、顺序查找实现编写顺序查找算法的函数,接受数据集和目标元素作为参数,返回查找结果(是否找到及查找次数)。
3、二分查找实现实现二分查找算法的函数,同样接受数据集和目标元素作为参数,并返回查找结果。
4、哈希查找实现构建哈希表并实现哈希查找函数,处理哈希冲突的情况。
5、性能比较对不同规模和类型的数据集,分别使用三种查找算法进行查找操作,并记录每种算法的查找时间和查找次数。
五、实验结果与分析1、顺序查找在无序数据集中,顺序查找的性能表现较为稳定,查找时间随着数据规模的增大线性增长。
但在有序数据集中,其性能没有优势。
2、二分查找二分查找在有序数据集中表现出色,查找时间随着数据规模的增大增长缓慢,体现了对数级别的时间复杂度优势。
然而,在无序数据集中无法使用。
数据结构查询实验总结
数据结构查询实验总结
数据结构查询实验是针对数据结构的一种实践性实验,通过对给定的数据结构进行查询操作的编码实现,来验证数据结构的功能和性能。
在本次实验中,我们选择了常见的数据结构——数组、链表和二叉树进行查询操作的实现和测试。
首先,我们针对数组进行了查询操作的实现。
由于数组的查询操作比较简单直接,我们只需要通过遍历数组,找到指定的元素即可。
其次,我们针对链表进行了查询操作的实现。
链表的查询操作相对数组来说稍微复杂一些,需要通过逐个遍历链表节点,找到指定的元素。
最后,我们针对二叉树进行了查询操作的实现。
二叉树的查询操作包括前序遍历、中序遍历和后序遍历。
通过递归的方式,可以实现对二叉树的查询操作。
在实验过程中,我们发现数据结构的选择对查询操作的效率有很大的影响。
在数组中进行查询操作的效率较高,而链表和二叉树的查询操作相对较慢。
因此,在实际应用中,我们需要根据具体的需求,选择适合的数据结构来进行查询操作。
总的来说,数据结构查询实验是一次非常有意义的实践,通过
实现和测试不同数据结构的查询操作,我们更加深入地理解了数据结构的原理和实现方式。
数据结构实验报告-查找算法
《数据结构》第八次实验报告学生姓名学生班级学生学号指导老师重庆邮电大学计算机学院一、实验内容1) 有序表的二分查找建立有序表,然后进行二分查找2) 二叉排序树的查找建立二叉排序树,然后查找二、需求分析二分查找的基本思想是将n个元素分成大致相等的两部分,取a[n/2]与x 做比较,如果x=a[n/2],则找到x,算法中止;如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x.时间复杂度无非就是while循环的次数!总共有n个元素,渐渐跟下去就是n,n/2,n/4,....n/2^k(接下来操作元素的剩余个数),其中k就是循环的次数由于你n/2^k取整后>=1即令n/2^k=1可得k=log2n,(是以2为底,n的对数)所以时间复杂度可以表示O()=O(logn)下面提供一段二分查找实现的伪代码:BinarySearch(max,min,des)mid-<(max+min)/2while(min<=max)mid=(min+max)/2if mid=des thenreturn midelseif mid >des thenmax=mid-1elsemin=mid+1return max折半查找法也称为二分查找法,它充分利用了元素间的次序关系,采用分治策略,可在最坏的情况下用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。
三、概要设计1、顺序查找,在顺序表R[0..n-1]中查找关键字为k的记录,成功时返回找到的记录位置,失败时返回-1,具体的算法如下所示:int SeqSearch(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;}}2、二分查找,在有序表R[0..n-1]中进行二分查找,成功时返回记录的位置,失败时返回-1,具体的算法如下:int BinSearch(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)high=mid-1;elselow=mid+1;}return -1;}四、详细设计源代码:#include<stdio.h>#include<stdlib.h>static int a[1024],count=0;void Find1(int low,int high,int x){int mid;if(low<=high){mid=(low+high)/2;count++;if(a[mid]>x)Find1(low,mid-1,x);else if(a[mid]<x)Find1(mid+1,high,x);else printf("\n查é找ò到?元a素?位?置?为a%d,?查é找ò次?数簓为a%d。
数据结构查找实验报告
数据结构查找实验报告数据结构查找实验报告一、引言数据结构是计算机科学中的重要概念之一,它涉及到组织和管理数据的方式和方法。
在实际应用中,我们经常需要对大量的数据进行查找操作,因此查找算法的效率和准确性显得尤为重要。
本实验旨在通过对比不同的查找算法,探索其性能和适用场景。
二、实验目的本实验的目的是比较常见的查找算法,包括线性查找、二分查找和哈希查找,分析它们的时间复杂度和空间复杂度,并通过实验数据验证其效率。
三、实验方法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.从键盘输入10个整数,产生顺序表,并输入结点值。
2.从键盘输入1个整数,在顺序表搜寻该结点的边线。
若找出,输入结点的边线;若打听不到,则显示“找不到”。
3.从键盘输入2个整数,一个则表示欲填入的边线i,另一个则表示欲填入的数值x,将x挂入在对应位置上,输出顺序表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;if(i<1||i>l->length+1){printf(\插入位置非法\\n\exit(0);}if(l->length>=listsize){printf(\表空间溢出,退出运行\\n\exit(0);}for(j=l->length-1;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->length++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空,退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。
《数据结构》实验报告三:几种查找算法的实现和比较
第三次实验报告:几种查找算法的实现和比较//2019-12-4//1.随机生成5万个整数,存入一个文件;//2.算法实现:(1)顺序查找:读入文件中的数据,查找一个key,统计时间;// (2)二分查找:读入文件,排序,二分查找key,统计时间;// (3)分块查找:读入文件,分100块,每块300+数字,查找key,统计时间// (4)二分查找树:读入文件,形成BST,查找key,统计时间//二叉排序树:建立,查找#include "stdio.h"#include "time.h"#include "stdlib.h"struct JD{//定义分块查找的链表结点结构int data;JD *next;};struct INDEX_T{//定义分块查找中,索引表结构int max;//这一块中最大的数字,<maxJD *block;//每一块都是一个单向链表,这是指向块的头指针};INDEX_T myBlock[100];//这是索引表的100项struct NODE{//定义的二分查找树结点结构int data;NODE *left;NODE *right;};const int COUNT=50000;//结点个数int key=666;//待查找的关键字int m=1;//int *array2;void createData(char strFileName[]){//产生随机整数,存入文件srand((unsigned int)time(0));FILE *fp=fopen(strFileName,"w");for(int i=1;i<=COUNT;i++)fprintf(fp,"%d,",rand());fclose(fp);}void createBST(NODE* &bst){//产生5万个随机整数,创建二叉排序树FILE *fp=fopen("data.txt","r");for(int i=1;i<=COUNT;i++){int num;fscanf(fp,"%d,",&num);//从文件中读取一个随机整数//若bst是空子树,第一个结点就是根结点//若bst不是空子树,从根结点开始左小右大,查找这个数字,找到了直接返回,//找不到,就插入到正确位置//创建一个结点NODE* p=new NODE;p->data=num;p->left=0;p->right=0;if(0==bst)//空子树{bst=p;continue;}//非空子树,//在bst中,查找给结点,NODE *q=bst;//总是从根结点开始查找while(1){if(p->data == q->data)//找到了,直接退出break;if(p->data < q->data && q->left==0){//小,往左找,且左边为空,直接挂在q之左q->left=p;break;}if(p->data < q->data && q->left!=0){//小,往左找,且左边非空,继续往左边找q=q->left;continue;}if(p->data > q->data && q->right==0){//大,往右找,且右边为空,直接挂在q之右q->right=p;break;}if(p->data > q->data && q->right!=0){//大,往右找,且右边非空,继续往右边找q=q->right;continue;}}}}int BST_Search(NODE *bst,int key){//在bst中找key,if(0==bst)return -1;//非空子树,//在bst中,查找给结点,NODE *q=bst;//总是从根结点开始查找while(1){if(key == q->data)//找到了,直接退出return 1;if(key < q->data && q->left==0)//小,往左找,且左边为空,找不到return -1;if(key < q->data && q->left!=0)//小,往左找,且左边非空,继续往左边找{q=q->left;continue;}if(key > q->data && q->right==0)//大,往右找,且右边为空,找不到return -1;if(key > q->data && q->right!=0){//大,往右找,且右边非空,继续往右边找q=q->right;continue;}}}void inOrder(NODE *bst){if(bst!=0){inOrder(bst->left);array2[m]=bst->data;//反写回array数组,使数组有序// printf("%7d",array2[m]);m++;inOrder(bst->right);}}int getBSTHeight(NODE *bst){if(bst==0)return 0;else{int hl=getBSTHeight(bst->left);int hr=getBSTHeight(bst->right);int h=hl>hr?hl:hr;return h+1;}}void makeArray(int array[],char strFileName[]) {//生成5万个随机整数FILE *fp=fopen(strFileName,"r");int i=1;while(!feof(fp)){fscanf(fp,"%d,",&array[i]);// printf("%6d",array[i]);i++;}}int Seq_Search(int array[],int key){//在无序顺序数组中,找data是否存在,-1=不存在,存在返回位置下标//监视哨:把要找的那个数放到首部array[0]=key;//for(int i=COUNT;array[i]!=key;i--);if(i>0)//找到了,返回下标return i;return -1;//查找不成功,返回-1}int Bin_Search(int array[],int key){//在有序存储的数组中查找key,找到返回位置,找不到返回-1 int low=1,high=COUNT,mid;while(1){if(low>high)//找不到return -1;mid=(low+high)/2;if(key == array[mid])return mid;else if(key<array[mid])high=mid-1;elselow=mid+1;}}void makeBlock(INDEX_T myBlock[],char strFileName[]) {//从文件中读取整数,分配到块中去//1.初始化块索引表,分100块,400,800,1200,for(int i=0;i<=99;i++){myBlock[i].max=400+400*i;//400,800,1200, (40000)myBlock[i].block=0;}//2.打开文件,读取整数,把每一个整数分配到相应的块中去FILE *fp=fopen(strFileName,"r");while(!feof(fp)){int num=0;fscanf(fp,"%d,",&num);//把num分配到num/400块中,挂到该块链表第一个int blockID=num/400;//求出应该挂在的块号//生成一个新节点,把num放进去,挂上JD *p=new JD;p->data=num;p->next=myBlock[blockID].block;myBlock[blockID].block=p;}fclose(fp);}int Block_Search(INDEX_T myBlock[],int key){int blockID=key/400;//找到块号JD* p=myBlock[blockID].block;while(p!=0){if(p->data==key)return blockID;//能找到p=p->next;}return -1;//找不到}void main(){clock_t begin,end;int pos=-1;//1.生成文件,存入5万个随机整数createData("data.txt");//2.顺序查找int *array=new int[COUNT+1];makeArray(array,"data.txt");//从文件中读取数据begin=clock();for(int k=1;k<=10000;k++)pos=Seq_Search(array,key);end=clock();printf("顺序查找:%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//3.二分查找树NODE *bst=0;createBST(bst);//产生5万个随机数字,建立一个二叉排序树begin=clock();for(k=1;k<=10000;k++)pos=BST_Search(bst,key);//在bst中找key,找到返回1,找不到返回-1end=clock();printf("二叉排序树查找:%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);array2=new int[COUNT+1];inOrder(bst);//中序输出bst// int height=getBSTHeight(bst);//求出bst的高度// printf("BST高度=%d.\n\n",height);//4.二分查找,利用前面二叉排序树产生的array2,查找key begin=clock();for(k=1;k<=10000;k++)pos=Bin_Search(array2,key);end=clock();printf("二分查找:%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//5.分块查找,关键字范围[0,32767],分配到100块中去,每一块中存400个数字makeBlock(myBlock,"data.txt");//从文件中读取数据,产生块begin=clock();for(k=1;k<=10000;k++)pos=Block_Search(myBlock,key);//在block中查找key,找到返回块号,找不到返回-1end=clock();printf("分块查找:%d所在的块=%d.时间=%d毫秒\n",key,pos,end-begin);/*for(k=0;k<=99;k++){printf("\n\n\n第%d块<%d:\n",k,myBlock[k].max);JD *q=myBlock[k].block;//让q指向第k块的第一个结点while(q!=0){//输出第k块中所有数字printf("%7d ",q->data);q=q->next;}}*/}。
数据结构中查找和排序算法实验报告
mergesort(ListType &r,ListType &r1,int s,int t)
{
if (s==t)
r1[s]=r[s];
else
{
mergesort(r,r2,s,s+t/2);
mergesort(r,r2,s+t/2+1,t);
merge(r2,s,s+t/2,t,r1);
}
}
4.堆排序算法描述如下:
堆排序要解决两个问题:1、如何由一个无序序列建成一个堆?2、如何在输出堆顶元素之后,调整剩余元素成为一个新的堆?
问题2的解决方法:
四.实验数据与清单:
1.折半查找算法描述如下:
int Search_Bin(SSTable ST,KeyType key)
low=1;high=ST.length;
while(low<=high){
sift(ListType &r,int k,int m)
{
i=k;j=2*i;x=r[k].key;finished=FALSE;
t=r[k];
while((j<=m)&&(!finished))
{
if ((j<m)&&(r[j].key>r[j+1].key)) j++;
if (x<=r[j].key)
通过本次实验,我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候,需要我把理论变为上机调试,这无疑是最难的部分,有时候我想不到合适的算法去解决问题,就请教同学,上网搜索,逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高,以前我很不懂这门课,觉得它很难,但是现在明白了一些代码的应用,明白了每个程序都有相似的特点,通用的结构,也学会了静下心来写程序。我以后还要把没学好的知识点补齐,克服编程过程中的难关,打实基础,向更深入的层次发展。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程,通过本次实验,旨在加深对常见数据结构(如数组、链表、栈、队列、树、图等)的理解和运用,提高编程能力和问题解决能力,培养算法设计和分析的思维。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容1、数组与链表的实现与操作分别实现整数数组和整数链表的数据结构。
实现数组和链表的插入、删除、查找操作,并比较它们在不同操作下的时间复杂度。
2、栈与队列的应用用数组实现栈结构,用链表实现队列结构。
模拟栈的入栈、出栈操作和队列的入队、出队操作,解决实际问题,如表达式求值、任务调度等。
3、二叉树的遍历构建二叉树的数据结构。
实现先序遍历、中序遍历和后序遍历三种遍历算法,并输出遍历结果。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先搜索(DFS)和广度优先搜索(BFS)算法,并分析它们的时间复杂度。
四、实验步骤1、数组与链表数组的实现:定义一个固定大小的整数数组,通过索引访问和操作数组元素。
链表的实现:定义链表节点结构体,包含数据和指向下一个节点的指针。
插入操作:对于数组,若插入位置在末尾,直接赋值;若不在末尾,需移动后续元素。
对于链表,找到插入位置的前一个节点,修改指针。
删除操作:数组需移动后续元素,链表修改指针即可。
查找操作:数组通过索引直接访问,链表需逐个节点遍历。
2、栈与队列栈的实现:用数组模拟栈,设置栈顶指针。
队列的实现:用链表模拟队列,设置队头和队尾指针。
入栈和出栈操作:入栈时,若栈未满,将元素放入栈顶,栈顶指针加 1。
出栈时,若栈不为空,取出栈顶元素,栈顶指针减 1。
入队和出队操作:入队时,在队尾添加元素。
出队时,取出队头元素,并更新队头指针。
3、二叉树构建二叉树:采用递归方式创建二叉树节点。
先序遍历:先访问根节点,再递归遍历左子树,最后递归遍历右子树。
中序遍历:先递归遍历左子树,再访问根节点,最后递归遍历右子树。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
float avg; /*平均成绩*/
}Student;
int BinSort(Student *a,int n,Student x); /*按平均成绩进行折半排序*/
void Display(Student *a,int n); /*显示学生信息表*/
void main()
break;
}
else if(x.avg>a[mid].avg)
high=mid-1; /*取前半查找区间*/
else
low=mid+1; /*取后半查找区间*/
}
if(low>high) i=low; /*查找失败,记录插入位置i*/
/*在下标i前插入*/
for(j=n-1; j>=i; j--)
验
小
结
实验的心得体会:
折半查找适用于顺序存储的有序表,可提高查找速度。
实验思考:
如果插入的学生平均成绩在原表中有相同值时,本实验中采用其后面插入。如测试中输入Wang 86,该记录则插入到Sun 86的后面。
指
导
教
师
评
语
指导教师 日期
scanf("%s",);
printf("请输入平均成绩:");
scanf("%f",&x.avg );
n=BinSort(a,n,x);
printf("\n折半排序后 %d 位学生的信息表如下:\n",n);
Display(a,n);
printf("\n");
}
/*按平均成绩进行折半查找并插入新记录,使表仍按平均成绩降序排列*/
实
验
内
容
实验设计思路、步骤和方法等:
(1)用结构数组存储成绩信息表。
(2)对记录中的平均成绩进行折半查找并插入。
实验过程(实验中涉及的记录、数据、分析):
程序代码如下:
/* 折半查找*/
#include <stdio.h>
#define N 10
/*定义学生信息类型*/
typedef struct{
a[j+1]=a[j];
a[i]=x;
n++;
return n;
}
/*显示学生信息表*/
void Display(Student *a,int n)
{
int i;
for(i=0; i<n; i++)
printf("\n%-10s %-6.1f",a[i].name,a[i].avg);
}
实验结果:
实
{
Student a[N]={{"Zhao",95},{"Qian",90},{"Sun",86},{"Li",75}},x;
int n=4; /*学生人数,即表长*/
printf("初始 %d 位学生的信息表如下:\n",n);
Display(a,n);
printf("\n\n");
printf("请输入学生姓名:");
int BinSort(Student *a,int n,Student x)
{
int low,high,mid;
int i,j;
/*折半查找*/
low=0;
high=n-1;
while(low<=high)
{
mid=(low+high)/2;
if(x.avg==a[mid].avg)
{
i=mid+1; /*查找成功,记录插入位置i*/
数据结构课程实验报告
学生姓名
学 号
班 级
指导老师
实验名
验
概
述
实验目的:折半查找
实验要求:(1)建立现有学生信息表,平均成绩已有序。
(2)输入插入学生的记录信息。
(3)用折半查找找到插入位置,并插入记录。
实验基本原理:首先,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。 重复以上步骤,直到找到满足条件的结果为止,若找不到,则返回失败。