查找排序实验报告
数据结构与算法实验报告5-查找与排序
北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。
在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。
查找排序实验报告
查找排序实验报告一、实验目的本次实验的主要目的是深入理解和比较不同的查找和排序算法在性能和效率方面的差异。
通过实际编程实现和测试,掌握常见查找排序算法的原理和应用场景,为今后在实际编程中能够选择合适的算法解决问题提供实践经验。
二、实验环境本次实验使用的编程语言为 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 语言实现上述六种查找排序算法,并分别封装成函数,以便后续调用和测试。
查找、排序的应用 实验报告
实验七查找、排序的应用一、实验目的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、插入排序每步将一个待排序的记录,按其关键码大小,插入到前面已经排好序的一组记录的适当位置上,直到记录全部插入为止。
实验四 查找和排序
实验四查找和排序一实验目的:了解和掌握查找和排序算法的基本与原理与实现方法,掌握分析算法时间复杂度和空间复杂度的方法。
二实验内容:编制程序完成查找和排序算法的实例化。
要求上机实现两种以上的查找算法及排序算法。
分析和比较各算法的时间和空间复杂度。
三实验原理:查找是为了得到某些特定信息而进行的信息搜索工作。
查找算法的种类很多:顺序查找又称线性查找,是最基本的查找方法之一。
其查找方法为:从表的一端开始,向另一端逐个按给定值kx与关键码进行比较,若找到,查找成功,并给出数据元素在表中的位置;若整个表检测完,仍未找到与kx相同的关键码,则查找失败,给出失败信息。
有序表即是表中数据元素按关键码升序或降序排列。
折半查找在有序表中,取中间元素作为比较对象,若给定值与中间元素的关键码相等,则查找成功;若给定值小于中间元素的关键码,则在中间元素的左半区继续查找;若给定值大于中间元素的关键码,则在中间元素的右半区继续查找。
不断重复上述查找过程,直到查找成功,或所查找的区域无数据元素,查找失败。
分块查找又称索引顺序查找,是对顺序查找的一种改进。
分块查找要求将查找表分成若干个子表,并对子表建立索引表,查找表的每一个子表由索引表中的索引项确定。
索引项包括两个字段:关键码字段 (存放对应子表中的最大关键码值) ;指针字段 (存放指向对应子表的指针) ,并且要求索引项按关键码字段有序。
查找时,先用给定值kx在索引表中检测索引项,以确定所要进行的查找在查找表中的查找分块 (由于索引项按关键码字段有序,可用顺序查找或折半查找) ,然后,再对该分块进行顺序查找。
二叉排序树查找二叉排序树的查找过程为:①若查找树为空,查找失败。
②查找树非空,将给定值kx与查找树的根结点关键码比较。
③若相等,查找成功,结束查找过程,否则,a.当给kx小于根结点关键码,查找将在以左子女为根的子树上继续进行,转①b.当给kx大于根结点关键码,查找将在以右子女为根的子树上继续进行,转①排序(Sorting)是对一个数据元素集合或序列重新排列成一个按数据元素某个项值有序的序列。
查找排序实验报告
《编程实训》实验报告书专业:计算机科学与技术班级:151班学号:姓名:指导教师:日期:2016年6月30日目录一、需求分析 (3)1.任务要求 (3)2.软件功能分析 (3)3.数据准备 (3)二、概要设计 (3)1.功能模块图 (4)2.模块间调用关系 (4)3.主程序模块 (5)4.抽象数据类型描述 (5)三、详细设计 (6)1.存储结构定义 (6)2.各功能模块的详细设计 (7)四、实现和调试 (7)1.主要的算法 (7)2.主要问题及解决 (8)3.测试执行及结果 (8)五、改进 (9)六、附录 (9)1.查找源程序 (9)2.排序源程序 (9)目录1 需求分析1.1 任务要求对于从键盘随机输入的一个序列的数据,存入计算机内,给出各种查找算法的实现;以及各种排序算法的实现。
1.2 软件功能分析任意输入n个正整数,该程序可以实现各类查找及排序的功能并将结果输出。
1.3 数据准备任意输入了5个正整数如下:12 23 45 56 782 概要设计(如果2,3合并可以省略2.4)2.1 功能模块图(注:含功能说明)2.2 模块间调用关系2.3 主程序模块2.4 抽象数据类型描述存储结构:数据结构在计算机中的表示(也称映像)叫做物理结构。
又称为存储结构。
数据类型(data type)是一个“值”的集合和定义在此集合上的一组操作的总称。
3 详细设计3.1 存储结构定义查找:typedef int ElemType ;//顺序存储结构typedef struct{ElemType *elem; //数据元素存储空间基址,建表时按实际长度分配,号单元留空int length; //表的长度}SSTable;排序:typedef struct{ //定义记录类型int key; //关键字项}RecType;typedef RecType SeqList[Max+1]; //SeqList为顺序表,表中第0个元素作为哨兵3.2 各功能模块的详细设计查找:void Create(SSTable *table, int length); // 构建顺序表void FillTable(SSTable *table) // 无序表的输入int Search_Seq(SSTable *table, ElemType key); //哨兵查找算法void Sort(SSTable *table ) // 排序算法int Search_Bin(SSTable *table, ElemType key) // 二分法查找(非递归)排序:void InsertSort(SeqList R) //对顺序表R中的记录R[1‥n]按递增序进行插入排序void BubbleSort(SeqList R) //自下向上扫描对R做冒泡排序int Partition(SeqList R,int i,int j)//对R[i‥j]做一次划分,并返回基准记录的位置void QuickSort(SeqList R,int low,int high) //R[low..high]快速排序void SelectSort(SeqList R) //直接选择排序void Heapify(SeqList R,int low,int high) //大根堆调整函数void MergePass(SeqList R,int length) //归并排序4 实现和调试4.1 主要的算法查找:①建立顺序存储结构,构建一个顺序表,实现顺序查找算法。
实验五-查找和排序实验报告 查找及排序实验
并对调试过程中的问题进行分析,对执
输入你晏査找的关键字:阴
第1页共1页
2S 査我旗 I 加
本文格式为 Word 版,下载可任意编辑,页眉双击删除即可。
通过本次排序和查找的练习,初步把握了其基本概念和操作。
冃次查找?(Y/W :
查找的基本概念: 查找表: 是由同一类型的数据元素〔或记录〕构
输入像要查戏的关键字:4
else low=mid +1 ;
return i; }
}
(3)写出源程序清单(加适当的注释)。
return 0;
;//建立一个二叉树,元素从键盘输入,
}//Serch_B in;
直到回车为止
2.顺序查找算法描述如下: typedef struct {
void insert(BiTree *bt,BiTree s){// 在二叉树中插
else return select (bt-rchild,key);
(1 )
-
请输入要一列整数,以空格隔开,回车结束.
-修改 -
12 刖 55 23 55 78 121 31
(4)
非序后:
(4)调试说明。包括上机调试的状况、调试所遇到的问题是如何解决的, 12239134 FE E5 78 121
第1页共1页
in sert(((*bt)-lchild),s);
本文格式为 Word 版,下载可任意编辑,页眉双击删除即可。
while(1)
s-dt=key;
prin tf(%5d,bt-dt);
else if (s-dt(*bt)-dt)
{
s-lchild=s-rchild=NULL;
ZXBL (bt-rchild);
查找与排序实验报告
实验四:查找与排序【实验目的】1.掌握顺序查找算法的实现。
2.掌握折半查找算法的实现。
【实验内容】1.编写顺序查找程序,对以下数据查找37所在的位置。
5,13,19,21,37,56,64,75,80,88,922.编写折半查找程序,对以下数据查找37所在的位置。
5,13,19,21,37,56,64,75,80,88,92【实验步骤】1.打开VC++。
2.建立工程:点File->New,选Project标签,在列表中选Win32 ConsoleApplication,再在右边的框里为工程起好名字,选好路径,点OK->finish。
至此工程建立完毕。
3.创建源文件或头文件:点File->New,选File标签,在列表里选C++ SourceFile。
给文件起好名字,选好路径,点OK。
至此一个源文件就被添加到了你刚创建的工程之中。
4.写好代码5.编译->链接->调试#include "stdio.h"#include "malloc.h"#define OVERFLOW -1#define OK 1#define MAXNUM 100typedef int Elemtype;typedef int Status;typedef struct{Elemtype *elem;int length;}SSTable;Status InitList(SSTable &ST ){int i,n;ST.elem = (Elemtype*) malloc (MAXNUM*sizeof (Elemtype)); if (!ST.elem) return(OVERFLOW);printf("输入元素个数和各元素的值:");scanf("%d\n",&n);for(i=1;i<=n;i++){scanf("%d",&ST.elem[i]);}ST.length = n;return OK;}int Seq_Search(SSTable ST,Elemtype key){int i;ST.elem[0]=key;for(i=ST.length;ST.elem[i]!=key;--i);return i;}int BinarySearch(SSTable ST,Elemtype key){int low,high,mid;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(ST.elem[mid]==key)return mid;else if(key<ST.elem[mid])high=mid-1;elselow=mid+1;}return 0;}void main(){int key;SSTable ST;InitList(ST);printf("输入查找的元素的值:");scanf("%d",&key);Seq_Search(ST,key);printf("查找的元素所在的位置:%d\n",Seq_Search(ST,key));printf("输入查找的元素的值:");scanf("%d",&key);BinarySearch(ST,key);printf("查找的元素所在的位置:%d\n",BinarySearch(ST,key));}【实验心得】这是本学期的最后一节实验课,实验的内容是查找与排序。
查找排序操作实验报告
一、实验目的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)排序算法性能测试在数据量较大的情况下,快速排序和归并排序的性能明显优于冒泡排序、选择排序和插入排序。
排序和查找的实验报告
排序和查找的实验报告实验报告:排序和查找引言排序和查找是计算机科学中非常重要的基本算法。
排序算法用于将一组数据按照一定的顺序排列,而查找算法则用于在已排序的数据中寻找特定的元素。
本实验旨在比较不同排序和查找算法的性能,并分析它们的优缺点。
实验设计为了比较不同排序算法的性能,我们选择了常见的几种排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。
在查找算法的比较实验中,我们选择了顺序查找和二分查找两种常见的算法。
同样地,我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。
实验结果在排序算法的比较实验中,我们发现快速排序和归并排序在大多数情况下表现最好,它们的平均执行时间和空间占用都要优于其他排序算法。
而冒泡排序和插入排序则表现较差,它们的执行时间和空间占用相对较高。
在查找算法的比较实验中,二分查找明显优于顺序查找,尤其是在数据规模较大时。
二分查找的平均执行时间远远小于顺序查找,并且占用的空间也更少。
结论通过本实验的比较,我们得出了一些结论。
首先,快速排序和归并排序是较优的排序算法,可以在大多数情况下获得较好的性能。
其次,二分查找是一种高效的查找算法,特别适用于已排序的数据集。
最后,我们也发现了一些排序和查找算法的局限性,比如冒泡排序和插入排序在大数据规模下性能较差。
总的来说,本实验为我们提供了对排序和查找算法性能的深入了解,同时也为我们在实际应用中选择合适的算法提供了一定的参考。
希望我们的实验结果能够对相关领域的研究和应用有所帮助。
实验八-查找、排序
实验8:查找、排序一、实验目的深入了解各种内部排序方法及效率分析。
二、问题描述各种内部排序算法的时间复杂度分析,试通过随机数据比较算法的关键字比较次数和关键字移动次数。
三、实验要求1、对起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序这六种常用排序算法进行比较。
2、待排序表的表长不超过100;其中数据用伪随机数产生程序产生。
3、至少要用6组不同的输入数据做比较。
4、要对实验结果做简单分析。
四、实验环境PC微机DOS操作系统或 Windows 操作系统Turbo C 程序集成环境或 Visual C++ 程序集成环境五、实验步骤1、根据问题描述写出基本算法。
2、设计六种排序算法并用适当语言实现。
3、输入几组随机数据,并对其关键字比较次数和关键字移动次数的比较。
4、对结果进行分析。
5、进行总结。
六种实验算法的基本思想:(1)直接插入排序的基本思想是:当插入第i个数据元素k时,由前i-1个数据元素组成已排序的数据元素序列,将k的关键字与序列中各数据元素的关键字依次进行比较后,找到该插入位置j,并将第j以及后面的数据元素顺序后移一个位置,然后将k插入到位置j,使得插入后的数据元素序列仍是排序的。
(2)希尔排序的基本思想是:先将整个待排序记录序列按给定的下标增量进行分组,并对组内的记录采用直接插入排序,再减小下标增量,即每组包含的记录增多,再继续对每组组内的记录采用直接插入排序;以此类推,当下标增量减小到1时,整个待排序记录已成为一组,再对全体待排序记录进行一次直接插入排序即可完成排序工作。
(3)冒泡排序的基本思想是:将相邻的两个数据元素按关键字进行比较,如果反序,则交换。
对于一个待排序的数据元素序列,经一趟排序后最大值数据元素移到最大位置,其它值较大的数据元素向也最终位置移动,此过程为一次起泡。
然后对下面的记录重复上述过程直到过程中没有交换为止,则已完成对记录的排序。
(4)选择排序的基本思想是:设有N个数据元素的序列,第一趟排序,比较N个数据元素,选择关键字最小的数据元素,将其交换到序列的第1个位置上;第2趟排序,在余下的N-1个数据元素中,再选取关键字最小的数据元素,交换到序列的第2个位置上;继续进行,经过N-1趟排序,N个数据元素则按递增次序排列完成。
查找和排序实验报告
查找和排序实验报告
本实验主要针对以查找、排序算法为主要实现目标的软件开发,进行实验室研究。
实
验包括:冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序,
以及折半查找算法。
实验采用C语言编写,在完成以上排序以及查找方法的基础上,针对实验的工程要求,进行了性能分析,分析了算法空间复杂度以及时间复杂度。
通过首先采用循环方式,构建未排序数组,在此基础上,调用算法实现查找和排序。
也对不同算法进行对比分析,将数据量在100个至30000个之间进行测试。
结果表明:快速排序与希尔排序在时间复杂度方面具有最好的表现,而冒泡排序和选
择排序时间复杂度较高。
在空间复杂度方面,基数排序表现最佳,折半查找的空间复杂度
则比较可观。
在工程应用中,根据对不同排序算法的研究,可以更准确、有效地选择正确的算法实现,有效应用C语言搭建软件系统,提高软件应用效率。
(建议加入算法图)
本实验结束前,可以得出结论:
另外,也可以从这些研究中发现,在使用C语言实现软件系统时,应该重视算法支持
能力,以提高软件应用效率。
由于查找和排序算法在软件应用中占有重要地位,此次实验
对此有贡献,可为未来开发提供支持。
排序检验的实验报告(3篇)
第1篇一、实验目的1. 了解排序检验的基本原理和适用条件。
2. 掌握排序检验的步骤和方法。
3. 通过实际操作,验证排序检验的有效性。
二、实验背景排序检验(Rank Test)是一种非参数检验方法,适用于检验两组或多组数据是否存在显著差异。
当数据不符合正态分布,或者数据量较小,无法使用参数检验时,排序检验是一种较好的选择。
三、实验材料1. 实验数据:两组或多组数据,每组数据包含多个观测值。
2. 计算工具:Excel、SPSS等统计软件。
四、实验步骤1. 收集实验数据,确保数据符合排序检验的适用条件。
2. 对每组数据进行排序,从大到小排列。
3. 计算每组的秩和,即每组的观测值在排序后所在的位置。
4. 计算各组秩和的平均值和标准差。
5. 计算检验统计量,即各组秩和的平均值之差除以标准差。
6. 根据检验统计量,查找相应的临界值表,确定显著性水平。
7. 判断两组或多组数据是否存在显著差异。
五、实验结果与分析1. 实验数据实验数据如下:组别1:[12, 15, 18, 20, 22]组别2:[10, 14, 17, 19, 21]2. 排序及秩和计算对两组数据进行排序,得到以下结果:组别1:[22, 20, 18, 15, 12]组别2:[21, 19, 17, 14, 10]计算秩和:组别1秩和 = 22 + 20 + 18 + 15 + 12 = 87组别2秩和 = 21 + 19 + 17 + 14 + 10 = 883. 检验统计量计算计算各组秩和的平均值和标准差:组别1平均值 = 87 / 5 = 17.4组别2平均值 = 88 / 5 = 17.6组别1标准差= √[(22-17.4)² + (20-17.4)² + (18-17.4)² + (15-17.4)² + (12-17.4)²] / 4 = 3.16组别2标准差= √[(21-17.6)² + (19-17.6)² + (17-17.6)² + (14-17.6)² + (10-17.6)²] / 4 = 3.16计算检验统计量:检验统计量 = (组别1平均值 - 组别2平均值) / 组别1标准差 = (17.4 - 17.6) / 3.16 = -0.01594. 判断显著性根据检验统计量,查找相应的临界值表,以显著性水平α=0.05为例,临界值为1.96。
顺序查找法实验报告
一、实验目的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)插值查找插值查找算法的基本思想是根据要查找的元素与线性表中元素的大小关系,估算出要查找的元素应该在大致的位置,然后从这个位置开始进行查找。
2. 排序算法本次实验涉及以下排序算法:冒泡排序、选择排序、插入排序、快速排序。
(1)冒泡排序冒泡排序算法的基本思想是通过比较相邻的元素,将较大的元素交换到后面,较小的元素交换到前面,直到整个线性表有序。
(2)选择排序选择排序算法的基本思想是在未排序的序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
(3)插入排序插入排序算法的基本思想是将一个记录插入到已排好序的有序表中,从而得到一个新的、记录数增加1的有序表。
(4)快速排序快速排序算法的基本思想是选择一个元素作为基准元素,将线性表分为两个子表,一个子表中所有元素均小于基准元素,另一个子表中所有元素均大于基准元素,然后递归地对两个子表进行快速排序。
三、实验结果与分析1. 查找算法通过实验,我们发现:(1)顺序查找算法的时间复杂度为O(n),适用于数据量较小的线性表。
排序查找实验报告
排序查找实验报告排序查找实验报告一、引言排序和查找是计算机科学中非常重要的基础算法。
排序算法可以将一组无序的数据按照某种规则重新排列,而查找算法则可以在大量数据中快速找到目标元素。
本实验旨在通过实际操作和观察,对比不同的排序和查找算法的性能和效果,以便更好地理解和应用这些算法。
二、实验目的本实验的主要目的有以下几点:1. 理解不同排序算法的原理和特点;2. 掌握不同排序算法的实现方法;3. 比较不同排序算法之间的性能差异;4. 理解不同查找算法的原理和特点;5. 掌握不同查找算法的实现方法;6. 比较不同查找算法之间的性能差异。
三、实验过程1. 排序算法实验在排序算法实验中,我们选择了冒泡排序、选择排序和快速排序三种常见的排序算法进行比较。
首先,我们编写了一个随机生成一组无序数据的函数,并将其作为排序算法的输入。
然后,分别使用冒泡排序、选择排序和快速排序对这组数据进行排序,并记录下每种算法的执行时间。
最后,我们比较了三种算法的执行效率和排序结果的准确性。
2. 查找算法实验在查找算法实验中,我们选择了顺序查找、二分查找和哈希查找三种常见的查找算法进行比较。
首先,我们编写了一个生成有序数据的函数,并将其作为查找算法的输入。
然后,分别使用顺序查找、二分查找和哈希查找对这组数据进行查找,并记录下每种算法的执行时间。
最后,我们比较了三种算法的执行效率和查找结果的准确性。
四、实验结果1. 排序算法实验结果经过实验比较,我们发现快速排序算法在大多数情况下具有最好的性能表现,其平均时间复杂度为O(nlogn)。
冒泡排序算法虽然简单,但其时间复杂度为O(n^2),在数据量较大时效率较低。
选择排序算法的时间复杂度也为O(n^2),但相对于冒泡排序,其交换次数较少,因此效率稍高。
2. 查找算法实验结果顺序查找算法是最简单的一种查找算法,其时间复杂度为O(n),适用于小规模数据的查找。
二分查找算法的时间复杂度为O(logn),适用于有序数据的查找。
查找和排序 实验报告
查找和排序实验报告查找和排序实验报告一、引言查找和排序是计算机科学中非常重要的基础算法之一。
查找(Search)是指在一组数据中寻找目标元素的过程,而排序(Sort)则是将一组数据按照特定的规则进行排列的过程。
本实验旨在通过实际操作和实验验证,深入理解查找和排序算法的原理和应用。
二、查找算法实验1. 顺序查找顺序查找是最简单的查找算法之一,它的基本思想是逐个比较待查找元素与数据集合中的元素,直到找到目标元素或遍历完整个数据集合。
在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用顺序查找算法查找指定的目标元素。
实验结果显示,顺序查找的时间复杂度为O(n)。
2. 二分查找二分查找是一种高效的查找算法,它要求待查找的数据集合必须是有序的。
二分查找的基本思想是通过不断缩小查找范围,将待查找元素与中间元素进行比较,从而确定目标元素的位置。
在本实验中,我们首先对数据集合进行排序,然后使用二分查找算法查找指定的目标元素。
实验结果显示,二分查找的时间复杂度为O(log n)。
三、排序算法实验1. 冒泡排序冒泡排序是一种简单但低效的排序算法,它的基本思想是通过相邻元素的比较和交换,将较大(或较小)的元素逐渐“冒泡”到数列的一端。
在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用冒泡排序算法对其进行排序。
实验结果显示,冒泡排序的时间复杂度为O(n^2)。
2. 插入排序插入排序是一种简单且高效的排序算法,它的基本思想是将数据集合分为已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的适当位置。
在本实验中,我们使用插入排序算法对包含1000个随机整数的数据集合进行排序。
实验结果显示,插入排序的时间复杂度为O(n^2)。
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)。
查找排序实验报告
查找、排序实验班级学号姓名一、实验目的1 掌握不同的查找和排序方法,并能用高级语言实现相应算法。
2 熟练掌握顺序查找和二分查找方法。
3 熟练掌握直接插入排序、选择排序、冒泡排序、快速排序。
二、实验内容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 使用直接插入排序方法,对学生信息中的姓名进行排序。
输出排序前和排序后的学生信息表,验证排序结果。
5 使用选择排序方法,对学生信息中的C成绩进行排序。
输出排序前和排序后的学生信息表,验证排序结果。
6 使用冒泡排序方法,对学生信息中的数据结构成绩进行排序。
输出排序前和排序后的学生信息表,验证排序结果。
7 编写一个主函数,将上面函数连在一起,构成一个完整程序。
8 调试实验源程序并运行。
三、实验结果源程序代码:#include <iostream> using namespace std; #include <string>#include <iomanip> #define M 100 typedef string Keytype; typedef struct{Keytype classNum;Keytype name;int studentNum;int C;int structure;}Student;typedef struct{Student s[M];int length;}s_t;int creat(s_t *t,int Num){int i;t->length=Num;for(i=1;i<=t->length;i++){cout<<"请输入第"<<i<<"个学生的信息(学号,姓名,班级,C++,数据结构):"<<endl;cin>>t->s[i].studentNum>>t->s[i].n ame>>t->s[i].classNum>>t->s[i].C>>t->s [i].structure;}return 0;}int print(s_t *t){int i;cout<<" "<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构"<<" "<<endl;for(i=1;i<=t->length;i++){cout<<" "<<t->s[i].studentNum<<""<<t->s[i].name<<""<<t->s[i].classNum<<""<<t->s[i].C<<""<<t->s[i].structure<<" "<<endl;}return 0;}int S_Search(s_t *t,Keytype kx){int i;t->s[0].name=kx;for(i=t->length;i>=0;i--)if(t->s[i].name==kx)return i;}void InserSort(s_t *t){int i;for(i=2;i<=t->length;i++)if(t->s[i].name<t->s[i-1].name){t->s[0]=t->s[i];for(intj=i-1;t->s[0].name<t->s[j].name;j--)t->s[j+1]=t->s[j];t->s[j+1]=t->s[0];}}int Select_Sort(s_t *t){int i,j,k;for(i=0;i<t->length;i++){k=i;for(j=i+1;j<=t->length;j++)if(t->s[k].C>t->s[j].C)k=j;if(i!=k){t->s[0]=t->s[k];t->s[k]=t->s[i];t->s[i]=t->s[0];}}return 0;}int Half_Sort(s_t *t,int num){int flag=0;int low,high,mid;low=1;high=t->length;while(low<=high){mid=(low+high)/2;if(t->s[mid].studentNum>num)high=mid-1;elseif(t->s[mid].studentNum<num)low=mid+1;else{flag=mid;break;}}return flag;}int Bu_Sort(s_t *t){int i,j,swap;for(i=1;i<t->length;i++){swap=0;for(j=1;j<=t->length-i;j++)if(t->s[j].structure>t->s[j+1].structur e){t->s[0]=t->s[j];t->s[j]=t->s[j+1];t->s[j+1]=t->s[0];swap=1;}if(swap==0)break;}return 0;}int Partition(s_t *t,int i,int j){t->s[0]=t->s[i];while(i<j){while(i<j&&t->s[j].studentNum>=t->s[0] .studentNum)j--;if(i<j){t->s[i]=t->s[j];i++;}while(i<j&&t->s[i].studentNum<t->s[0].stude ntNum)i++;if(i<j){t->s[j]=t->s[i];j--;}}t->s[i]=t->s[0];return i;}void Quick_sort(s_t *t,int s,int p){int i;if(s<p){i=Partition(t,s,p);Quick_sort(t,s,i-1);Quick_sort(t,i+1,p);}}void Quick(s_t *t,int n){Quick_sort(t,1,n);}int main(){s_t *t;int i,n,n1,Num;int flag=1;Keytype kx;t=new s_t;cout<<" *********欢迎进入学生管理系统************** "<<endl;cout<<" 1 按姓名顺序查找2 输出所有学生信息 3 直接插入排序"<<endl;cout<<" 4 按C++选择排序5 按学号二分查找 6 按数据结构冒泡排序"<<endl;cout<<" 7 按学号快速排序8 建立学生的信息0 退出程序"<<endl;cout<<"********************************* *********** "<<endl;while(flag){cout<<"请选择要进行的操作:";cin>>n;switch(n){case 1:cout<<"请输入要查找的学生的姓名:"<<endl;cin>>kx;i=S_Search(t,kx);if(i){cout<<" "<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构"<<" "<<endl;cout<<""<<t->s[i].studentNum<<""<<t->s[i].name<<""<<t->s[i].classNum<<""<<t->s[i].C<<""<<t->s[i].structure<<" "<<endl;cout<<endl;}else cout<<"没有此人!"<<endl;break;case 2:cout<<"输出现在学生的全部信息:"<<endl;print(t);break;case 3:cout<<"直接插入排序:"<<endl;cout<<"排序前的学生信息"<<endl;print(t);cout<<"排序后的学生信息"<<endl;InserSort(t);print(t);break;case 4:cout<<"选择排序:"<<endl;cout<<"排序前的学生信息"<<endl;print(t);Select_Sort(t);cout<<"排序后的学生信息"<<endl;print(t);break;case 5:Select_Sort(t);cout<<"输入要查找的学号"<<endl;cin>>n1;i=Half_Sort(t,n1);if(i){cout<<" "<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构"<<" "<<endl;cout<<""<<t->s[i].studentNum<<""<<t->s[i].name<<""<<t->s[i].classNum<<""<<t->s[i].C<<""<<t->s[i].structure<<" "<<endl;cout<<endl;}else cout<<"不存在此学号!"<<endl;break;case 6:cout<<"冒泡排序"<<endl;cout<<"排序前的学生信息"<<endl;print(t);Bu_Sort(t);cout<<"排序后的学生信息"<<endl;print(t);break;case 7:cout<<""<<endl;print(t);cout<<""<<endl;Quick(t ,Num);print(t);break;case 8:cout<<"请输入学生的个数:";cin>>Num;creat(t,Num);break;case 0: return 0;default:cout<<"没有此功能,请选择正确的操作!"<<endl;break;}}return 0;} else cout<<"没人得此成绩!"<<endl;break;case 6:Bu_Sort(t);print(t);break;case 7:Quick(t ,Num);break;case 8:cout<<"请输入学生的个数:";cin>>Num;creat(t,Num);break;case 0: return 0;default:cout<<"没有此功能,请选择正确的操作!"<<endl;break;}}return 0;}运行结果:表1 输入学生信息表2 顺序查找方法表3 按姓名直接插入表4 按C成绩选择排序表5 按学号进行二分法查找表6 按数据结构成绩进行冒泡法排序四、实验总结(1)直接插入排序时,要明确后移的结束条件,以便进行正确插入。
查找与排序实验报告
查找与排序实验报告《查找与排序实验报告》摘要:本实验旨在通过不同的查找与排序算法对比分析它们的效率和性能。
我们使用了常见的查找算法包括线性查找、二分查找和哈希查找,以及排序算法包括冒泡排序、快速排序和归并排序。
通过实验数据的对比分析,我们得出了每种算法的优缺点和适用场景,为实际应用提供了参考依据。
1. 实验目的通过实验对比不同查找与排序算法的性能,分析它们的优缺点和适用场景。
2. 实验方法(1)查找算法实验:分别使用线性查找、二分查找和哈希查找算法,对含有一定数量元素的数组进行查找操作,并记录比较次数和查找时间。
(2)排序算法实验:分别使用冒泡排序、快速排序和归并排序算法,对含有一定数量元素的数组进行排序操作,并记录比较次数和排序时间。
3. 实验结果(1)查找算法实验结果表明,二分查找在有序数组中的查找效率最高,哈希查找在大规模数据中的查找效率最高。
(2)排序算法实验结果表明,快速排序在平均情况下的排序效率最高,归并排序在最坏情况下的排序效率最高。
4. 实验分析通过实验数据的对比分析,我们得出了以下结论:(1)查找算法:二分查找适用于有序数组的查找,哈希查找适用于大规模数据的查找。
(2)排序算法:快速排序适用于平均情况下的排序,归并排序适用于最坏情况下的排序。
5. 结论不同的查找与排序算法在不同的场景下有着不同的性能表现,选择合适的算法可以提高程序的效率和性能。
本实验为实际应用提供了参考依据,对算法的选择和优化具有一定的指导意义。
通过本次实验,我们深入了解了不同查找与排序算法的原理和性能,为今后的算法设计和优化工作提供了宝贵的经验和参考。
数据结构中查找和排序算法实验报告
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)
通过本次实验,我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候,需要我把理论变为上机调试,这无疑是最难的部分,有时候我想不到合适的算法去解决问题,就请教同学,上网搜索,逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高,以前我很不懂这门课,觉得它很难,但是现在明白了一些代码的应用,明白了每个程序都有相似的特点,通用的结构,也学会了静下心来写程序。我以后还要把没学好的知识点补齐,克服编程过程中的难关,打实基础,向更深入的层次发展。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《编程实训》实验报告书专业:计算机科学与技术班级:151班学号:姓名:指导教师:日期:2016年6月30日目录一、需求分析 (3)1.任务要求 (3)2.软件功能分析 (3)3.数据准备 (3)二、概要设计 (3)1.功能模块图 (4)2.模块间调用关系 (4)3.主程序模块 (5)4.抽象数据类型描述 (5)三、详细设计 (6)1.存储结构定义 (6)2.各功能模块的详细设计 (7)四、实现和调试 (7)1.主要的算法 (7)2.主要问题及解决 (8)3.测试执行及结果 (8)五、改进 (9)六、附录 (9)1.查找源程序 (9)2.排序源程序 (9)目录1 需求分析1.1 任务要求对于从键盘随机输入的一个序列的数据,存入计算机内,给出各种查找算法的实现;以及各种排序算法的实现。
1.2 软件功能分析任意输入n个正整数,该程序可以实现各类查找及排序的功能并将结果输出。
1.3 数据准备任意输入了5个正整数如下:12 23 45 56 782 概要设计(如果2,3合并可以省略2.4)2.1 功能模块图(注:含功能说明)2.2 模块间调用关系2.3 主程序模块2.4 抽象数据类型描述存储结构:数据结构在计算机中的表示(也称映像)叫做物理结构。
又称为存储结构。
数据类型(data type)是一个“值”的集合和定义在此集合上的一组操作的总称。
3 详细设计3.1 存储结构定义查找:typedef int ElemType ;//顺序存储结构typedef struct{ElemType *elem; //数据元素存储空间基址,建表时按实际长度分配,号单元留空int length; //表的长度}SSTable;排序:typedef struct{ //定义记录类型int key; //关键字项}RecType;typedef RecType SeqList[Max+1]; //SeqList为顺序表,表中第0个元素作为哨兵3.2 各功能模块的详细设计查找:void Create(SSTable *table, int length); // 构建顺序表void FillTable(SSTable *table) // 无序表的输入int Search_Seq(SSTable *table, ElemType key); //哨兵查找算法void Sort(SSTable *table ) // 排序算法int Search_Bin(SSTable *table, ElemType key) // 二分法查找(非递归)排序:void InsertSort(SeqList R) //对顺序表R中的记录R[1‥n]按递增序进行插入排序void BubbleSort(SeqList R)//自下向上扫描对R做冒泡排序int Partition(SeqList R,int i,int j)//对R[i‥j]做一次划分,并返回基准记录的位置void QuickSort(SeqList R,int low,int high) //R[low..high]快速排序void SelectSort(SeqList R) //直接选择排序void Heapify(SeqList R,int low,int high) //大根堆调整函数void MergePass(SeqList R,int length) //归并排序4 实现和调试4.1 主要的算法查找:①建立顺序存储结构,构建一个顺序表,实现顺序查找算法。
typedef struct {ElemType *elem; //数据元素存储空间基址,建表时按实际长度分配,号单元留空int length; //表的长度} SSTable;②对顺序表先排序后,实现行二分法查找相关操作。
③定义二叉树节点,根据节点的值进行查找,并且实现节点的插入,删除等操作。
typedef struct BiTnode { //定义二叉树节点int data; //节点的值struct BiTnode *lchild,*rchild;}BiTnode,*BiTree;④定义哈希表以及要查找的节点元素,创建哈希表,实现其相关查找操作。
typedef struct {int num;} Elemtype; //定义查找的结点元素typedef struct {Elemtype *elem; //数据元素存储基址int count; //数据元素个数int sizeindex;}HashTable;//定义哈希表排序:2. 排序相关实验内容及步骤。
①定义记录类型。
typedef struct{int key; //关键字项}RecType;②实现直接插入排序:每次将一个待排序的记录,按其关键字大小插入到前面已排序好的子文件中的适当位置,直到全部记录插入完成为止。
③实现冒泡排序:设想被排序的记录数组R[1‥n]垂直排序。
根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R,凡扫描到违反本原则的轻气泡,就使其向上“漂浮”(交换),如此反复进行,直到最后任意两个气泡都是轻者在上,重者在下为止。
④实现快速排序:在待排序的n个记录中任取一个记录(通常取第一个记录),把该记录作为支点(又称基准记录)(pivot),将所有关键字比它小的记录放置在它的位置之前,将所有关键字比它大的记录放置在它的位置之后(称之为一次划分过程)。
之后对所分的两部分分别重复上述过程,直到每部分只有一个记录为止。
⑤实现直接选择排序:第i趟排序开始时,当前有序区和无序区分别为R[1‥i-1]和R[i‥n](1≤i≤n-1),该趟排序则是从当前无序区中选择出关键字最小的记录R[k],将它与无序区的的第一个记录R[i]交换,有序区增加一个记录,使R[1‥i],和R[i+1‥n]分别为新的有序区和新的无序区。
如此反复进行,直到排序完毕。
⑥实现堆排序:它是一种树型选择排序,特点是:在排序的过程中,将R[1‥n]看成是一个完全二叉树的顺序存储结构,利用完全二叉树中双亲结点和孩子结点之间的内在关系,在当前无序区中选择关键字最大(或最小)的记录。
即:把待排序文件的关键字存放在数组R[1‥n]子中,将R看成是一棵二叉树,每个结点表示一个记录,源文件的第一个记录R[1]作为二叉树的根,以下各记录R[2‥n]依次逐层从左到右排列,构成一棵完全二叉树,任意结点R[i]的左孩子是R[2i],右孩子是R[2i+1],双亲是R[i/2]。
⑦实现二路归并排序:假设初始序列n个记录,则可看成是n个有序的子序列,每个子序列的长度为1,然后两两归并,得到[n/2]个长度为2或1的有序子序列;再两两归并,……,如此重复,直到一个长度为n的有序序列为止。
4.2 主要问题及解决在实验前对于各种查找和排序的算法不是很熟悉,所以花了一些时间去复习。
有些代码反复测试还是找不出错误,最后也是翻阅了书本并仔细思考才改进了算法并成功测试出了结果。
这次试验大大提升了我对排序算法及查找算法的熟练程度。
4.3 测试执行及结果查找算法:任意输入若干正整数并测试如下:排序算法:任意输入数字并测试如下:5 改进根据提示的代码,经过一系列调试后最终出了结果。
在一开始运行时总是出错,特别是二叉树的测试,代码有些小错误导致测试的时候程序总是出错。
最后改动了一下提高了程序的稳定性并成功运行出了结果。
6 附录【附录1----查找源程序】#include"iostream"#include"stdlib.h"#include"stdio.h"#include "malloc.h"#define MAX 11using namespace std;typedef int ElemType ;//顺序存储结构typedef struct{ElemType *elem; //数据元素存储空间基址,建表时按实际长度分配,号单元留空int length; //表的长度}SSTable;void Create(SSTable *table, int length);void Destroy(SSTable *table);int Search_Seq(SSTable *table, ElemType key);void Traverse(SSTable *table, void (*visit)(ElemType elem));void Create(SSTable **table, int length) // 构建顺序表{SSTable *t = (SSTable*) malloc(sizeof(SSTable));//分配空间t->elem=(ElemType*)malloc(sizeof(ElemType)*(length+1));t->length=length;*table=t;}void FillTable(SSTable *table) // 无序表的输入{ElemType *t=table->elem;for(int i=0; i<table->length; i++) //for循环,输入各个元素{t++;scanf("%d", t); //输入元素getchar();}}void Destroy(SSTable *table) // 销毁表{free(table->elem);//释放元素空间free(table);//释放表的空间}void PrintTable(SSTable *table) // 打印查找表{int i; //定义变量ElemType *t=table->elem;for(i=0; i<table->length; i++) //进入循环,依次打印表中元素{t++;printf("%d ", *t); //打印输出}printf("\n");}int Search_Seq(SSTable *table, ElemType key) //哨兵查找算法{table->elem[0]=key; //设置哨兵int result=0; // 找不到时,返回int i;for (i=table->length; i>=1;i--){if (table->elem[i]==key){result=i;break;}}return result; //返回结果}void printSeq(){SSTable *table; //先设置几个变量int r;int n;ElemType key;printf("请输入元素个数:");scanf("%d",&n); //输入元素个数Create(&table, n); //建立表printf("请输入");cout<<n;printf("个值:");FillTable(table); //输入无序表的值printf("您输入的%d 个值是:\n",n);PrintTable(table); //打印无序表printf("请输入关键字的值:");scanf("%d",&key);printf("\n");printf("顺序查找法运行结果如下:\n\n ");Search_Seq(table,key); //哨兵查找算法r=Search_Seq(table,key);if(r>0){printf(" 关键字%d 在表中的位置是:%d\n",key, r);//打印关键字在表中的位置printf("\n");}else //查找失败{printf ("查找失败,表中无此数据。