查找和排序算法的实现(实验七)

合集下载

查找与排序算法方案

查找与排序算法方案

2.2 折半查找
如果从文件中读取的数据记录的关键字是有序排列的, 则可以用一种效率更高的查找方法来查找文件中的记录,这 就是折半查找法,又称为二分搜索。
折半查找的基本思想是:减小查找序列的长度,分而治 之地进行关键字的查找。它的查找过程是:先确定待查找记 录的所在的范围,然后逐渐缩小查找的范围,直至找到该记 录为止(也可能查找失败)。
2.1 顺序查找
如果一个文件具有n个连续的记录,可将该文件读到内 存中的一个顺序表中进行各种操作。顺序查找就是在文件的 关键字集合key[1,2,...,n]中找出与给定的关键字key相等的文 件记录。如图2-2所示,磁盘中有这样一个顺序文件。对文 件中记录的查找就是对其关键字的查找,找到了关键字就找 到了该关键字对应的那条记录。
直接插入排序的基本思想是:第i趟排序将序列中的第 i+1个元素ki&) 中的合适的位置,使得插入后的序列仍然保持按值有序。
2.5 选择排序
选择排序(selection sort)也是一种比较常见的排序方法。它 的基本思想是:第i趟排序从序列的后n-i+1(i=1,2,…,n-1)个元 素中选择一个最小的元素,与该n-i+1个元素的最前面那个元素 进行位置交换,也就是与第i个位置上的元素进行交换,直到 i=n-1。直观地讲,每一趟的选择排序就是从序列中未排好顺序 的元素中选择一个最小的元素,将该元素与这些未排好顺序的 元素的第一个元素交换位置。
2.3 排序的概述
对于文件而言,排序可以理解为:根据文件记录的关键 字的值的递增或者递减关系将文件的记录的次序进行重新排 列的过程。排序后的文件记录一定是按关键字值有序排列的 。例如最开始从磁盘中读出的文件如图2-5所示。
2.4 直接插入排序

数据结构中查找和排序算法实验报告

数据结构中查找和排序算法实验报告
ST.elme[0].key=key;
for(i=ST.length; !EQ(ST.elem[i].key,key); --i);
return i;
}
3.归并排序算法描述如下:
merge(ListType r,int l,int m,int n,ListType &r2)
{
i=l;j=m+1;k=l-1;
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)
将两个或两个以上的有序表组合成一个新的有序表的方法叫归并。
假设初始序列含有n个记录,则可看成是n个有序的子序列,每个子序列的长度为1,然后两两归并,得到n/2个长度为2或1的有序子序列;再两两归并,如此重复。
4.堆排序分析:
只需要一个记录大小的辅助空间,每个待排序的记录仅占有一个存储空间。
什么是堆?n个元素的序列{k1,k2,...,kn}当且仅当满足下列关系时,称之为堆。关系一:ki<=k2i关系二:ki<=k2i+1(i=1,2,...,n/2)
静态查找表的顺序存储结构:
typedef struct {ElemType *e源自em;int length;
}SSTable;
顺序查找:从表中最后一个记录开始,逐个进行记录的关键字和给定值的比较,若某个记录的关键字和给定值比较相等,则查找成功,找到所查记录;反之,查找不成功。

查找排序实验报告

查找排序实验报告

查找排序实验报告一、实验目的本次实验的主要目的是深入理解和比较不同的查找和排序算法在性能和效率方面的差异。

通过实际编程实现和测试,掌握常见查找排序算法的原理和应用场景,为今后在实际编程中能够选择合适的算法解决问题提供实践经验。

二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。

计算机配置为:处理器_____,内存_____,操作系统_____。

三、实验内容1、查找算法顺序查找二分查找2、排序算法冒泡排序插入排序选择排序快速排序四、算法原理1、顺序查找顺序查找是一种最简单的查找算法。

它从数组的一端开始,依次比较每个元素,直到找到目标元素或者遍历完整个数组。

其时间复杂度为 O(n),在最坏情况下需要遍历整个数组。

2、二分查找二分查找适用于已排序的数组。

它通过不断将数组中间的元素与目标元素进行比较,将查找范围缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。

其时间复杂度为 O(log n),效率较高。

3、冒泡排序冒泡排序通过反复比较相邻的两个元素并交换它们的位置,将最大的元素逐步“浮”到数组的末尾。

每次遍历都能确定一个最大的元素,经过 n-1 次遍历完成排序。

其时间复杂度为 O(n^2)。

4、插入排序插入排序将数组分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的合适位置。

其时间复杂度在最坏情况下为 O(n^2),但在接近有序的情况下性能较好。

5、选择排序选择排序每次从待排序数组中选择最小的元素,与当前位置的元素交换。

经过 n-1 次选择完成排序。

其时间复杂度为 O(n^2)。

6、快速排序快速排序采用分治的思想,选择一个基准元素,将数组分为小于基准和大于基准两部分,然后对这两部分分别递归排序。

其平均时间复杂度为 O(n log n),在大多数情况下性能优异。

五、实验步骤1、算法实现使用Python 语言实现上述六种查找排序算法,并分别封装成函数,以便后续调用和测试。

c程序实验报告

c程序实验报告

c程序实验报告C程序实验报告引言在计算机科学领域中,C语言是一种被广泛使用的编程语言,它具有高效、灵活和可移植等特点。

为了更好地掌握C语言的基本概念和编程技巧,我们进行了一系列的C程序实验。

本实验报告将对实验过程、实验结果和实验心得进行详细描述和分析。

实验一:Hello World在第一个实验中,我们编写了一个简单的C程序,输出了"Hello World"这个经典的字符串。

通过这个实验,我们熟悉了C语言的基本语法和编译运行的流程。

这个简单的程序为我们后续的实验打下了坚实的基础。

实验二:计算器在第二个实验中,我们设计了一个简单的计算器程序。

该程序可以进行基本的加、减、乘、除运算,并能够根据用户的输入进行相应的计算。

通过这个实验,我们学会了如何使用变量、运算符和控制语句来实现简单的计算功能。

同时,我们也了解了C语言中的数据类型和输入输出函数的使用。

实验三:学生成绩管理系统在第三个实验中,我们开发了一个学生成绩管理系统。

该系统可以实现学生信息的录入、查询和统计功能。

我们使用了结构体和数组来存储学生信息,并通过循环和条件语句实现了不同功能的选择。

这个实验让我们更深入地了解了C语言中的复合数据类型和数组的使用。

实验四:文件操作在第四个实验中,我们学习了C语言中的文件操作。

我们通过编写一个简单的文件管理系统,实现了文件的创建、读取、写入和删除等功能。

通过这个实验,我们掌握了C语言中文件操作函数的使用方法,并了解了文件的打开和关闭过程。

