查找和排序算法的实现(实验七)
(完整word版)数据结构查找算法实验报告
![(完整word版)数据结构查找算法实验报告](https://img.taocdn.com/s3/m/9ea33a0c31126edb6f1a10ec.png)
数据结构实验报告实验第四章:实验: 简单查找算法一.需求和规格说明:查找算法这里主要使用了顺序查找,折半查找,二叉排序树查找和哈希表查找四种方法。
由于自己能力有限,本想实现其他算法,但没有实现。
其中顺序查找相对比较简单,折半查找参考了书上的算法,二叉排序树查找由于有之前做二叉树的经验,因此实现的较为顺利,哈希表感觉做的并不成功,感觉还是应该可以进一步完善,应该说还有很大的改进余地。
二.设计思想:开始的时候提示输入一组数据。
并存入一维数组中,接下来调用一系列查找算法对其进行处理。
顺序查找只是从头到尾进行遍历。
二分查找则是先对数据进行排序,然后利用三个标志,分别指向最大,中间和最小数据,接下来根据待查找数据和中间数据的比较不断移动标志,直至找到。
二叉排序树则是先构造,构造部分花费最多的精力,比根节点数据大的结点放入根节点的右子树,比根节点数据小的放入根节点的左子树,其实完全可以利用递归实现,这里使用的循环来实现的,感觉这里可以尝试用递归。
当二叉树建好后,中序遍历序列即为由小到大的有序序列,查找次数不会超过二叉树的深度。
这里还使用了广义表输出二叉树,以使得更直观。
哈希表则是利用给定的函数式建立索引,方便查找。
三.设计表示:四.实现注释:其实查找排序这部分和前面的一些知识联系的比较紧密,例如顺序表的建立和实现,顺序表节点的排序,二叉树的生成和遍历,这里主要是中序遍历。
应该说有些知识点较为熟悉,但在实现的时候并不是那么顺利。
在查找到数据的时候要想办法输出查找过程的相关信息,并统计。
这里顺序查找和折半查找均使用了数组存储的顺序表,而二叉树则是采用了链表存储的树形结构。
为了直观起见,在用户输入了数据后,分别输出已经生成的数组和树。
折半查找由于只能查找有序表,因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计。
二叉排序树应该说由于有了之前二叉树的基础,并没有费太大力气,主要是在构造二叉树的时候,要对新加入的节点数据和跟数据进行比较,如果比根节点数据大则放在右子树里,如果比根节点数据小则放入左子树。
实验报告-排序与查找
![实验报告-排序与查找](https://img.taocdn.com/s3/m/24ab3931011ca300a6c390f7.png)
电子科技大学实验报告课程名称:数据结构与算法学生姓名:学号:点名序号:指导教师:实验地点:基础实验大楼实验时间: 5月20日2014-2015-2学期信息与软件工程学院实验报告(二)学生姓名学号:指导教师:实验地点:基础实验大楼实验时间:5月20日一、实验室名称:软件实验室二、实验项目名称:数据结构与算法—排序与查找三、实验学时:4四、实验原理:快速排序的基本思想是:通过一躺排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一不部分的所有数据都要小,然后再按次方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
假设要排序的数组是A[1]……A[N],首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一躺快速排序。
一躺快速排序的算法是:1)设置两个变量I、J,排序开始的时候I:=1,J:=N2)以第一个数组元素作为关键数据,赋值给X,即X:=A[1];3)从J开始向前搜索,即(J:=J-1),找到第一个小于X的值,两者交换;4)从I开始向后搜索,即(I:=I+1),找到第一个大于X的值,两者交换;5)重复第3、4步,直到I=J。
二分法查找(折半查找)的基本思想:(1)确定该区间的中点位置:mid=(low+high)/2min代表区间中间的结点的位置,low代表区间最左结点位置,high代表区间最右结点位置(2)将待查a值与结点mid的关键字(下面用R[mid].key)比较,若相等,则查找成功,否则确定新的查找区间:A)如果R[mid].key>a,则由表的有序性可知,R[mid].key右侧的值都大于a,所以等于a的关键字如果存在,必然在R[mid].key左边的表中,这时high=mid-1;B)如果R[mid].key<a,则等于a的关键字如果存在,必然在R[mid].key右边的表中。
查找和排序实验报告
![查找和排序实验报告](https://img.taocdn.com/s3/m/11cc220203d8ce2f00662340.png)
查找和排序1.需求分析1.编写一个程序输出在顺序表{3,6,2,10,1,8,5,7,4,9}中采用顺序方法查找关键字5的过程;2.编写一个程序输出在顺序表{1,2,3,4,5,6,7,8,9,10}中采用顺序方法查找关键字9的过程;3.编写一个程序实现直接插入排序算法,并输出{9,8,7,6,5,4,3,2,1,0}的排序过程;4.编写一个程序实现快速排序算法,并输出{6,8,7,9,0,1,3,2,4,5}的排序过程2.系统设计1.静态查找表的抽象数据类型定义:ADT StaticSearchTable{数据对象D:D是具有相同特性的数据元素的集合。
各个数据元素均含有类型相同,可惟一标识数据元素的关键字数据关系R:数据元素同属一个集合基本操作P:Create(&ST,n)操作结果:构造一个含n个数据元素的静态查找表STDestroy(&ST)初始条件:静态查找表ST存在操作结果:销毁表STSearch(ST,key)初始条件:静态查找表ST存在,key为和关键字类型相同的给定值操作结果:若ST中存在其关键字等于key的数据元素,则函数值为该元素的值或在表中的位置,否则为“空”Traverse(ST,V isit())初始条件:静态查找表ST存在,Visit是对元素操作的应用函数操作结果:按某种次序对ST的每个元素调用函数Visit()一次且仅一次。
一旦Visit()失败,则操作失败}ADT StaticSearchTable3.调试分析(1)要在适当的位置调用Print函数,以正确显示排序过程中顺序表的变化(2)算法的时间复杂度分析:顺序查找:T(n)=O(n)折半查找:T(n)=O(logn)直接插入排序:T(n)=O(n2)快速排序:T(n)=O(nlogn)4.测试结果用需求分析中的测试数据顺序查找:顺序表3,6,2,10,1,8,5,7,4,9,查找5折半查找:顺序表1,2,3,4,5,6,7,8,9,10,查找9直接插入排序:顺序表9,8,7,6,5,4,3,2,1,0,从小到大排序快速排序:顺序表6,8,7,9,0,1,3,2,4,5,从小到大排序5.用户手册(1)输入表长;(2)依次输入建立顺序表;(3)查找:输入要查找的关键字(4)回车输出,查找为下标的移动过程;排序为顺序表的变化过程6.附录源程序:(1)顺序查找#include <stdio.h>#include <stdlib.h>#define ST_INIT_SIZE 200#define EQ(a,b) ((a)==(b))#define OVERFLOW -2typedef int KeyType;typedef struct{KeyType key;}ElemType;typedef struct{ElemType *elem;//数据元素存储空间基址,建表时按实际长度分配,0号单元留空int length;//表长度}SSTable;void InitST(SSTable &ST){ST.elem=(ElemType*)malloc(ST_INIT_SIZE*sizeof(ElemType));if(!ST.elem)exit(OVERFLOW);ST.length=0;}void CreateST(SSTable &ST){int i;printf("输入表长:");scanf("%d",&ST.length);for(i=1;i<=ST.length;i++)scanf("%d",&ST.elem[i].key);}void PrintST(SSTable ST){int i;for(i=1;i<=ST.length;i++)printf("%2d",ST.elem[i].key);printf("\n");}int Search_Seq(SSTable ST,KeyType key){//在顺序表ST中顺序查找其关键字等于key的数据元素//若找到则函数值为该元素在表中的位置,否则为0int i;ST.elem[0].key=key;printf("下标:");for(i=ST.length;!EQ(ST.elem[i].key,key);--i)printf("%d→",i);//从后往前找return i;}void main(){SSTable ST;KeyType key;InitST(ST);CreateST(ST);printf("顺序查找表:");PrintST(ST);printf("输入要查找的关键字:");scanf("%d",&key);int found=Search_Seq(ST,key);if(found)printf("找到,为第%d个数据\n",found);else printf("没有找到!\n");}(2)折半查找#include <stdio.h>#include <stdlib.h>#define ST_INIT_SIZE 200#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))#define OVERFLOW -2typedef int KeyType;typedef struct{KeyType key;}ElemType;typedef struct{ElemType *elem;//数据元素存储空间基址,建表时按实际长度分配,0号单元留空int length;//表长度}SSTable;void InitST(SSTable &ST){ST.elem=(ElemType*)malloc(ST_INIT_SIZE*sizeof(ElemType));if(!ST.elem)exit(OVERFLOW);ST.length=0;}void CreateST(SSTable &ST){int i;printf("输入表长:");scanf("%d",&ST.length);for(i=1;i<=ST.length;i++)scanf("%d",&ST.elem[i].key);}void PrintST(SSTable ST){int i;for(i=1;i<=ST.length;i++)printf("%2d",ST.elem[i].key);printf("\n");}int Search_Bin(SSTable ST,KeyType key){//在有序表ST中折半查找其关键字等于key的数据元素//若找到,则函数值为该元素在表中的位置,否则为0int low,high,mid;low=1;high=ST.length;//置区间初值printf("下标:");while(low<=high){mid=(low+high)/2;printf("%d→",mid);if(EQ(key,ST.elem[mid].key))return mid;//找到待查元素else if(LT(key,ST.elem[mid].key))high=mid-1;//继续在前半区间进行查找else low=mid+1;}return 0;//顺序表中不存在待查元素}void main(){SSTable ST;KeyType key;InitST(ST);CreateST(ST);printf("顺序查找表:");PrintST(ST);printf("输入要查找的关键字:");scanf("%d",&key);int found=Search_Bin(ST,key);if(found)printf("找到,为第%d个数据\n",found);else printf("没有找到!\n");}(3)直接插入排序#include <stdio.h>#define MAXSIZE 20#define LT(a,b) ((a)<(b))typedef int KeyType;typedef struct{KeyType key;}RedType;//记录类型typedef struct{RedType r[MAXSIZE+1];//r[0]闲置或用作哨兵单元int length;//顺序表长度}SqList;//顺序表类型void CreateSq(SqList &L){int i;printf("输入表长:");scanf("%d",&L.length);for(i=1;i<=L.length;i++)scanf("%d",&L.r[i].key);}void PrintSq(SqList L){int i;for(i=1;i<=L.length;i++)printf("%2d",L.r[i].key);printf("\n");}void InsertSort(SqList &L){//对顺序表L作直接插入排序int i,j;printf("排序过程:\n");for(i=2;i<=L.length;++i){if(LT(L.r[i].key,L.r[i-1].key)){//"<",需将L.r[i]插入有序子表L.r[0]=L.r[i];//复制为哨兵L.r[i]=L.r[i-1];for(j=i-2;LT(L.r[0].key,L.r[j].key);--j)L.r[j+1]=L.r[j];//记录后移L.r[j+1]=L.r[0];//插入到正确位置}PrintSq(L);}}//InsertSortvoid main(){SqList L;CreateSq(L);printf("原始顺序表:");PrintSq(L);InsertSort(L);printf("排序后的顺序表:");PrintSq(L);}(4)快速排序#include <stdio.h>#define MAXSIZE 20typedef int KeyType;typedef struct{KeyType key;}RedType;//记录类型typedef struct{RedType r[MAXSIZE+1];//r[0]闲置或用作哨兵单元int length;//顺序表长度}SqList;//顺序表类型void CreateSq(SqList &L){int i;printf("输入表长:");scanf("%d",&L.length);for(i=1;i<=L.length;i++)scanf("%d",&L.r[i].key);}void PrintSq(SqList L){int i;for(i=1;i<=L.length;i++)printf("%2d",L.r[i].key);printf("\n");}int Partition(SqList &L,int low,int high){//交换顺序表L中子表r[low…high]的记录,枢轴记录到位,并返回其所在位置, //此时在它之前/后的记录均不大/小于它int pivotkey;L.r[0]=L.r[low];//用子表的第一个记录作枢轴记录pivotkey=L.r[low].key;//枢轴记录关键字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];//枢轴记录到位PrintSq(L);return low;//返回枢轴位置}//Partitionvoid QSort(SqList &L,int low,int high){//对顺序表L中的子序列L.r[low…high]作快速排序int pivotloc;if(low<high){//长度大于1pivotloc=Partition(L,low,high);//将L.r[low…high]一分为二QSort(L,low,pivotloc-1);//对低子表递归排序,pivotloc是枢轴位置QSort(L,pivotloc+1,high);//对高子表递归排序}}//QSortvoid QuickSort(SqList &L){//对顺序表L作快速排序printf("排序过程:\n");QSort(L,1,L.length);}//QuickSortvoid main(){SqList L;CreateSq(L);printf("原始顺序表:");PrintSq(L);QuickSort(L);printf("快速排序后的顺序表:");PrintSq(L);}。
数据结构与算法实验报告5-查找与排序
![数据结构与算法实验报告5-查找与排序](https://img.taocdn.com/s3/m/1e7c4e20bf1e650e52ea551810a6f524ccbfcb8f.png)
北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。
在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。
查找排序实验报告
![查找排序实验报告](https://img.taocdn.com/s3/m/66eabb4558eef8c75fbfc77da26925c52cc591b2.png)
查找排序实验报告一、实验目的本次实验的主要目的是深入理解和比较不同的查找和排序算法在性能和效率方面的差异。
通过实际编程实现和测试,掌握常见查找排序算法的原理和应用场景,为今后在实际编程中能够选择合适的算法解决问题提供实践经验。
二、实验环境本次实验使用的编程语言为 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 语言实现上述六种查找排序算法,并分别封装成函数,以便后续调用和测试。
数据结构实验(6)查找和排序
![数据结构实验(6)查找和排序](https://img.taocdn.com/s3/m/8d63f9ccd5bbfd0a795673b1.png)
计算机系数据结构实验报告(x)姓名:陈科健学号:6100113017 专业班级:电子商务131 实验名称:查找和排序实验目的:深入了解各种内部排序方法及效率分析。
问题描述:各种内部排序算法的时间复杂度分析,试通过随机数据比较算法的关键字比较次数和关键字移动次数。
实验要求:1、对起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序这六种常用排序算法进行分析。
2、用代码实现上述算法中任意两种排序算法。
3、设计待排序表的表长不超过100(其中数据最好用伪随机数产生程序产生,也可以自己设计一组待排序数据)。
4、要对实验结果做简单分析。
算法分析:实验内容和过程:#include<stdio.h>#include<stdlib.h>typedef struct{int key;}Key;typedef struct{Key r[6];}SqList;void BubbleSort(int *a,int n){int i, j,t;for (i = 0; i < n - 1; i++){for (j = 0; j <n-i-1;j++){if (a[j]>a[j+1]){t = a[j];a[j] = a[j+1];a[j+1] = t;}}}for (i = 0; i < n ; i++){printf("%5d", a[i]);}}int Partition(SqList &L, int low, int high){int pivotkey;L.r[0] = L.r[low];pivotkey = L.r[low].key;while (low < high){while (low < high && L.r[high].key >= pivotkey) --high;L.r[low] = L.r[high];while (low < high && L.r[high].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);}}void QuickSort(SqList &L){int i;QSort(L,0,5);for (i = 0; i < 6; i++){printf("%5d", L.r[i].key);}}int main(){int i, a[6]; SqList L;printf(" ** 起泡排序**\n\n");printf("请输入6个数:\n");for (i = 0; i < 6; i++){scanf_s("%d", &a[i]);}printf("排序后:\n");BubbleSort(a, 6);printf("\n\n ** 快速排序**\n\n");printf("请输入6个数:\n");for (i = 0; i < 6; i++){scanf_s("%d", &L.r[i].key);}printf("排序后:\n");QuickSort(L);system("pause");}实验结果:总结和感想:起泡还好做。
查找、排序的应用 实验报告
![查找、排序的应用 实验报告](https://img.taocdn.com/s3/m/c73358df80eb6294dd886c28.png)
实验七查找、排序的应用一、实验目的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、插入排序每步将一个待排序的记录,按其关键码大小,插入到前面已经排好序的一组记录的适当位置上,直到记录全部插入为止。
常见算法设计实验报告(3篇)
![常见算法设计实验报告(3篇)](https://img.taocdn.com/s3/m/15d5e12f2f3f5727a5e9856a561252d381eb2016.png)
第1篇一、实验目的通过本次实验,掌握常见算法的设计原理、实现方法以及性能分析。
通过实际编程,加深对算法的理解,提高编程能力,并学会运用算法解决实际问题。
二、实验内容本次实验选择了以下常见算法进行设计和实现:1. 排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。
2. 查找算法:顺序查找、二分查找。
3. 图算法:深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)。
4. 动态规划算法:0-1背包问题。
三、实验原理1. 排序算法:排序算法的主要目的是将一组数据按照一定的顺序排列。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。
2. 查找算法:查找算法用于在数据集中查找特定的元素。
常见的查找算法包括顺序查找和二分查找。
3. 图算法:图算法用于处理图结构的数据。
常见的图算法包括深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)等。
4. 动态规划算法:动态规划算法是一种将复杂问题分解为子问题,通过求解子问题来求解原问题的算法。
常见的动态规划算法包括0-1背包问题。
四、实验过程1. 排序算法(1)冒泡排序:通过比较相邻元素,如果顺序错误则交换,重复此过程,直到没有需要交换的元素。
(2)选择排序:每次从剩余元素中选取最小(或最大)的元素,放到已排序序列的末尾。
(3)插入排序:将未排序的数据插入到已排序序列中适当的位置。
(4)快速排序:选择一个枢纽元素,将序列分为两部分,使左侧不大于枢纽,右侧不小于枢纽,然后递归地对两部分进行快速排序。
(5)归并排序:将序列分为两半,分别对两半进行归并排序,然后将排序好的两半合并。
(6)堆排序:将序列构建成最大堆,然后重复取出堆顶元素,并调整剩余元素,使剩余元素仍满足最大堆的性质。
2. 查找算法(1)顺序查找:从序列的第一个元素开始,依次比较,直到找到目标元素或遍历完整个序列。
实验七排序
![实验七排序](https://img.taocdn.com/s3/m/3692ea0bbb1aa8114431b90d6c85ec3a87c28b1e.png)
实验七排序
一、目的:
掌握各种排序方法的基本思想、排序过程、算法实现,能进行时间和
空间性能的分析,根据实际问题的特点和要求选择合适的排序方法。
二、
要求:
实现直接排序、冒泡、直接选择、快速、堆、归并排序算法。
比较各
种算法的运行速度。
三、实验内容
1、编写各种排序程序。
2、在排序程序中能输出以上各种排序算法的各趟排序结束时,关键
字序列的状态。
3、调试程序,以关键字序列(265,301,751,129,937,863,742,694,76,438)
作为输入数据,采用上述方法进行排序。
四、实验报告要求
要求所编的程序能正确运行,并提交实验报告。
实验报告的基本要求为:1、陈述程序设计的任务,强调程序要做什么,明确规定:(1)输入
的形式和输出值的范围;(2)输出的形式;
(3)程序所能达到的功能;
(4)测试数据:包括正确的输入输出结果和错误的输入及输出结果。
2、说明用到的数据结构定义、主程序的流程及各程序模块之间的调
用关系。
3、提交带注释的源程序或者用伪代码写出每个操作所涉及的算法。
4、调试分析:
(1)调试过程中所遇到的问题及解决方法;(2)算法的时空分析;(3)经验与体会。
5、用户使用说明:说明如何使用你的程序,详细列出每一步操作步骤。
6、测试结果:列出对于给定的输入所产生的输出结果。
排序实验报告
![排序实验报告](https://img.taocdn.com/s3/m/807cb3b50342a8956bec0975f46527d3240ca6cf.png)
实验五排序实验目的: 掌握几种排序的思想及算法问题分析:(一)直接插入排序1. 排序思想将待排序的记录Ri,插入到已排好序的记录表R1, R2 ,…., Ri-1中,得到一个新的、记录数增加1的有序表。
直到所有的记录都插入完为止。
设待排序的记录顺序存放在数组R[1…n]中,在排序的某一时刻,将记录序列分成两部分:◆R[1…i-1]:已排好序的有序部分;◆R[i…n]:未排好序的无序部分。
显然,在刚开始排序时,R[1]是已经排好序的。
2 . 算法实现void straight_insert_sort(Sqlist R){ int i, j ;for (i=2; i<=n; i++){ R[0]=R[i]; j=i-1; /*设置哨兵*/while( LT(R[0].key, R[j].key) ){ R[j+1]=R[j];j--;} /* 查找插入位置*/R[j+1]=R[0]; /* 插入到相应位置*/}}(二)希尔排序1. 排序思想①先取一个正整数d1(d1<n)作为第一个增量,将全部n个记录分成d1组,把所有相隔d1的记录放在一组中,即对于每个k(k=1, 2, … d1),R[k], R[d1+k], R[2d1+k] , …分在同一组中,在各组内进行直接插入排序。
这样一次分组和排序过程称为一趟希尔排序;②取新的增量d2<d1,重复①的分组和排序操作;直至所取的增量di=1为止,即所有记录放进一个组中排序为止。
2. 算法实现先给出一趟希尔排序的算法,类似直接插入排序。
void shell_pass(Sqlist R, int d)/* 对顺序表L进行一趟希尔排序, 增量为d */{ int j, k ;for (j=d+1; j<=n; j++){ R[0]=R[j] ; /* 设置监视哨兵*/k=j-d ;while (k>0&<(R[0].key, R[k].key) ){ R[k+d]=R[k] ; k=k-d ; }R[k+d]=R[0] ;}}然后在根据增量数组dk进行希尔排序。
实验1 查找与排序
![实验1 查找与排序](https://img.taocdn.com/s3/m/aedc134677232f60ddcca1c8.png)
实验1 查找与排序一、实验目的(1)掌握查找的问题描述,实现线性查找算法及二分查找算法;(2)熟悉排序的问题描述,实现插入排序算法。
二、实验内容1、线性查找算法#include <stdio.h>void main(){int a[101]; //定义数组a,设置其长度为101int i,n,num;printf("**************************************************\n");printf(" 顺序查找算法\n");printf("**************************************************\n\n");printf("您要在多少个数中进行线性查找,请输入(1~100):");___________________________; //输入一个数值赋给变量n,表示数列长度printf("\n");while(________________________) //如果输入的数据列表长度不在[1,100]之间{________________________________________________printf("您要在多少个数中进行线性查找,请输入(1~100):");________________________}printf("请您输入第1个整数a[1]:");scanf("%d",&a[1]);i=2;while(________________________){printf(_____________________________________________);________________________________________________}printf("\n输出数据列表:\n");for(________________________){printf("%6d",a[i]);}printf("\n\n");do{printf("请输入要查找的数:");_________________________; //输入一个整数赋给变量num,表示要查找的对象i=1;while(_________________________________________) //在数据列表内搜索num{i++;}if(________________________)printf("该表中没有您要查找的数据!\n");elseprintf(________________________________________________);} while (________________________); //若输入的待查找的数不是999,则可持续搜索。
《数据结构》实验报告三:几种查找算法的实现和比较
![《数据结构》实验报告三:几种查找算法的实现和比较](https://img.taocdn.com/s3/m/3860004758f5f61fb636660f.png)
第三次实验报告:几种查找算法的实现和比较//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;}}*/}。
查找排序实验报告总结
![查找排序实验报告总结](https://img.taocdn.com/s3/m/4ad376b418e8b8f67c1cfad6195f312b3169ebe4.png)
一、实验目的本次实验旨在通过编写程序实现查找和排序算法,掌握基本的查找和排序方法,了解不同算法的优缺点,提高编程能力和数据处理能力。
二、实验内容1. 查找算法本次实验涉及以下查找算法:顺序查找、二分查找、插值查找。
(1)顺序查找顺序查找算法的基本思想是从线性表的第一个元素开始,依次将线性表中的元素与要查找的元素进行比较,若找到相等的元素,则查找成功;若线性表中所有的元素都与要查找的元素进行了比较但都不相等,则查找失败。
(2)二分查找二分查找算法的基本思想是将待查找的元素与线性表中间位置的元素进行比较,若中间位置的元素正好是要查找的元素,则查找成功;若要查找的元素比中间位置的元素小,则在线性表的前半部分继续查找;若要查找的元素比中间位置的元素大,则在线性表的后半部分继续查找。
重复以上步骤,直到找到要查找的元素或查找失败。
(3)插值查找插值查找算法的基本思想是根据要查找的元素与线性表中元素的大小关系,估算出要查找的元素应该在大致的位置,然后从这个位置开始进行查找。
2. 排序算法本次实验涉及以下排序算法:冒泡排序、选择排序、插入排序、快速排序。
(1)冒泡排序冒泡排序算法的基本思想是通过比较相邻的元素,将较大的元素交换到后面,较小的元素交换到前面,直到整个线性表有序。
(2)选择排序选择排序算法的基本思想是在未排序的序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
(3)插入排序插入排序算法的基本思想是将一个记录插入到已排好序的有序表中,从而得到一个新的、记录数增加1的有序表。
(4)快速排序快速排序算法的基本思想是选择一个元素作为基准元素,将线性表分为两个子表,一个子表中所有元素均小于基准元素,另一个子表中所有元素均大于基准元素,然后递归地对两个子表进行快速排序。
三、实验结果与分析1. 查找算法通过实验,我们发现:(1)顺序查找算法的时间复杂度为O(n),适用于数据量较小的线性表。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
![数据结构c++顺序表、单链表的基本操作,查找、排序代码](https://img.taocdn.com/s3/m/1c7659c6ba0d4a7302763acf.png)
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
查找和排序 实验报告
![查找和排序 实验报告](https://img.taocdn.com/s3/m/ac67c99248649b6648d7c1c708a1284ac9500575.png)
查找和排序实验报告查找和排序实验报告一、引言查找和排序是计算机科学中非常重要的基础算法之一。
查找(Search)是指在一组数据中寻找目标元素的过程,而排序(Sort)则是将一组数据按照特定的规则进行排列的过程。
本实验旨在通过实际操作和实验验证,深入理解查找和排序算法的原理和应用。
二、查找算法实验1. 顺序查找顺序查找是最简单的查找算法之一,它的基本思想是逐个比较待查找元素与数据集合中的元素,直到找到目标元素或遍历完整个数据集合。
在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用顺序查找算法查找指定的目标元素。
实验结果显示,顺序查找的时间复杂度为O(n)。
2. 二分查找二分查找是一种高效的查找算法,它要求待查找的数据集合必须是有序的。
二分查找的基本思想是通过不断缩小查找范围,将待查找元素与中间元素进行比较,从而确定目标元素的位置。
在本实验中,我们首先对数据集合进行排序,然后使用二分查找算法查找指定的目标元素。
实验结果显示,二分查找的时间复杂度为O(log n)。
三、排序算法实验1. 冒泡排序冒泡排序是一种简单但低效的排序算法,它的基本思想是通过相邻元素的比较和交换,将较大(或较小)的元素逐渐“冒泡”到数列的一端。
在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用冒泡排序算法对其进行排序。
实验结果显示,冒泡排序的时间复杂度为O(n^2)。
2. 插入排序插入排序是一种简单且高效的排序算法,它的基本思想是将数据集合分为已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的适当位置。
在本实验中,我们使用插入排序算法对包含1000个随机整数的数据集合进行排序。
实验结果显示,插入排序的时间复杂度为O(n^2)。
3. 快速排序快速排序是一种高效的排序算法,它的基本思想是通过递归地将数据集合划分为较小和较大的两个子集合,然后对子集合进行排序,最后将排序好的子集合合并起来。
数据结构实验七-二分排序
![数据结构实验七-二分排序](https://img.taocdn.com/s3/m/ecc6cf60c5da50e2534d7f0a.png)
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++) {
实验6 查找和排序
![实验6 查找和排序](https://img.taocdn.com/s3/m/cb067379a26925c52cc5bfbb.png)
实验六、七:查找、排序算法的应用班级 10512 学号 20103051224 姓名苏晓菲一、实验目的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 使用直接插入排序方法,对学生信息中的姓名进行排序。
输出排序前和排序后的学生信息表,验证排序结果。
5 使用直接选择排序方法,对学生信息中的C成绩进行排序。
输出排序前和排序后的学生信息表,验证排序结果。
6 使用冒泡排序方法,对学生信息中的数据结构成绩进行排序。
输出排序前和排序后的学生信息表,验证排序结果。
7 编写一个主函数,将上面函数连在一起,构成一个完整程序。
8 将实验源程序调试并运行。
三、实验结果#include<iostream.h>#define maxsize 50typedef int KeyType;KeyType key;typedef struct{int number;int chengji1,chengji2;char name[20];char banji;}DataType;typedef struct{DataType data[maxsize];int len;}Seqlist;void InitSeqlist(Seqlist &L){L.len=0;}void CreateSeqlist(Seqlist &L){cout<<"请输入线性表的长度:";cin>>L.len;cout<<"请输入学生信息:"<<endl<<"学号姓名班级C++ 数据结构"<<endl;for(int i=0;i<L.len;i++){cin>>L.data[i].number>>L.data[i].name>>L.data[i].banji>>L.data[i].chengji1>>L .data[i].chengji2;}cout<<"当前学生信息为:"<<endl;for(int j=0;j<L.len;j++){cout<<L.data[j].number<<" "<<L.data[j].name<<" "<<L.data[j].banji<<" "<<L.data[j].chengji1<<" "<<L.data[j].chengji2;cout<<endl;}}//顺序查找方法void S_Search(SeqList L,char na[20]){int result;for(int i=1;i<=L.len;i++)result=strcmp(L.data[i].name,na);if(result==0){cout<<L.data[i].number<<" "<<L.data[i].name<<" "<<L.data[i].banji<<" "<<L.data[i].score1<<" "<<L.data[i].score2<<endl;break;}}if(i>L.len)cout<<"不存在该学生"<<endl;}//二分查找方法void Binary_Search(SeqList &L,int nu){ int low=1,high=L.len,mid;while(low<=high){mid=(low+high)/2;if(L.data[mid].number==nu){cout<<L.data[mid].number<<" "<<L.data[mid].name<<" "<<L.data[mid].banji<<" "<<L.data[mid].score1<<" "<<L.data[mid].score2<<endl;break;}else if(L.data[mid].number>nu)high=mid-1;else low=mid+1;}if(low>high)cout<<"不存在该学生!"<<endl;}//直接插入排序void InsertSort(SeqList &L){int i, j;for( i=2; i<=L.len; i++ )int result1=strcmp(L.data[i].name , L.data[i-1].name);if (result1<0){L.data[0]=L.data[i]; // 复制为哨兵for(j=i-1;strcmp(L.data[0].name,L.data[j].name)<0; j-- )L.data[j+1]=L.data[j]; // 记录后移L.data[j+1]=L.data[0]; // 插入到正确位置}}}//直接选择排序void SelectSort(SeqList &L){ int i, j,k;DataType temp;for( i=1; i<L.len; i++ ){ k = i;for( j=i+1; j<=L.len; j++ ){if( L.data[j].score1 < L.data[k].score1 )k = j ;}if( k != i ){temp = L.data[i];L.data[i] = L.data[k];L.data[k] =temp;}}}//冒泡排序void BubbleSort(SeqList &L){ int i,j,flag=1; DataType x;for(i=1;((i<L.len)&&(flag==1));i++){ flag=0;for(j=1;j<L.len-i+1;j++)if(L.data[j].score2>L.data[j+1].score2){ x=L.data[j];L.data[j]=L.data[j+1];L.data[j+1]=x; flag=1;}}}void Print_SeqList(SeqList L){for(int i=1;i<=L.len;i++){cout<<L.data[i].number<<" ";cout<<L.data[i].name<<" ";cout<<L.data[i].banji<<" ";cout<<L.data[i].score1<<" ";cout<<L.data[i].score2<<endl;}}void main(){SeqList L;Init_SeqList(L);Create_SeqList(L);char na[20];for(int i=0;i<2;i++){cout<<"请输入要查找的学生姓名:"<<endl;cin>>na;S_Search(L,na);cout<<"----------------------------"<<endl;}int nu;for(int j=0;j<2;j++){cout<<"请输入要查找的学生学号:"<<endl;cin>>nu;Binary_Search(L,nu);cout<<"----------------------------"<<endl;}InsertSort(L);cout<<"按姓名进行排序后的结果:"<<endl;Print_SeqList( L);cout<<"----------------------------"<<endl;SelectSort(L);cout<<"按C++成绩进行排序后的结果:"<<endl;Print_SeqList( L);cout<<"----------------------------"<<endl;BubbleSort(L);cout<<"按数据结构成绩进行排序后的结果:"<<endl;Print_SeqList( L);}程序运行结果如下:四、实验总结在按姓名查找和排序时,忘记字符数组有自己的方法来实现数组的大小比较,应使用strcmp(a,b)方法。
排序查找实验报告总结
![排序查找实验报告总结](https://img.taocdn.com/s3/m/6b9d1e9cd4bbfd0a79563c1ec5da50e2524dd1ea.png)
一、实验目的本次实验旨在通过实际操作,加深对排序和查找算法的理解,掌握几种常见的排序和查找方法,提高编程能力,并了解它们在实际应用中的优缺点。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm三、实验内容1. 排序算法(1)冒泡排序冒泡排序是一种简单的排序算法,基本思想是通过相邻元素的比较和交换,逐步将较大的元素移动到序列的后面,较小的元素移动到序列的前面,直到整个序列有序。
(2)选择排序选择排序是一种简单直观的排序算法,基本思想是遍历整个序列,每次从剩余未排序的元素中找到最小(或最大)的元素,将其与未排序序列的第一个元素交换,然后继续在剩余未排序的元素中寻找最小(或最大)的元素。
(3)插入排序插入排序是一种简单直观的排序算法,基本思想是将一个记录插入到已经排好序的有序表中,从而得到一个新的、记录数增加1的有序表。
(4)快速排序快速排序是一种效率较高的排序算法,基本思想是选取一个基准值,将待排序序列分为两个子序列,一个子序列中所有元素都比基准值小,另一个子序列中所有元素都比基准值大,然后递归地对两个子序列进行快速排序。
2. 查找算法(1)顺序查找顺序查找是一种最简单的查找算法,基本思想是从线性表的第一个元素开始,依次将线性表中的元素与要查找的元素进行比较,若相等,则查找成功;若线性表中所有元素都与要查找的元素不相等,则查找失败。
(2)二分查找二分查找是一种效率较高的查找算法,基本思想是对于有序的线性表,通过将待查找元素与线性表中间的元素进行比较,逐步缩小查找范围,直到找到目标元素或查找失败。
四、实验结果与分析1. 排序算法分析(1)冒泡排序:时间复杂度为O(n^2),空间复杂度为O(1),稳定排序。
(2)选择排序:时间复杂度为O(n^2),空间复杂度为O(1),不稳定排序。
(3)插入排序:时间复杂度为O(n^2),空间复杂度为O(1),稳定排序。
实验6_7查找和排序
![实验6_7查找和排序](https://img.taocdn.com/s3/m/3ae344cfd5bbfd0a79567337.png)
实验六、七:查找、排序算法的应用一、实验目的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;}}}。
查找实验报告
![查找实验报告](https://img.taocdn.com/s3/m/34e3c03bfbd6195f312b3169a45177232f60e46c.png)
查找实验报告第一篇:查找实验报告实验六查找实验目的:掌握几种查找的思想及算法问题分析:(一)顺序查找 1.查找思想从表的一端开始逐个将记录的关键字和给定K值进行比较,若某个记录的关键字和给定K值相等,查找成功;否则,若扫描完整个表,仍然没有找到相应的记录,则查找失败。
2.算法实现int Seq_Search(SST able ST,int key){int p;} ST.data[0].key=key;/* 设置监视哨兵,失败返回0 */ for(p=ST.length;ST.data[p].key!=key;p--);return(p);3.算法分析设查找每个记录成功的概率相等,即Pi=1/n;查找第i个元素成功的比较次数Ci=n-i+1 ;◆ 查找成功时的平均查找长度ASL:◆包含查找不成功时:查找失败的比较次数为n+1,若成功与不成功的概率相等,对每个记录的查找概率为Pi=1/(2n),则平均查找长度ASL:(二)折半查找前提条件:查找表中的所有记录是按关键字有序(升序或降序)。
查找过程中,先确定待查找记录在表中的范围,然后逐步缩小范围(每次将待查记录所在区间缩小一半),直到找到或找不到记录为止。
1.查找思想用Low、High和Mid表示待查找区间的下界、上界和中间位置指针,初值为Low=1,High=n。
⑴取中间位置Mid:Mid=⎣(Low+High)/2⎦;⑵比较中间位置记录的关键字与给定的K值:①相等:查找成功;②大于:待查记录在区间的前半段,修改上界指针:High=Mid-1,转⑴ ;③小于:待查记录在区间的后半段,修改下界指针:Low=Mid+1,转⑴ ;直到越界(Low>High),查找失败。
2.算法实现int Bin_Search(SST able ST , KeyType k){int low=1,high=ST.length, mid;while(low<=high){mid=(low+high)/2;if(EQ(ST.data[mid].key, k))return(mid);else if(LT(ST.dat[mid].key, k))low=mid+1;else high=mid-1;}return(0);/*查找失败*/ } 3.算法分析①查找时每经过一次比较,查找范围就缩小一半,该过程可用一棵二叉树表示:◆根结点就是第一次进行比较的中间位置的记录;◆ 排在中间位置前面的作为左子树的结点;◆ 排在中间位置后面的作为右子树的结点;对各子树来说都是相同的。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验七查找和排序算法的实现•实验目的及要求(1)学生在实验中体会各种查找和内部排序算法的基本思想、适用场合,理解开发高效算法的可能性和寻找、构造高效算法的方法。
(2)掌握运用查找和排序解决一些实际应用问题。
二.实验内容:(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等)算相应的ASL。
(2)编程实现一种内部排序算法(如插入排序、快速排序等)。
三.实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写,请另加附页)(1)编程实现一种查找算法(如折半查找、二叉排序树的查找、哈希查找等)算相应的ASL。
程序代码:折半查找:头文件:#defi ne EQ(a,b) ((a)==(b))#define LT(a,b) ((a)v(b))#defi ne maxle ngth 20 typedef int ElemType;typedef struct{ElemType key;ElemType other;}card;〃每条记录包含的数据项typedef struct{card r[maxle ngth];int len gth;}SSTable;〃一张表中包含的记录容量void Create(SSTable & L); int Search(SSTable L,i nt elem);功能函数:#i nclude"1.h" #i nclude"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(" elseif(LT(elem,L.r[mid].key)){high=mid-1;}else{low=mid+1;}}printf(" 表中没有该元素(不在范围内)return 0;}主函数:#include"stdio.h"#include"1.h" int main() {该元素在第%d 位\n",mid+1); return 0;} \n");SSTable L;Create(L);prin tf("\n");printf("此时的线性表元素:\n");for(i nt a=0;a<L .len gth;a++){prin tf("%d "丄.r[a].key);}prin tf("\n");prin tf("\n");int elem;do{printf("请输入要查找的元素(输入000表示结束程序)\n");sea nf("%d", &elem);if(elem!=000){Seareh(L,elem);}}while(elem!=000);return 0;}运行结果:(2)编程实现一种内部排序算法(如插入排序、快速排序等)。
程序代码部分:直接插入排序头文件:#defi ne maxle ngth 20/最大数据容量#defi ne OK 1typedef int Other;typedef int KeyType;typedef int Status;typedef struct{KeyType key;Other data;}Red;typedef struct{Red r[maxle ngth+1];〃加了个哨兵的位置int len gth;//当前数据个数}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(i nt 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 Other;typedef int KeyType;typedef struct{KeyType key;Other data;}Red;typedef struct{Red r[maxle ngth+1];〃加了个哨兵的位置int len gth;//当前数据个数}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"); typedef int Status;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(" 请输入无序子列的开始和结束位置(有序子列不用管) int\n");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分)不及格。