实验五:排序算法在第五个实验中,我们研究了几种常见的排序算法,包括冒泡排序、插入排序和快速排序。

我们通过编写这些排序算法的C程序,对它们的原理和实现进行了深入的分析。

这个实验让我们更加熟悉了C语言中的循环和条件语句,并提高了我们的编程能力。

实验六:链表在第六个实验中,我们学习了链表这种常见的数据结构。

我们编写了一个简单的链表程序,实现了链表的创建、插入和删除等操作。

查找排序操作实验报告

查找排序操作实验报告

一、实验目的1. 熟悉常用的查找和排序算法,掌握它们的原理和实现方法。

2. 提高编程能力,提高算法分析能力。

3. 通过实验验证查找和排序算法的性能。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm三、实验内容1. 查找算法:二分查找、线性查找2. 排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序四、实验步骤1. 设计一个数据结构,用于存储待查找和排序的数据。

2. 实现二分查找算法,用于查找特定元素。

3. 实现线性查找算法,用于查找特定元素。

4. 实现冒泡排序、选择排序、插入排序、快速排序、归并排序算法,对数据进行排序。

5. 分别测试查找和排序算法的性能,记录时间消耗。

五、实验结果与分析1. 查找算法(1)二分查找算法输入数据:[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]查找目标:11查找结果:成功,位置为5(2)线性查找算法输入数据:[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]查找目标:11查找结果:成功,位置为52. 排序算法(1)冒泡排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](2)选择排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](3)插入排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](4)快速排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](5)归并排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8]3. 性能测试(1)查找算法性能测试二分查找算法在数据量较大的情况下,查找效率明显优于线性查找算法。

(2)排序算法性能测试在数据量较大的情况下,快速排序和归并排序的性能明显优于冒泡排序、选择排序和插入排序。

排序和查找的实验报告

排序和查找的实验报告

排序和查找的实验报告实验报告:排序和查找引言排序和查找是计算机科学中非常重要的基本算法。

排序算法用于将一组数据按照一定的顺序排列,而查找算法则用于在已排序的数据中寻找特定的元素。

本实验旨在比较不同排序和查找算法的性能,并分析它们的优缺点。

实验设计为了比较不同排序算法的性能,我们选择了常见的几种排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。

我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。

在查找算法的比较实验中,我们选择了顺序查找和二分查找两种常见的算法。

同样地,我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。

实验结果在排序算法的比较实验中,我们发现快速排序和归并排序在大多数情况下表现最好,它们的平均执行时间和空间占用都要优于其他排序算法。

而冒泡排序和插入排序则表现较差,它们的执行时间和空间占用相对较高。

在查找算法的比较实验中,二分查找明显优于顺序查找,尤其是在数据规模较大时。

二分查找的平均执行时间远远小于顺序查找,并且占用的空间也更少。

结论通过本实验的比较,我们得出了一些结论。

首先,快速排序和归并排序是较优的排序算法,可以在大多数情况下获得较好的性能。

其次,二分查找是一种高效的查找算法,特别适用于已排序的数据集。

最后,我们也发现了一些排序和查找算法的局限性,比如冒泡排序和插入排序在大数据规模下性能较差。

总的来说,本实验为我们提供了对排序和查找算法性能的深入了解,同时也为我们在实际应用中选择合适的算法提供了一定的参考。

希望我们的实验结果能够对相关领域的研究和应用有所帮助。

数据结构实验报告七_顺序查找

数据结构实验报告七_顺序查找

实验七顺序查找一、实验目的1.掌握顺序查找操作的算法实现。

二、实验平台操作系统:Windows7或Windows XP开发环境:JA V A三、实验内容及要求1.建立顺序查找表,并在此查找表上实现顺序查找操作。

四、实验的软硬件环境要求硬件环境要求:PC机(单机)使用的软件名称、版本号以及模块:Netbeans 6.5以上或Eclipse、MyEclipse等编程环境下。

五、知识准备前期要求掌握查找的含义和顺序查找操作的方法。

六、验证性实验1.实验要求编程实现如下功能:(1)根据输入的查找表的表长n和n个关键字值,建立顺序查找表,并在此查找表中用顺序查找方法查找给定关键值的记录,最后输出查找结果。

2. 实验相关原理:查找表分别静态查找表和动态查找表两种,其中只能做引用操作的查找表称为静态查找表。

静态查找表采用顺序存储结构,待查找的记录类可描述如下:public class RecordNode {private Comparable key; //关键字private Object element; //数据元素……}待排序的顺序表类描述如下:public class SeqList {private RecordNode[] r; //顺序表记录结点数组private int curlen; //顺序表长度,即记录个数// 顺序表的构造方法,构造一个存储空间容量为maxSize的顺序表public SeqList(int maxSize) {this.r = new RecordNode[maxSize]; // 为顺序表分配maxSize个存储单元this.curlen = 0; // 置顺序表的当前长度为0}……}【核心算法提示】查找操作是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素或记录的过程。

若查找表中存在这样一个记录,则称“查找成功”。

查找结果给出整个记录的信息,或指示该记录在查找表中的位置;若在查找表中不存在这样的记录,则称“查找不成功”。

查找和排序算法的实现 (实验七)

查找和排序算法的实现 (实验七)

实验七查找和排序算法的实现一.实验目的及要求(1)学生在实验中体会各种查找和部排序算法的基本思想、适用场合,理解开发高效算法的可能性和寻找、构造高效算法的方法。

(2)掌握运用查找和排序解决一些实际应用问题。

二.实验容:(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等),并计算相应的ASL。

(2)编程实现一种部排序算法(如插入排序、快速排序等)。

三.实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写,请另加附页)(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等),并计算相应的ASL。

➢程序代码:折半查找:头文件:#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))#define maxlength 20typedef int ElemType;typedef struct{ElemType key;ElemType other;}card;//每条记录包含的数据项typedef struct{card r[maxlength];int length;}SSTable;//一表中包含的记录容量void Create(SSTable &L);int Search(SSTable L,int elem);功能函数:#include"1.h"#include"stdio.h"void Create(SSTable &L){printf("新的线性表已经创建,请确定元素个数(不超过20)\n");scanf("%d",&L.length);printf("请按递增序列输入具体的相应个数的整数元素(空格隔开)\n");for(int i=0;i<L.length;i++){scanf("%d",&L.r[i].key);}}int Search(SSTable L,int elem){if(L.r[L.length-1].key<elem||L.r[0].key>elem){printf("表中没有该元素(不在围)\n");return 0;}int low=0,high=L.length-1;int mid;while(low<=high){mid=(low+high)/2;if(EQ(L.r[mid].key,elem)){printf("该元素在第%d位\n",mid+1); return 0;}else if(LT(elem,L.r[mid].key)){high=mid-1;}else{low=mid+1;}}printf("表中没有该元素(不在围)\n");return 0;}主函数:#include"stdio.h"#include"1.h"int main(){SSTable L;Create(L);printf("\n");printf("此时的线性表元素:\n");for(int a=0;a<L.length;a++){printf("%d ",L.r[a].key);}printf("\n");printf("\n");int elem;do{printf("请输入要查找的元素(输入000表示结束程序)\n");scanf("%d",&elem);if(elem!=000){Search(L,elem);}}while(elem!=000);return 0;}➢运行结果:(2)编程实现一种部排序算法(如插入排序、快速排序等)。

查找、排序的应用 实验报告

查找、排序的应用 实验报告

实验七查找、排序的应用一、实验目的1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。

2、学会比较各种排序与查找算法的优劣。

3、学会针对所给问题选用最适合的算法。

4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。

二、实验内容[问题描述]对学生的基本信息进行管理。

[基本要求]设计一个学生信息管理系统,学生对象至少要包含:学号、姓名、性别、成绩1、成绩2、总成绩等信息。

要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息(要求至少用两种查找算法实现);3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序(要求至少用两种排序算法实现)。

[测试数据]由学生依据软件工程的测试技术自己确定。

三、实验前的准备工作1、掌握哈希表的定义,哈希函数的构造方法。

2、掌握一些常用的查找方法。

1、掌握几种常用的排序方法。

2、掌握直接排序方法。

四、实验报告要求1、实验报告要按照实验报告格式规范书写。

2、实验上要写出多批测试数据的运行结果。

3、结合运行结果,对程序进行分析。

五、算法设计a、折半查找设表长为n,low、high和mid分别指向待查元素所在区间的下界、上界和中点,key为给定值。

初始时,令low=1,high=n,mid=(low+high)/2,让key与mid指向的记录比较,若key==r[mid].key,查找成功若key<r[mid].key,则high=mid-1若key>r[mid].key,则low=mid+1重复上述操作,直至low>high时,查找失败b、顺序查找从表的一端开始逐个进行记录的关键字和给定值的比较。

在这里从表尾开始并把下标为0的作为哨兵。

void chaxun(SqList &ST) //查询信息{ cout<<"\n************************"<<endl;cout<<"~ (1)根据学号查询 ~"<<endl;cout<<"~ (2)根据姓名查询 ~"<<endl;cout<<"~ (3)根据性别查询 ~"<<endl;cout<<"~ (4)退出 ~"<<endl;cout<<"************************"<<endl; if(m==1) 折半查找算法:for(int i=1;i<ST.length;i++)//使学号变为有序for(int j=i;j>=1;j--)if(ST.r[j].xuehao<ST.r[j-1].xuehao){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}int a=0;cout<<"输入要查找的学号"<<endl;cin>>n;int low,high,mid;low=0;high=ST.length-1; // 置区间初值while (low<=high){mid=(low+high)/2;if(n==ST.r[mid].xuehao){cout<<ST.r[mid].xuehao<<""<<ST.r[mid].xingming<<""<<ST.r[mid].xingbei<<""<<ST.r[mid].chengji1<<""<<ST.r[mid].chengji2<<""<<ST.r[mid].zong<<endl;a=1;break;}else if(n<ST.r[mid].xuehao )high=mid-1; // 继续在前半区间进行查找elselow=mid+1; // 继续在后半区间进行查找顺序查找算法:cout<<"输入要查找的姓名"<<endl;cin>>name;for(int i=0;i<ST.length;i++){if(name==ST.r[i].xingming){cout<<ST.r[i].xuehao<<""<<ST.r[i].xingming<<""<<ST.r[i].xingbei<<""<<ST.r[i].chengji1<<""<<ST.r[i].chengji2<<""<<ST.r[i].zong<<endl;a=1;}1、插入排序每步将一个待排序的记录,按其关键码大小,插入到前面已经排好序的一组记录的适当位置上,直到记录全部插入为止。

查找和排序实验报告

查找和排序实验报告

查找和排序实验报告
本实验主要针对以查找、排序算法为主要实现目标的软件开发,进行实验室研究。


验包括:冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序,
以及折半查找算法。

实验采用C语言编写,在完成以上排序以及查找方法的基础上,针对实验的工程要求,进行了性能分析,分析了算法空间复杂度以及时间复杂度。

通过首先采用循环方式,构建未排序数组,在此基础上,调用算法实现查找和排序。

也对不同算法进行对比分析,将数据量在100个至30000个之间进行测试。

结果表明:快速排序与希尔排序在时间复杂度方面具有最好的表现,而冒泡排序和选
择排序时间复杂度较高。

在空间复杂度方面,基数排序表现最佳,折半查找的空间复杂度
则比较可观。

在工程应用中,根据对不同排序算法的研究,可以更准确、有效地选择正确的算法实现,有效应用C语言搭建软件系统,提高软件应用效率。

(建议加入算法图)
本实验结束前,可以得出结论:
另外,也可以从这些研究中发现,在使用C语言实现软件系统时,应该重视算法支持
能力,以提高软件应用效率。

由于查找和排序算法在软件应用中占有重要地位,此次实验
对此有贡献,可为未来开发提供支持。

顺序查找法实验报告

顺序查找法实验报告

一、实验目的1. 理解顺序查找法的原理和过程。

2. 掌握顺序查找法的实现方法。

3. 通过实验验证顺序查找法的效率和适用场景。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 实验数据:一组随机生成的整数序列三、实验原理顺序查找法是一种简单的查找算法,其基本思想是从线性表的第一个元素开始,逐个比较,直到找到待查找的元素或者比较到序列的末尾。

如果找到待查找的元素,则返回该元素的位置;如果比较到序列的末尾仍未找到,则返回-1表示查找失败。

顺序查找法的时间复杂度为O(n),空间复杂度为O(1),适用于数据量较小或者无序的线性表。

四、实验步骤1. 导入Python的random模块,用于生成随机整数序列。

2. 定义一个顺序查找函数,接收线性表和待查找元素作为参数。

3. 在主函数中,生成一个随机整数序列,并设置待查找元素。

4. 调用顺序查找函数,并输出查找结果。

五、实验代码```pythonimport randomdef sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1def main():# 生成随机整数序列arr = [random.randint(1, 100) for _ in range(20)] print("随机整数序列:", arr)# 设置待查找元素target = random.randint(1, 100)print("待查找元素:", target)# 调用顺序查找函数result = sequential_search(arr, target)# 输出查找结果if result != -1:print("查找成功,元素位置:", result)else:print("查找失败")if __name__ == "__main__":main()```六、实验结果与分析1. 运行实验程序,生成随机整数序列和待查找元素。

实验七 查找和排序

实验七  查找和排序

实验七查找、排序的应用一、实验目的和内容1.实验目的1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。

2、学会比较各种排序与查找算法的优劣。

3、学会针对所给问题选用最适合的算法。

4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。

2.实验内容问题描述对学生的基本信息进行管理。

基本要求设计一个学生信息管理系统,学生对象至少要包含:学号、姓名、性别、成绩1、成绩2、总成绩等信息。

要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息(要求至少用两种查找算法实现);3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序(要求至少用两种排序算法实现)。

测试数据由学生依据软件工程的测试技术自己确定。

二、程序设计1.总体设计typedef struct //定义每个记录(数据元素)的结构{string xingming; //姓名string xingbei; //性别float numer; //学号float score1,score2; //成绩1,成绩2float total_score; //总分}RecordType;typedef struct //定义顺序表的结构{RecordType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;void CreatList(SqList &ST) //创建学生的相关信息void total_score(SqList &ST) //计算总分void output(SqList &ST) //输出void Query(SqList &ST) //查询信息void sort(SqList &ST) //排序void menu(SqList &ST) //选择菜单2.详细设计1.void Query(SqList &ST)函数是用来查询信息,其中可以根据学号、姓名、性别查询学生信息。

排序查找实验报告

排序查找实验报告

排序查找实验报告排序查找实验报告一、引言排序和查找是计算机科学中非常重要的基础算法。

排序算法可以将一组无序的数据按照某种规则重新排列,而查找算法则可以在大量数据中快速找到目标元素。

本实验旨在通过实际操作和观察,对比不同的排序和查找算法的性能和效果,以便更好地理解和应用这些算法。

二、实验目的本实验的主要目的有以下几点:1. 理解不同排序算法的原理和特点;2. 掌握不同排序算法的实现方法;3. 比较不同排序算法之间的性能差异;4. 理解不同查找算法的原理和特点;5. 掌握不同查找算法的实现方法;6. 比较不同查找算法之间的性能差异。

三、实验过程1. 排序算法实验在排序算法实验中,我们选择了冒泡排序、选择排序和快速排序三种常见的排序算法进行比较。

首先,我们编写了一个随机生成一组无序数据的函数,并将其作为排序算法的输入。

然后,分别使用冒泡排序、选择排序和快速排序对这组数据进行排序,并记录下每种算法的执行时间。

最后,我们比较了三种算法的执行效率和排序结果的准确性。

2. 查找算法实验在查找算法实验中,我们选择了顺序查找、二分查找和哈希查找三种常见的查找算法进行比较。

首先,我们编写了一个生成有序数据的函数,并将其作为查找算法的输入。

然后,分别使用顺序查找、二分查找和哈希查找对这组数据进行查找,并记录下每种算法的执行时间。

最后,我们比较了三种算法的执行效率和查找结果的准确性。

四、实验结果1. 排序算法实验结果经过实验比较,我们发现快速排序算法在大多数情况下具有最好的性能表现,其平均时间复杂度为O(nlogn)。

冒泡排序算法虽然简单,但其时间复杂度为O(n^2),在数据量较大时效率较低。

选择排序算法的时间复杂度也为O(n^2),但相对于冒泡排序,其交换次数较少,因此效率稍高。

2. 查找算法实验结果顺序查找算法是最简单的一种查找算法,其时间复杂度为O(n),适用于小规模数据的查找。

二分查找算法的时间复杂度为O(logn),适用于有序数据的查找。

湘潭大学 数据结构实验7 实验报告 源代码 查找和排序算法

湘潭大学 数据结构实验7 实验报告 源代码 查找和排序算法

“数据结构和算法II”课程实验报告实验名称:查找和排序算法的实现班级姓名学号实验日期:实验机时:2 学时实验成绩:-------------------------------------------------------------------------------一.实验目的:掌握有序表、无序表查找的基本思想及存储、运算的实现熟练掌握常用排序算法的基本思想及实现深刻理解各种算法的特点,并加以灵活应用加深对查找和排序的理解,逐步培养解决实际问题的编程能力加深对图的理解,逐步培养解决实际问题的编程能力实验内容:(1)基本实验内容:建立一个无序表并实现其上的顺序查找;建立一个有序表并实现其上的折半查找;实现插入排序、起泡排序、快速排序和希尔排序的基本算法;(2)扩展实验内容:建立二叉排序树并在其上查找指定关键字。

二.程序及注释:1.顺序查找与二分法查找:#include<stdio.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int status ;typedef int ElemType ;typedef struct{ElemType *elem;int length,listsize;}SqList;int n;status InitList(SqList &L)//初始化{L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.listsize=LIST_INIT_SIZE;L.length=0;return OK;}status Build(SqList &L)//建立表{int i;printf("请输入元素个数n和n个元素\n");scanf("%d",&n);if(n>LIST_INIT_SIZE)//如果n大于当前空间{L.elem=(ElemType *)realloc(L.elem,(n+LISTINCREMENT)*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.listsize=n+LISTINCREMENT;}for(i=0;i<n;i++)scanf("%d",L.elem+i);L.length=n;return OK;}void Sort(SqList &L)//冒泡排序(升序){int i,j,t;for(i=1;i<L.length;i++)for(j=0;j<L.length-i;j++){if(*(L.elem+j)>*(L.elem+j+1)){t=*(L.elem+j);*(L.elem+j)=*(L.elem+j+1);*(L.elem+j+1)=t;}}}void sunxv(SqList &L,int x)//顺序查找函数{ int i,k=0;for(i=0;i<n;i++){ if(x==*(L.elem+i)){printf("已找到您查找的元素:%d\n",x);k=1;break;} } if(k==0)printf("未找到您查找的元素\n");}int erfen(SqList &L,int x)//二分法查找函数{ int left,mid,right;left=0;right=n-1;while(left<=right){ mid=(left+right)/2;if(*(L.elem+mid)<x)left=mid+1;else if(*(L.elem+mid)>x)right=mid-1;else{printf("已找到您查找的元素:%d\n",x);return 0;}}printf("未找到您查找的元素\n");}int main(){int op,x,sign=1;SqList L,Lb;InitList(L);Build(L);Sort(L);while(sign){printf("请选择要执行的查找方式:\n 【1】顺序查找\n 【2】二分查找\n 【0】退出\n"); scanf("%d",&op);if(op==0){sign=0;continue;}printf("请选择要查找的元素:\n");scanf("%d",&x);if(op==1)sunxv(L,x);else if(op==2)erfen(L,x);elseprintf("输入错误!!!\n");}}2.几种排序算法:#include<stdio.h>#include<stdlib.h>#define Q 1000typedef struct {char *base ;int stacksize ;int length;}SqList1;void zj(FILE *fp)//插入排序{SqList1 r;int i,j;char temp,*p;r.base=(char *) malloc(Q*sizeof(char));r.stacksize = Q;r.length = 0;while(!feof(fp)){fscanf(fp,"%c",r.base);r.base++;r.length++;if(r.length == r.stacksize ){r.base= r.base - r.length;r.base=(char *) realloc(r.base,(r.stacksize + Q) * sizeof(char));if(!r.base){printf("ERROR");return ; }r.base = r.base + r.stacksize;r.stacksize += Q;} }r.length --;r.base --;r.base= r.base - r.length;for (i = 1 ; i < r.length ;++i )for(j=0;j < i;++j)if(r.base[i] < r.base[j]){temp = r.base[i];//保存待插入记录for(i= i ;i > j; --i )r.base[i] = r.base[i-1];//记录后移r.base[j] = temp;//插入到正确的为位置}r.base[r.length] ='\0';rewind(fp);fprintf(fp,"%s",r.base);fclose(fp);free(r.base);}typedef struct {char *base ;int stacksize ;int length;}SqList3;void xe(FILE *fp)//希尔排序{SqList3 r;int i,j,k,m;char temp;r.length = 0;r.base=(char *) malloc(1000*sizeof(char));r.stacksize = 1000;while(!feof(fp)){fscanf(fp,"%c",r.base);r.base++;r.length++;if(r.length == r.stacksize ){r.base= r.base - r.length;r.base=(char *) realloc(r.base,(r.stacksize + Q) * sizeof(char));if(!r.base){printf("ERROR");return ; }r.base = r.base + r.stacksize;r.stacksize += Q;} }r.length --;r.base --;r.base= r.base - r.length;for(k = 0; k < 10 ; k++){m = 10 - k;for( i = m ; i < r.length; i ++ )if(r.base[i] < r.base[i - m]){temp = r.base[i]; //保存待插记录for(j = i - m ; j >= 0 && temp < r.base[j]; j -= m)r.base[ j + m ] = r.base[j]; //记录后移,查找插入位置r.base[ j + m ] = temp;//插入} }rewind(fp);fprintf(fp,"%s",r.base);fclose(fp);free(r.base);}typedef struct {char *base ;int stacksize ;int length;}SqList7;void mp(FILE *fp)//冒泡排序{ SqList7 r;int i,j ,m;char temp;r.length = 0;r.base = (char *) malloc(1000*sizeof(char));r.stacksize = 1000;while(!feof(fp)){ fscanf(fp,"%c",r.base);r.base++;r.length++;if(r.length == r.stacksize ){ r.base= r.base - r.length;r.base=(char *) realloc(r.base,(r.stacksize + Q) * sizeof(char));if(!r.base){ printf("ERROR");return ; }r.base = r.base + r.stacksize;r.stacksize += Q;} }r.length --;r.base --;r.base= r.base - r.length;for( i=0; i < r.length ;i++ )// i为排好序的数的下标,依次往后存放排好序的数;{ m=1;for( j = r.length-2;j >= i;j -- ) //从后往前依次两两比较,较小的被调换到前面;if(r.base[j+1] < r.base[j])//比较相邻两个数,如果后面的小于前面的,向下执行;{ temp = r.base[j+1]; //将后面的较小的数保存起来;r.base[j+1] = r.base[j];//将前面的较大的数放在后面较小的数的位置;r.base[j] = temp;//将较小的数放在前面的较大的数的位置;m = 0;}if( m ) break; }r.base[r.length] ='\0';rewind(fp);fprintf(fp,"%s",r.base);fclose(fp);free(r.base);}typedef struct {char *base ;int stacksize ;int length;}SqList5;void HeapAdjust(char *r,int s,int m);void dp(FILE *fp)//堆排序{ SqList5 r;int i,j;char temp,*k;r.length = 0;r.base=(char *) malloc(1000*sizeof(char));r.stacksize = 1000;r.base += 1;while(!feof(fp)){ fscanf(fp,"%c",r.base);r.base++;r.length++;if(r.length == (r.stacksize - 1) ){ r.base= r.base - r.length - 1;r.base=(char *) realloc(r.base,(r.stacksize + Q) * sizeof(char));if(!r.base){ printf("ERROR");return ; }r.base = r.base + r.stacksize;r.stacksize += Q;} }r.length --;r.base --;r.base= r.base - r.length - 1;for(i = r.length / 2;i >= 1 ; --i)//把r.base[1...r.length]建成大顶堆HeapAdjust(r.base,i,r.length);for(i = r.length ;i >= 2 ; --i){ temp = r.base[1];r.base[1] = r.base[i];r.base[i] = temp;HeapAdjust(r.base,1,i-1);//将r.base[1...i-1]重新调整为大顶堆}k = (char *) malloc((r.length+1)*sizeof(char));for(i = r.length,j = 0; i >= 1; i--,j++)k[j] = r.base[i];k[j]='\0';rewind(fp);fprintf(fp,"%s",k);fclose(fp);free(k);free(r.base);}void HeapAdjust(char *r,int k,int m){ int i,j;char x;i=k; x=r[i]; j=2*i;//沿key 较大的孩子节点向下筛选while(j<=m)//j为key较大的记录的下标{ if( (j<m) && (r[j]>r[j+1]) )j++;if(x>r[j])//插入字符比当前的大,交换{ r[i] =r[j];i = j;j *= 2;}else //否则比较停止j = m + 1;}r[i] = x;//把字符x插入到该位置,元素插入实现}#include<stdio.h>#include<stdlib.h>#define Q 1000typedef struct {char *base ;int stacksize ;int length;}SqList6;void merge(SqList6 r,int h,int m,int w,SqList6 t)//对相邻两组数据进行组合排序;{ int i,j,k;i = h; j = m + 1; k = h - 1;//j为合并的第二组元素的第一个数位置,k为存入t中的数的位置while((i <= m)&&(j <= w))//依次排列两组数据{ k++;if(r.base[i] <= r.base[j])//将第一组数据与第二组数据分别比较;t.base[k] = r.base[i++];elset.base[k] = r.base[j++]; }if(i > m)//第一组数据先排完的情况while(j <= w) t.base[++k]=r.base[j++];elsewhile(i <= m) t.base[++k]=r.base[i++];}void tgb(int s,int n,SqList6 r,SqList6 t)//对数据进行每组s个数的归并排序;{ int i=1;//i为要合并两组元素的第一个数位置;while(i<=(n-2*s+1)){ merge(r,i,i+s-1,i+2*s-1,t);//i+s-1为要合并的第一组元素的最后一个数位置、i+2*s-1 为要合并的两组元素最后一个数位置i=i+2*s;}if(i<(n-s+1)) //考虑n不能被s整除,如果余下的数少于2*s 但大于s,也就是余下的数不能凑成两组,凑一组有余,则把余下的数进行组合,并对其进行排序;merge(r,i,i+s-1,n,t);else //如果余下的数少于s,则余下的数进行组//合,并进行排序;while(i<=n)t.base[i]=r.base[i++];}void gb(FILE *fp)//归并主函数;{ SqList6 r;r.length = 0;r.base=(char *) malloc(1000*sizeof(char));r.stacksize = 1000;r.base += 1;while(!feof(fp)){ fscanf(fp,"%c",r.base);r.base++;r.length++;if(r.length == (r.stacksize - 1) ){ r.base= r.base - r.length - 1;r.base=(char *) realloc(r.base,(r.stacksize + Q) * sizeof(char));if(!r.base){ printf("ERROR");return ; }r.base = r.base + r.stacksize;r.stacksize += Q;} }r.length --;r.base= r.base - r.length - 2;int i,j,n,s=1;n = r.length;SqList6 t;t.base=(char *) malloc(r.stacksize*sizeof(char));//给待排序的数组t申请内存;while(s<n)//每组元素不断增加循环进行合并排序;{ tgb(s,n,r,t);// s为每组元素的个数、n为元素总个数、r为原数组,t为待排序的数组,进行归并排序;把元素个数相同的两组合并并进行重新定义成新的一组,此组元素个数为2*s;s*=2;if(s<n){ tgb(s,n,t,r); s *= 2; }//当元素个数小于n时,对其进行合并排序;else //当元素个数大于n时,对剩下的数排序;{ i=0;while(i<=n){ r.base[i]=t.base[i+1];i++;} } }r.base[r.length] ='\0';rewind(fp);fprintf(fp,"%s",r.base);fclose(fp);free(t.base);free(r.base);}int main(){ FILE *fp;int sign=1;while(sign != 0){ printf("请选择:\n");printf(" %6c [1]直接插入排序\n",' ');printf(" %6c [2]希尔排序\n",' ');printf(" %6c [3]堆排序\n",' ');printf(" %6c [4]归并排序\n",' ');printf(" %6c [5]冒泡排序\n",' ');printf(" %6c [0]退出\n",' ');printf("请输入:");scanf("%d",&sign);if((fp=fopen("xuexinsheng.txt","r+"))==NULL){ printf(" File open error!\n");return 0;}switch(sign){case 1:zj(fp);break;case 2:xe(fp); break;case 3:dp(fp);break;case 4:gb(fp); break;case 5:mp(fp);break;case 0:break;}if(sign!=0)printf("排序已完成!!!\n\n"); }}三.运行结果:1.顺序查找与二分法查找:2.几种排序算法:(排序算法运行结果如上,由于几种排序方法的运行结果相同,故只演示其中一种的截图。

查找和排序 实验报告

查找和排序 实验报告

查找和排序实验报告查找和排序实验报告一、引言查找和排序是计算机科学中非常重要的基础算法之一。

查找(Search)是指在一组数据中寻找目标元素的过程,而排序(Sort)则是将一组数据按照特定的规则进行排列的过程。

本实验旨在通过实际操作和实验验证,深入理解查找和排序算法的原理和应用。

二、查找算法实验1. 顺序查找顺序查找是最简单的查找算法之一,它的基本思想是逐个比较待查找元素与数据集合中的元素,直到找到目标元素或遍历完整个数据集合。

在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用顺序查找算法查找指定的目标元素。

实验结果显示,顺序查找的时间复杂度为O(n)。

2. 二分查找二分查找是一种高效的查找算法,它要求待查找的数据集合必须是有序的。

二分查找的基本思想是通过不断缩小查找范围,将待查找元素与中间元素进行比较,从而确定目标元素的位置。

在本实验中,我们首先对数据集合进行排序,然后使用二分查找算法查找指定的目标元素。

实验结果显示,二分查找的时间复杂度为O(log n)。

三、排序算法实验1. 冒泡排序冒泡排序是一种简单但低效的排序算法,它的基本思想是通过相邻元素的比较和交换,将较大(或较小)的元素逐渐“冒泡”到数列的一端。

在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用冒泡排序算法对其进行排序。

实验结果显示,冒泡排序的时间复杂度为O(n^2)。

2. 插入排序插入排序是一种简单且高效的排序算法,它的基本思想是将数据集合分为已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的适当位置。

在本实验中,我们使用插入排序算法对包含1000个随机整数的数据集合进行排序。

实验结果显示,插入排序的时间复杂度为O(n^2)。

3. 快速排序快速排序是一种高效的排序算法,它的基本思想是通过递归地将数据集合划分为较小和较大的两个子集合,然后对子集合进行排序,最后将排序好的子集合合并起来。

查找排序算法实验报告(3篇)

查找排序算法实验报告(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)。

实验6_7查找和排序

实验6_7查找和排序

实验六、七:查找、排序算法的应用一、实验目的1 掌握查找的不同方法,并能用高级语言实现查找算法。

2 熟练掌握顺序表和有序表的顺序查找和二分查找方法。

3 掌握排序的不同方法,并能用高级语言实现排序算法。

4 熟练掌握顺序表的选择排序、冒泡排序和直接插入排序算法的实现。

二、实验内容1 创建给定的顺序表。

表中共包含八条学生信息,信息如下:学号姓名班级C++ 数据结构1 王立03511 85 762 张秋03511 78 883 刘丽03511 90 794 王通03511 75 865 赵阳03511 60 716 李艳03511 58 687 钱娜03511 95 898 孙胜03511 45 602 使用顺序查找方法,从查找表中查找姓名为赵阳和王夏的学生。

如果查找成功,则显示该生的相关信息;如果查找不成功,则给出相应的提示信息。

3 使用二分查找方法,从查找表中查找学号为7和12的学生。

如果查找成功,则显示该生的相关信息;如果查找不成功,则给出相应的提示信息。

(注意:创建静态查找表时必须按学号的从小到大排列!)4 使用直接选择排序方法,对学生信息中的C成绩进行排序。

输出排序前和排序后的学生信息表,验证排序结果。

5 使用冒泡排序方法,对学生信息中的数据结构成绩进行排序。

输出排序前和排序后的学生信息表,验证排序结果。

6 编写一个主函数,将上面函数连在一起,构成一个完整程序。

7 将实验源程序调试并运行。

三、实验结果源程序代码为:#include <stdio.h>#include <string.h>//#define M 100typedef struct {int studentNum;char name[20];char classNum[20];int C;int structure;}Student;int print(Student S[]){int i;printf("学生学号姓名班级C语言成绩数据结构成绩\n");for(i=0;i<8;i++){printf("%d %s %s %d %d\n",S[i].studentNum,S[i].name,S[i].classNum,S[i].C,S[i].struc ture);}return 0;}int shunxu(Student s[],char x[20]){int i,a=0;for(i=7;i>=0;i--)if(strcmp(s[i].name,x)==0)a=i;return a;}int xuanze(Student s[]){int i,j,k;Student A;for(i=0;i<7;i++){k=i;for(j=i+1;j<=7;j++)if(s[k].C>s[j].C)k=j;if(i!=k){A=s[k];s[k]=s[i];s[i]=A;}}return 0;}int erfen(Student s[],int num){int flag=0;int low,high,mid;low=0;high=7;while(low<=high){mid=(low+high)/2;if(s[mid].studentNum>num)high=mid-1;else if(s[mid].studentNum<num)low=mid+1;else{flag=mid;break;}}return flag;}int maopao(Student s[]){int i,j,swap;Student A;for(i=1;i<8;i++){swap=0;for(j=0;j<=8-i;j++)if(s[j].structure>s[j+1].structure){A=s[j];s[j]=s[j+1];s[j+1]=A;swap=1;}if(swap==0)break;} return 0;}void main(){int i,n,n1;int flag=1;char kx[20];Student s[] = {{1, "wangli", "03511", 85, 76},{2, "zhangqiu", "03511", 78, 88},{3, "liuli", "03511", 90, 79},{4, "wangtong", "03511", 75, 86},{5, "zhaoyang", "03511", 60, 71},{6, "liyan", "03511", 58, 68},{7, "qianna", "03511", 95, 89},{8, "sunsheng", "03511", 45, 60}};printf("1、按姓名顺序查找2、按C语言成绩排序");printf("3、按学号查找4、按数据结构成绩排序5、退出程序");while(flag){printf("\n请选择要进行的操作:");scanf("%d",&n);switch(n){case 1: printf("请输入要查找的学生的姓名:\n");scanf("%s",&kx);i=shunxu(s,kx);if(i){printf("学生的学号姓名班级C语言成绩数据结构成绩\n");printf("%d %s %s %d %d",s[i].studentNum,s[i].name,s[i].classNum,s[i].C,s[i].structure );printf("\n");}elseprintf("没有此人!");break;case 2: printf("选择排序:\n");printf("排序前的学生信息:\n");print(s);xuanze(s);printf("排序后的学生信息:\n");print(s);break;case 3:printf("输入要查找的学号:");scanf("%d",&n1);i=erfen(s,n1);if(i){printf("学生的学号姓名班级C语言成绩数据结构成绩\n");printf("%d %s %s %d %d",s[i].studentNum,s[i].name,s[i].classNum,s [i].C,s[i].structure);printf("\n");}elseprintf("不存在此学号!");break;case 4: printf("排序前的学生信息:\n");print(s);maopao(s);printf("排序后的学生信息:\n");print(s);break;case 5: printf("欢迎再次使用本系统!\n");flag=0;break;}}}。

查找与排序实验报告

查找与排序实验报告

查找与排序实验报告《查找与排序实验报告》摘要:本实验旨在通过不同的查找与排序算法对比分析它们的效率和性能。

我们使用了常见的查找算法包括线性查找、二分查找和哈希查找,以及排序算法包括冒泡排序、快速排序和归并排序。

通过实验数据的对比分析,我们得出了每种算法的优缺点和适用场景,为实际应用提供了参考依据。

1. 实验目的通过实验对比不同查找与排序算法的性能,分析它们的优缺点和适用场景。

2. 实验方法(1)查找算法实验:分别使用线性查找、二分查找和哈希查找算法,对含有一定数量元素的数组进行查找操作,并记录比较次数和查找时间。

(2)排序算法实验:分别使用冒泡排序、快速排序和归并排序算法,对含有一定数量元素的数组进行排序操作,并记录比较次数和排序时间。

3. 实验结果(1)查找算法实验结果表明,二分查找在有序数组中的查找效率最高,哈希查找在大规模数据中的查找效率最高。

(2)排序算法实验结果表明,快速排序在平均情况下的排序效率最高,归并排序在最坏情况下的排序效率最高。

4. 实验分析通过实验数据的对比分析,我们得出了以下结论:(1)查找算法:二分查找适用于有序数组的查找,哈希查找适用于大规模数据的查找。

(2)排序算法:快速排序适用于平均情况下的排序,归并排序适用于最坏情况下的排序。

5. 结论不同的查找与排序算法在不同的场景下有着不同的性能表现,选择合适的算法可以提高程序的效率和性能。

本实验为实际应用提供了参考依据,对算法的选择和优化具有一定的指导意义。

通过本次实验,我们深入了解了不同查找与排序算法的原理和性能,为今后的算法设计和优化工作提供了宝贵的经验和参考。

实验名称二查找和排序算法的实现

实验名称二查找和排序算法的实现

实验名称:二查找和排序算法的实现课程名称数据结构实验时间年月日(组)实验地点一、实验目的1.掌握插入排序在顺序存储结构上的实现。

2.掌握交换排序在顺序存储结构上的实现。

3.掌握选择排序在顺序存储结构上的实现。

4.掌握归并排序在顺序存储结构上的实现。

5.理解基数排序在链式存储结构上的实现。

二、实验环境硬件环境:微型计算机软件环境:Window 7操作系统、VC++6.0编辑器三、实验原理及相关知识重点:插入、交换、选择、归并、基数排序在顺序存储结构上的实现。

难点:插入、交换、选择、归并、基数排序在顺序存储结构上的实现。

四、实验步骤1.编写程序,建立线性表,实现顺序查找和折半查找某个关键字。

#include "stdio.h"#include "stdlib.h"typedef int datatype;#define n 10typedef struct record{int key;datatype others;}record;int sqsearch(struct record r[], int k){int i;for(i=0; i<=n-1; i++)if (r[i].key==k)return i+1;return 0;}int bisearch(struct record r[], int k) {int low=0,mid,high=n-1;while(low<=high){mid=(low+high)/2;if(r[mid].key==k)return mid+1;else if(r[mid].key>k)high=mid-1;elselow=mid+1;}return 0;}void biinsertsort(struct record r[],int k) {int i,j,low,mid,high;struct record temp;for(i=1;i<=k-1;i++){low=0; high=i-1;while(low<=high){mid=(low+high)/2;if(_____________)_____________;else_____________;}for(temp=r[i], j=i-1; j>=low; j--)_____________;r[low]=temp;}for( i=0; i<=k-1; i++)printf("%d\t",r[i].key);printf("\n");}void main( ){int i;struct record r[n];for (i=0;i<n;i++){r[i].key=rand()%100;printf("%d\t",r[i].key);}biinsertsort(r,n);if (sqsearch(r,44)>0)printf("44 found\n");elseprintf("44 not found\n");if(bisearch(r,44)>0)printf("44 found\n");elseprintf("44 not found\n");}2.插入排序在顺序存储结构上的实现。

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

实验七查找和排序算法的实现一.实验目的及要求(1)学生在实验中体会各种查找和内部排序算法的基本思想、适用场合,理解开发高效算法的可能性和寻找、构造高效算法的方法。

(2)掌握运用查找和排序解决一些实际应用问题。

二.实验内容:(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等),并计算相应的ASL。

(2)编程实现一种内部排序算法(如插入排序、快速排序等)。

三.实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写,请另加附页)(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等),并计算相应的ASL。

➢程序代码:折半查找:头文件:#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))#define maxlength 20typedef int ElemType;typedef struct{ElemType key;ElemType other;}card;//每条记录包含的数据项typedef struct{card r[maxlength];int length;}SSTable;//一张表中包含的记录容量void Create(SSTable &L);int Search(SSTable L,int elem);功能函数:#include"1.h"#include"stdio.h"void Create(SSTable &L){printf("新的线性表已经创建,请确定元素个数(不超过20)\n");scanf("%d",&L.length);printf("请按递增序列输入具体的相应个数的整数元素(空格隔开)\n");for(int i=0;i<L.length;i++){scanf("%d",&L.r[i].key);}}int Search(SSTable L,int elem){if(L.r[L.length-1].key<elem||L.r[0].key>elem){printf("表中没有该元素(不在范围内)\n");return 0;}int low=0,high=L.length-1;int mid;while(low<=high){mid=(low+high)/2;if(EQ(L.r[mid].key,elem)){printf("该元素在第%d位\n",mid+1); return 0;}else if(LT(elem,L.r[mid].key)){high=mid-1;}else{low=mid+1;}}printf("表中没有该元素(不在范围内)\n");return 0;}主函数:#include"stdio.h"#include"1.h"int main(){SSTable L;Create(L);printf("\n");printf("此时的线性表元素:\n");for(int a=0;a<L.length;a++){printf("%d ",L.r[a].key);}printf("\n");printf("\n");int elem;do{printf("请输入要查找的元素(输入000表示结束程序)\n");scanf("%d",&elem);if(elem!=000){Search(L,elem);}}while(elem!=000);return 0;}➢运行结果:(2)编程实现一种内部排序算法(如插入排序、快速排序等)。

程序代码部分:直接插入排序头文件:#define maxlength 20//最大数据容量#define OK 1typedef int Status;typedef int Other;typedef int KeyType;typedef struct{KeyType key;Other data;}Red;typedef struct{Red r[maxlength+1];//加了个哨兵的位置int length;//当前数据个数}SqList;Status Init(SqList &L);Status Insertsort(SqList &L);功能函数:#include"stdio.h"#include"1.h"Status Init(SqList &L){printf("新的线性表以创建,请确定元素个数(不超过20)\n");scanf("%d",&L.length);printf("请输入具体的相应个数的整数元素(空格隔开)\n");for(int i=1/*将哨兵的位置【0】空出来*/;i<L.length+1;i++){scanf("%d",&L.r[i].key);}return OK;}Status Insertsort(SqList &L){for(int i=2;i<L.length+1;i++){L.r[0]=L.r[i];//交换的应该是该位置记录的完整数据项,而不仅仅是数据项中的一个keyfor(int j=i;j>0&&L.r[0].key<L.r[j-1].key/*这里是依据记录中的数据项key来排序的,所以比较的是key,而不是一条记录的所有数据项*/;j--){L.r[j]=L.r[j-1];}L.r[j]=L.r[0];}return OK;}主函数:#include"stdio.h"#include"1.h"int main(){SqList L;Init(L);printf("\n");printf("排序前的线性表元素:\n");for(int a=1;a<L.length+1;a++){printf("%d ",L.r[a].key);}printf("\n");printf("\n");Insertsort(L);printf("排序后的线性表元素:\n");for(int b=1;b<L.length+1;b++){printf("%d ",L.r[b].key);}printf("\n");return 0;}快速排序头文件:#define maxlength 20//最大数据容量#define OK 1typedef int Status;typedef int Other;typedef int KeyType;typedef struct{KeyType key;Other data;}Red;typedef struct{Red r[maxlength+1];//加了个哨兵的位置int length;//当前数据个数}SqList;void Init(SqList &L);Status Partition(SqList &L,int low,int high);void QSort(SqList &L,int low,int high);功能函数:#include"stdio.h"#include"1.h"void Init(SqList &L){printf("新的线性表以创建,请确定元素个数(不超过20)\n");scanf("%d",&L.length);printf("请输入具体的相应个数的整数元素(空格隔开)\n");for(int i=1/*将存放枢轴中关键字所在记录完整信息的位置【0】空出来*/;i<L.length+1;i++){scanf("%d",&L.r[i].key);}}Status Partition(SqList &L,int low,int high){int pivotkey;pivotkey=L.r[low].key;//用第一条记录的关键字作枢轴L.r[0]=L.r[low];//存放作为枢轴的关键字所在记录的完整信息while(low<high){while(low<high&&L.r[high].key>=pivotkey){high--;}//从右端往左L.r[low]=L.r[high];while(low<high&&L.r[low].key<=pivotkey){low++;}//从左端往右L.r[high]=L.r[low];}L.r[low]=L.r[0];return low;}void QSort(SqList &L,int low,int high){int pivotloc;if(low<high){pivotloc=Partition(L,low,high);QSort(L,low,pivotloc-1);QSort(L,pivotloc+1,high);}}主函数:#include"stdio.h"#include"1.h"int main(){SqList L;Init(L);printf("\n");printf("排序前的线性表元素:\n");for(int a=1;a<L.length+1;a++){printf("%d ",L.r[a].key);}printf("\n");printf("\n");printf("请输入无序子列的开始和结束位置(有序子列不用管)\n");int low,high;scanf("%d %d",&low,&high);QSort(L,low,high);printf("排序后的线性表元素:\n");for(int b=1;b<L.length+1;b++){printf("%d ",L.r[b].key);}printf("\n");return 0;➢运行结果:四.实验结果的分析与评价(该部分如不够填写,请另加附页)1.快速排序利用了递归的思想;2.折半查找使用前提为:数列有序注:实验成绩等级分为(90-100分)优,(80-89分)良,(70-79分)中,(60-69分)及格,(59分)不及格。

相关文档
最新文档