数据结构 查找排序实验

合集下载

数据结构实验五-查找与排序的实现

数据结构实验五-查找与排序的实现

实验报告课程名称数据结构实验名称查找与排序得实现系别专业班级指导教师11学号姓名实验日期实验成绩一、实验目得(1)掌握交换排序算法(冒泡排序)得基本思想;(2)掌握交换排序算法(冒泡排序)得实现方法;(3)掌握折半查找算法得基本思想;(4)掌握折半查找算法得实现方法;二、实验内容1.对同一组数据分别进行冒泡排序,输出排序结果。

要求:1)设计三种输入数据序列:正序、反序、无序2)修改程序:a)将序列采用手工输入得方式输入b)增加记录比较次数、移动次数得变量并输出其值,分析三种序列状态得算法时间复杂性2.对给定得有序查找集合,通过折半查找与给定值k相等得元素。

3.在冒泡算法中若设置一个变量lastExchangeIndex来标记每趟排序时经过交换得最后位置,算法如何改进?三、设计与编码1、本实验用到得理论知识2、算法设计3、编码package sort_search;import java、util、Scanner;publicclass Sort_Search{//冒泡排序算法ﻩpublic voidBubbleSort(int r[]){int temp;ﻩint count=0,move=0;ﻩboolean flag=true;ﻩfor(int i=1;i〈r、length&&flag;i++){ﻩﻩflag=false;ﻩﻩcount++;ﻩfor(intj=0;j<r、length-i;j++){if(r[j]>r[j+1]){ﻩtemp=r[j];ﻩﻩﻩr[j]=r[j+1];r[j+1]=temp;ﻩﻩmove++;flag=true;ﻩﻩ}ﻩﻩﻩ}ﻩ}ﻩﻩSystem、out、println("排序后得数组为:”);ﻩfor(int i=0;i〈r、length;i++){ﻩﻩSystem、out、print(r[i]+" ”);ﻩ}System、out、println();ﻩSystem、out、println("比较次数为:"+count);ﻩﻩSystem、out、println("移动次数为:”+move);}ﻩpublic staticint BinarySearch(int r[],int key){//折半查找算法ﻩint low=0,high=r、length-1;ﻩwhile(low<=high){ﻩint mid=(low+high)/2;ﻩﻩif(r[mid]==key){ﻩreturn mid;ﻩﻩ}ﻩﻩelse if(r[mid]>key){high=mid—1;ﻩﻩ}ﻩﻩelse{ﻩﻩﻩlow=mid+1;ﻩﻩ}ﻩ}ﻩﻩreturn -1;ﻩ}//测试public static void main(String[]args){ﻩSort_Search ss=new Sort_Search();intt[]=new int[13];ﻩSystem、out、println(”依次输入13个整数为:");ﻩScanner sc=new Scanner(System、in);ﻩfor(int i=0;i〈t、length;i++){ﻩﻩt[i]=sc、nextInt();ﻩ}ﻩﻩSystem、out、println("排序前得数组为: ");ﻩfor(int i=0;i<t、length;i++){ﻩSystem、out、print(t[i]+"”);ﻩ}ﻩSystem、out、println();ﻩﻩss、BubbleSort(t);//查找ﻩwhile(true){ﻩﻩSystem、out、println("请输入要查找得数: ”); ﻩﻩint k=sc、nextInt();ﻩif(BinarySearch(t,k)>0)System、out、println(k+"在数组中得位置就是第:"+ BinarySearch(t,k));ﻩﻩelseﻩﻩSystem、out、println(k+”在数组中查找不到!");ﻩ}ﻩ }}四、运行与调试1.在调试程序得过程中遇到什么问题,就是如何解决得?问题:在计算比较次数与移动次数时,计算数据明显出错。

数据结构实验六 查找与排序

数据结构实验六    查找与排序

数据结构实验六查找与排序班级学号姓名分数一、实验目的:1、掌握各种排序方法的基本思想、排序过程、算法实现2、能进行时间和空间性能的分析,根据实际问题的特点和要求选择合适的排序方二、实验要求:实现直接排序、冒泡、直接选择、快速、堆、归并排序算法。

比较各种算法的运行速度。

三、实验内容及分析:比较各种算法的运行速度运行速度比较:直接排序冒泡排序直接插入冒泡排序快速排序时间复杂度 O(n2),其中快速排序效率较高其它的效率差不多堆排序归并排序时间复杂度 (nlogn) ,平均效率都很高四、程序的调试及运行结果直接插入排序冒泡法排序快速排序直接选择排序堆排序归并排序五、程序代码#include"stdio.h"#include"stdlib.h"#define Max 100 //假设文件长度typedef struct{ //定义记录类型int key; //关键字项}RecType;typedef RecType SeqList[Max+1]; //SeqList为顺序表,表中第0个元素作为哨兵int n; //顺序表实际的长度//==========直接插入排序法======void InsertSort(SeqList R){ //对顺序表R中的记录R[1‥n]按递增序进行插入排序int i,j;for(i=2;i<=n;i++) //依次插入R[2],……,R[n]if(R[i].key<R[i-1].key){ //若R[i].key大于等于有序区中所有的keys,则R[i]留在原位R[0]=R[i];j=i-1; //R[0]是R[i]的副本do{ //从右向左在有序区R[1‥i-1]中查找R[i] 的位置R[j+1]=R[j]; //将关键字大于R[i].key的记录后移j--;}while(R[0].key<R[j].key); //当R[i].key≥R[j].key 是终止R[j+1]=R[0]; //R[i]插入到正确的位置上}//endif}//==========冒泡排序=======typedef enum {FALSE,TRUE} Boolean; //FALSE为0,TRUE为1void BubbleSort(SeqList R) { //自下向上扫描对R做冒泡排序int i,j; Boolean exchange; //交换标志for(i=1;i<n;i++) { //最多做n-1趟排序exchange=FALSE; //本趟排序开始前,交换标志应为假for(j=n-1;j>=i;j--) //对当前无序区R[i‥n] 自下向上扫描if(R[j+1].key<R[j].key){ //两两比较,满足条件交换记录R[0]=R[j+1]; //R[0]不是哨兵,仅做暂存单元R[j+1]=R[j];R[j]=R[0];exchange=TRUE; //发生了交换,故将交换标志置为真}if(! exchange) //本趟排序未发生交换,提前终止算法return;}// endfor(为循环)}//1.========一次划分函数=====int Partition(SeqList R,int i,int j){ // 对R[i‥j]做一次划分,并返回基准记录的位置RecType pivot=R[i]; //用第一个记录作为基准while(i<j) { //从区间两端交替向中间扫描,直到i=jwhile(i<j &&R[j].key>=pivot.key) //基准记录pivot相当与在位置i上j--; //从右向左扫描,查找第一个关键字小于pivot.key的记录R[j]if(i<j) //若找到的R[j].key < pivot.key,则R[i++]=R[j]; //交换R[i]和R[j],交换后i指针加1while(i<j &&R[i].key<=pivot.key) //基准记录pivot相当与在位置j上i++; //从左向右扫描,查找第一个关键字小于pivot.key的记录R[i]if(i<j) //若找到的R[i].key > pivot.key,则R[j--]=R[i]; //交换R[i]和R[j],交换后j指针减1}R[i]=pivot; //此时,i=j,基准记录已被最后定位return i; //返回基准记录的位置}//2.=====快速排序===========void QuickSort(SeqList R,int low,int high){ //R[low..high]快速排序int pivotpos; //划分后基准记录的位置if(low<high) { //仅当区间长度大于1时才排序pivotpos=Partition(R,low,high); //对R[low..high]做一次划分,得到基准记录的位置QuickSort(R,low,pivotpos-1); //对左区间递归排序QuickSort(R,pivotpos+1,high); //对右区间递归排序}}//======直接选择排序========void SelectSort(SeqList R){int i,j,k;for(i=1;i<n;i++){ //做第i趟排序(1≤i≤n-1)k=i;for(j=i+1;j<=n;j++) //在当前无序区R[i‥n]中选key最小的记录R[k] if(R[j].key<R[k].key)k=j; //k记下目前找到的最小关键字所在的位置if(k!=i) { // //交换R[i]和R[k]R[0]=R[i];R[i]=R[k];R[k]=R[0];} //endif} //endfor}//==========大根堆调整函数=======void Heapify( SeqList R,int low,int high){ // 将R[low..high]调整为大根堆,除R[low]外,其余结点均满足堆性质int large; //large指向调整结点的左、右孩子结点中关键字较大者RecType temp=R[low]; //暂存调整结点for(large=2*low; large<=high;large*=2){ //R[low]是当前调整结点//若large>high,则表示R[low]是叶子,调整结束;否则先令large指向R[low]的左孩子if(large<high && R[large].key<R[large+1].key)large++; //若R[low]的右孩子存在且关键字大于左兄弟,则令large指向它//现在R[large]是调整结点R[low]的左右孩子结点中关键字较大者if(temp.key>=R[large].key) //temp始终对应R[low]break; //当前调整结点不小于其孩子结点的关键字,结束调整R[low]=R[large]; //相当于交换了R[low]和R[large]low=large; //令low指向新的调整结点,相当于temp已筛下到large的位置 }R[low]=temp; //将被调整结点放入最终位置上}//==========构造大根堆==========void BuildHeap(SeqList R){ //将初始文件R[1..n]构造为堆int i;for(i=n/2;i>0;i--)Heapify(R,i,n); //将R[i..n]调整为大根堆}//==========堆排序===========void HeapSort(SeqList R){ //对R[1..n]进行堆排序,不妨用R[0]做暂存单元int i;BuildHeap(R); //将R[1..n]构造为初始大根堆for(i=n;i>1;i--){ //对当前无序区R[1..i]进行堆排序,共做n-1趟。

数据结构查找排序实验报告

数据结构查找排序实验报告

贵州大学实验报告学院:电子信息学院专业:通信工程班级:2012级1班姓名学号实验组实验时间2014.5.15 指导教师成绩实验项目名称查找排序实验目的和要求1、掌握常用的查找、排序方法,及相应的算法实现。

2、能实现并应用某一种查找算法。

理解各种排序方法的特点,并能加以灵活应用。

3、了解各种排序算法的时间复杂度分析。

实验原理1、根据实验内容编程,上机调试、得出正确的运行程序。

2、编译运行程序,观察运行情况和输出结果。

实验仪器运行Visual c++的微机一台实验内容和步骤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;②实现直接插入排序:每次将一个待排序的记录,按其关键字大小插入到前面已排序好的子文件中的适当位置,直到全部记录插入完成为止。

数据结构实验七 查找

数据结构实验七 查找

数据结构实验七查找数据结构实验七查找一、实验目的本实验旨在通过编程实现常见的查找算法,包括顺序查找、二分查找和哈希查找,并比较它们的效率和适用场景。

二、实验内容1.顺序查找1.1 算法思想顺序查找算法是一种简单直观的查找方法,它的基本思想是从数组的第一个元素开始逐个比较,直到找到目标元素或遍历完整个数组。

1.2 算法流程a) 初始化目标元素的索引为 -1.b) 从数组的第一个元素开始,依次与目标元素比较。

c) 如果找到目标元素,则记录其索引,并结束查找。

d) 如果遍历完整个数组仍未找到目标元素,则记录目标索引仍为 -1.1.3 时间复杂度顺序查找算法的时间复杂度为 O(n),其中 n 为数组的长度。

2.二分查找2.1 算法思想二分查找算法是一种高效的查找算法,但要求被查找的数组必须是有序的。

它的基本思想是将目标元素与数组的中间元素进行比较,然后根据比较结果将查找的范围缩小一半,直到找到目标元素或查找范围为空。

2.2 算法流程a) 初始化目标元素的索引为 -1、查找范围的起始索引为0,终止索引为数组长度减一。

b) 计算查找范围的中间索引,取整数部分。

c) 将目标元素与中间索引对应的数组元素进行比较:- 如果相等,则记录中间索引为目标索引,并结束查找。

- 如果目标元素小于中间元素,则在前一半查找范围中进行二分查找。

- 如果目标元素大于中间元素,则在后一半查找范围中进行二分查找。

d) 如果查找范围的起始索引大于终止索引,则表示查找范围为空,记录目标索引仍为 -1.2.3 时间复杂度二分查找算法的时间复杂度为 O(log n),其中 n 为数组的长度。

3.哈希查找3.1 算法思想哈希查找算法利用哈希函数将关键字映射到一个固定位置进行查找,从而实现快速访问。

它的基本思想是通过哈希函数计算得到关键字的哈希值,并根据哈希值找到对应的存储位置,如果哈希表中已经存在该关键字,则返回对应的值,否则返回空。

3.2 算法流程a) 初始化一个哈希表,用于存储关键字和对应值的映射。

数据结构与算法实验报告5-查找与排序

数据结构与算法实验报告5-查找与排序

北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。

在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。

数据结构查找实验报告

数据结构查找实验报告

一、实验目的1. 理解并掌握几种常见查找算法的基本原理和实现方法。

2. 比较不同查找算法的时间复杂度和空间复杂度。

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

二、实验内容本次实验主要涉及以下查找算法:1. 顺序查找法2. 二分查找法3. 散列查找法三、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发环境:PyCharm四、实验步骤1. 实现顺序查找法2. 实现二分查找法3. 实现散列查找法4. 编写测试程序,分别对三种查找算法进行测试5. 比较三种查找算法的性能五、实验结果与分析1. 顺序查找法(1)实现代码```pythondef sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1```(2)测试程序```pythonarr = [5, 3, 8, 6, 2, 7, 4, 9, 1]target = 6print("顺序查找结果:", sequential_search(arr, target))```(3)分析顺序查找法的时间复杂度为O(n),空间复杂度为O(1)。

当数据量较大时,查找效率较低。

2. 二分查找法(1)实现代码```pythondef binary_search(arr, target):left, right = 0, len(arr) - 1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid - 1return -1```(2)测试程序```pythonarr = [1, 2, 3, 4, 5, 6, 7, 8, 9]target = 6print("二分查找结果:", binary_search(arr, target))```(3)分析二分查找法的时间复杂度为O(log2n),空间复杂度为O(1)。

数据结构实验报告五,查找与排序-

数据结构实验报告五,查找与排序-

数据结构实验报告五,查找与排序-查找与排序一、实验目的:1.理解掌握查找与排序在计算机中的各种实现方法。

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

3.熟练掌握常用排序算法在顺序表上的实现。

二、实验要求:掌握利用常用的查找排序算法的思想来解决一般问题的方法和技巧,进行算法分析并写出实习报告。

三、实验内容及分析:设计一个学生信息管理系统,学生对象至少要包含:学号、性别、成绩1、成绩总成绩等信息。

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

四、程序的调试及运行结果五、程序代码#includestdio.h#includestring.hstruct student//定义结构体{char name;int a1,a2,a3,num;double pow;}zl;int count=0;void jiemian1(); //主界面//函数声明int jiemian2(); //选择界面void luru(); //录入函数void xianshi(); //显示void paixv(); //排序void diaoyong(int); //循环调用选择界面void tianjia(); //添加信息void chaxun1(); //按学号查询详细信息void chaxun2(); //按姓名查询详细信息void xiugai(); //修改信息void shanchu(); //删除信息void main() //main函数{jiemian1();//函数点用}void jiemian1() //主界面定义{char a;printf(“\n\n\n\n\t\t\t学员信息管理器\n\n\n\t\t\t 数据结构课程设计练习六\n\n\n\t\t\t 09信计2:于学彬\n\n“);printf("\n\t\t\t 按回车键继续:");scanf("%c",system("cls");jiemian2();}int jiemian2() //选择界面{int a,b;printf("*******************************主要功能********************************");printf("\n\n\n\n\t\t\t\t1.录入信息\n\n\t\t\t\t2.添加信息\n\n\t\t\t\t3.查看信息\n\n\t\t\t\t4.查询信息\n\n\t\t\t\t5.修改信息\n\n\t\t\t\t6.删除信息\n\n\t\t\t\t7.退出\n\n\t\t\t\t请选择:");scanf("%d",switch(a){case 1:system("cls");luru();break;case 2:system("cls");tianjia();break;case 3:system("cls");paixv();break;case 4:system("cls");printf("1.按学号查询详细信息\n2.按姓名查询详细信息\n请选择:");scanf("%d",switch(b){case 1:system("cls");chaxun1();break;case 2:system("cls");chaxun2();break;} break;case 5:system("cls");xiugai();break;case 6:system("cls");shanchu();break;case 7:system("cls");return a;break;}}void diaoyong(int b) //循环调用选择界面{char a='y';printf("是否返回选择页(y/n):");fflush(stdin);//清空输入缓冲区,通常是为了确保不影响后面的数据读取(例如在读完一个字符串后紧接着又要读取一个字符,此时应该先执行fflush(stdin);)a=getchar();system("cls");while(a=='y'||a=='Y'){b=jiemian2();if(b==7){break;}}}void luru() //录入函数{char a;//='y';do{printf("请输入学员信息:\n");printf("学号:");scanf("%d",zl[count].num);//调用结构体printf("姓名:");fflush(stdin);gets(zl[count].name);printf("三门成绩:\n");printf("成绩1:");scanf("%d",zl[count].a1);printf("成绩2:");scanf("%d",zl[count].a2);printf("成绩3:");scanf("%d",zl[count].a3);zl[count].pow=(zl[count].a1+zl[count].a2+zl[count].a3)/3;//求平均数printf("是否继续(y/n):");fflush(stdin);a=getchar();count++;system("cls");}while(a=='y'count100);//paixv();diaoyong(count);}void tianjia() //添加信息{char a='y';do{printf("请输入学员信息:\n");printf("学号:");scanf("%d",zl[count].num);printf("姓名:");//fflush(stdin);gets(zl[count].name);printf("三门成绩:\n");printf("成绩1:");scanf("%d",zl[count].a1);printf("成绩2:");scanf("%d",zl[count].a2);printf("成绩3:");scanf("%d",zl[count].a3);zl[count].pow=(zl[count].a1+zl[count].a2+zl[count].a3)/3; printf("是否继续(y/n):");//fflush(stdin);a=getchar();count++;system("cls");}while(a=='y'count100);paixv(count);diaoyong(count);}void xianshi() //显示{int i;printf("学号\t \t姓名\t\t\t平均成绩\n");for(i=0;icount;i++){printf("%d\t \t%s\t\t\t%f\n",zl[i].num,zl[i].name,zl[i].pow); }}void paixv() //排序{int i,j;struct student zl1;printf("排序前:\n");xianshi();for(i=0;icount;i++){for(j=1;jcount-i;j++){if(zl[j-1].powzl[j].pow){zl1=zl[j-1];zl[j-1]=zl[j];zl[j]=zl1;}}}printf("排序后:\n");xianshi();diaoyong(count);}void chaxun1() //按学号查询详细信息{int i,num;printf("请输入要查询学员的学号:");scanf("%d",num);printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n"); for(i=0;icount;i++){if(zl[i].num==num){printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl [i].a3,zl[i].pow);}}diaoyong(count);}void chaxun2() //按姓名查询详细信息{int i;struct student zl1;printf("请输入要查询学员的姓名:");fflush(stdin);gets();printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n");for(i=0;icount;i++){if((strcmp(zl[i].name,))==0)//比较两个字符串的大小{printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl [i].a3,zl[i].pow);}}diaoyong(count);}void xiugai() //修改信息{int i,num;printf("请输入要查询学员的学号:");scanf("%d",num);printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n");for(i=0;icount;i++){if(zl[i].num==num){break;}}printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl [i].a3,zl[i].pow);printf("请输入学员信息:\n");printf("学号:");scanf("%d",zl[i].num);printf("姓名:");fflush(stdin);gets(zl[i].name);printf("三门成绩:\n");printf("成绩1:");scanf("%d",zl[i].a1);printf("成绩2:");scanf("%d",zl[i].a2);printf("成绩3:");scanf("%d",zl[i].a3);zl[i].pow=(zl[i].a1+zl[i].a2+zl[i].a3)/3;printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n"); printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl[i].a3,zl[i].pow);diaoyong(count);}void shanchu() //删除信息{int num,i,j;printf("请输入要删除的学员学号:");scanf("%d",num);for(i=0;icount;i++){if(zl[i].num==num){for(j=i;jcount;j++){zl[j]=zl[j+1];}}}count--;xianshi();diaoyong(count);}。

查找排序操作实验报告

查找排序操作实验报告

一、实验目的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)排序算法性能测试在数据量较大的情况下,快速排序和归并排序的性能明显优于冒泡排序、选择排序和插入排序。

数据结构查找实验报告

数据结构查找实验报告

数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能比较,分析它们在不同数据规模和分布情况下的效率和适用场景。

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

实验中所使用的数据集生成工具为 numpy 库。

三、实验原理1、顺序查找顺序查找是一种最简单的查找算法,它从数据结构的开头依次逐个比较元素,直到找到目标元素或遍历完整个数据结构。

其平均时间复杂度为 O(n)。

2、二分查找二分查找要求数据结构是有序的。

通过不断将查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。

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

3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中,利用哈希函数计算元素的存储位置,从而实现快速查找。

理想情况下,其平均时间复杂度为 O(1),但在存在哈希冲突时,性能可能会下降。

四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集,包括有序数据集、无序数据集和具有一定重复元素的数据集。

2、顺序查找实现编写顺序查找算法的函数,接受数据集和目标元素作为参数,返回查找结果(是否找到及查找次数)。

3、二分查找实现实现二分查找算法的函数,同样接受数据集和目标元素作为参数,并返回查找结果。

4、哈希查找实现构建哈希表并实现哈希查找函数,处理哈希冲突的情况。

5、性能比较对不同规模和类型的数据集,分别使用三种查找算法进行查找操作,并记录每种算法的查找时间和查找次数。

五、实验结果与分析1、顺序查找在无序数据集中,顺序查找的性能表现较为稳定,查找时间随着数据规模的增大线性增长。

但在有序数据集中,其性能没有优势。

2、二分查找二分查找在有序数据集中表现出色,查找时间随着数据规模的增大增长缓慢,体现了对数级别的时间复杂度优势。

然而,在无序数据集中无法使用。

数据结构实验4查找、排序

数据结构实验4查找、排序

淮海工学院计算机工程学院实验报告书课程名:《数据结构》题目:实验4 查找、排序的应用班级:学号:姓名:实验4 查找、排序的应用实验目的和要求1.熟悉查找表的存储结构。

2.熟练掌握循序查找和二分查找方法。

3.熟悉几种典型的排序方法,并对各种算法的特点、使用范围和效率有进一步的了解。

4.实现两种以上的简单排序和快速排序、比较它们的时间效率。

5.要求独立完成实验内容(提交程序清单、相关实验数据及运行结果);6.要求认真书写实验报告,并按时提交。

实验环境Turbo C 或VC++实验学时4学时,必做实验实验内容和步骤l、产生n个整数并存于数组r[1..n]中。

对主要查找算法(顺序查找、折半查找)和排序算法(直接插入排序、冒泡排序、快速排序、简单选择排序)进行实验比较,计算出平均比较次数、平均移动次数。

2、对实验结果数据进行对比分析。

1. #include <iostream>using namespace std;int count;int SepSearch(int r[], int key,int len) //顺序查找{int i;count=0;i=len;while(key!=r[i]){i--;count++;}return(i);}int BinSrch(int r[],int key,int len) //折半查找{int low,high,mid;low=1;high=len;count=0;while(low<=high){ count++;mid=(low+high)/2;if(key==r[mid]) return(mid);else if(key<r[mid]) high=mid-1;else low=mid+1;}return(0);}void BiInsertsort(int r[], int n) //插入排序(折半){count=0;for(int i=2;i<=n;i++){if (r[i]<r[i-1]){r[0] = r[i];int low=1,high=i-1;while (low<=high){count++;int mid=(low+high)/2;if (r[0]<r[mid])high=mid-1;else low = mid+1;}int j;for (j=i-1;j>high;j--){r[j+1] = r[j];count++;}r[j+1] = r[0];}}for(int k=1;k<=n;k++)printf("%d ",r[k]);printf("\n");}void BubbleSort(int r[], int n) //冒泡排序{count=0;int i;int temp,exchange,bound;exchange=n;while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{bound=exchange;exchange=0;for (int j=1; j<bound; j++)if (r[j]>r[j+1]){temp=r[j];r[j]=r[j+1];r[j+1]=temp;exchange=j;count++;}}for( i=1;i<=n;i++)printf("%d ",r[i]);printf("\n");}int Partition(int r[], int first, int end) //快速排序一次划分{int i=first;int j=end;r[0]=r[first];count=1;while (i<j){while (i<j && r[0]<= r[j]) j--; //右侧扫描r[i]=r[j];while (i<j && r[i]<= r[0]) i++; //左侧扫描r[j]=r[i];}r[i]=r[0];return i; //i为轴值记录的最终位置}void QuickSort(int r[], int first, int end) //快速排序{count++;if (first<end){int pivot=Partition(r, first, end);QuickSort(r, first, pivot-1); //递归地对左侧子序列进行快速排序QuickSort(r, pivot+1, end); //递归地对右侧子序列进行快速排序}}void SelectSort(int r[ ], int n) //简单选择排序{count=0;int i,j,index,temp;for (i=1; i<n; i++){index=i;for (j=i+1; j<=n; j++){count++;if (r[j]<r[index]) index=j;}if (index!=i){temp=r[i];r[i]=r[index];r[index]=temp;}}for(i=1;i<=n;i++)printf("%d ",r[i]);printf("\n");}void main(){const int numv=12;inta[3][numv]={{0,6,13,19,23,37,39,41,45,48,58,86},{0,86,58,48,45,41,39,37,23,19,13,6},{0,23,13,48,86,19, 6,41,58,37,45,39}};int z1[numv],z2[numv];int m,n,i,j;int s1;printf("请选择测试数据类:1 正序2 逆序3 随机[ 若跳出,请按4 ]\n");scanf("%d",&m);while(m>0&&m<4){printf("请选择操作算法:1 直接插入排序2 冒泡排序3 快速排序 4 简单选择排序5顺序查找6 折半查找\n");scanf("%d",&n);switch(n){case 1:printf("直接插入排序前:\n");for(j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("直接插入排序结果为:\n");BiInsertsort(a[m-1],numv-1);printf("移动了""%d""次\n",count);break;case 2:printf("冒泡排序前:\n");for( j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("冒泡排序结果为:\n");BubbleSort(a[m-1], numv-1);printf("移动了""%d""次\n",count);break;case 3:printf("快速排序前:\n");for( j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("快速排序结果为:\n");QuickSort(a[m-1],0,numv-1);for(i=1;i<numv;i++)printf("%d ",a[m-1][i]);printf("\n");printf("移动了""%d""次\n",count);break;case 4:printf("简单选择排序前:\n");for( j=1;j<numv;j++)printf("%d ",a[m-1][j]);printf("\n");printf("简单选择排序结果为:\n");SelectSort(a[m-1],numv-1);printf("移动了""%d""次\n",count);break;case 5:printf("请输入查找的数:\n");scanf("%d\n",&s1);i=SepSearch(a[m-1], s1,numv-1);printf("用顺序查找法查找数""%d""在第""%d""位,""比较了""%d""次\n",s1,i+1,count); break;case 6:printf("请输入查找的数:\n");scanf("%d\n",&s1);j=BinSrch(a[m-1], s1,numv-1);printf("用折半查找法查找数""%d""在第""%d""位,""比较了""%d""次\n",s1,i+1,count);break;default:printf("输入错误!\n");}m=0;printf("请选择测试数据类型:1 正序2逆序3随机[ 若跳出,请按4 ]:\n");scanf("%d",&m);}if(m==4) printf("(*^__^*) 再见!\n");else printf("输入错误!\n");}实验结果:(1)直接插入排序:(2)冒泡排序:(3)快速排序:(3)快速排序(4)简单选择排序(5)顺序查找(6)折半查找2.1 顺《数据结构》实验报告- 10 -2结果分析(1)几种排序法的比较如下表:(2)顺序查找平均查找长度:ASL=1/2(n+1)(3)折半法平均查找长度:ASL= (n+1)/2*log2(n+1)-1折半法查找方法优点是比较次数少,查找速度快,平均性能好,但要求查找的表为有序,且插入删除困难。

数据结构实验报告——查找与排序

数据结构实验报告——查找与排序

哈尔滨工业大学(深圳)数据结构实验报告查找与排序学院: 计算机科学与技术一、问题分析此题是一道排序问题,排序的方法有很多种,此题我用的是堆排序,这是一种不稳定排序,但时间复杂度较低,比较快。

计算机首先需要把文件中的数据读入内存中,用动态数组存储数据,然后建立数据结构,然后建立堆,比较子节点和父节点大小,降序排列,之后互换头结点与尾节点,再递归重复即可。

查找的话,依次查找对比即可。

二、详细设计2.1 设计思想将股票的代码,交易日期,及开盘价等信息分别用不同的动态数组存储起来。

因为要根据交易量的降序进行排序所以应将交易量的信息另外用一个float型的数组保存起来便于比较。

排序:使用一个下标数组用来模拟交易量的堆排序,将下标数组进行降序排序。

再根据下标数组里的值将股票信息保存在新的文件中。

查看:因为录入文件时是先把股票的代码相同的信息存入数组的。

所以查找时比较股票的代码,找到该代码后比较交易日期。

最后输出交易量。

2.2 存储结构及操作(1) 存储结构(一般为自定义的数据类型,比如单链表,栈等。

)vector<string> a;//股票代码vector<string> b;//股票交易日期vector<string> c;//股票开盘价_最高价_最低价_收盘价vector<float> d;//将交易量转换为float用于比较不过有的会被舍去vector<string> e;//交易量的原始数据用于输出到排序的文件中(2)涉及的操作(一般为自定义函数,可不写过程,但要注明该函数的含义。

)read_file() 将文件信息分别保存在上述存储结构中HeapAdjust(vector<long>& x,long s,long n) 小顶堆的调整函数HeapSort() 用堆排序进行交易量的降序排序并存储在指定文件中serach() 查找某交易日期某股票的交易量2.3 程序整体流程开始 A读入文件,存入数组 B排序 C查找 D结束 E2.堆排序示意图(由于堆排序描述时需要具体数据,所以只弄到示意图)三、用户手册1>将股票文件先存入指定文件夹中,根据提示输入文件名字按回车即可2>先在指定文件夹新建你要保存的文件后将文件的名字输入3>根据提示输入股票代码及交易日期,以空格隔开。

数据结构查找算法实验报告

数据结构查找算法实验报告

数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能分析,比较它们在不同数据规模和分布情况下的效率和优劣。

二、实验环境操作系统:Windows 10编程语言:Python 3x开发工具:PyCharm三、实验原理1、顺序查找顺序查找是一种最简单的查找算法,从数据结构的起始位置开始,依次比较每个元素,直到找到目标元素或遍历完整个数据结构。

其时间复杂度在最坏情况下为 O(n),平均情况下也接近 O(n)。

2、二分查找二分查找要求数据结构是有序的。

通过不断将查找区间缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。

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

3、哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置,如果发生冲突则通过相应的解决冲突策略进行处理。

在理想情况下,其时间复杂度可以接近 O(1)。

四、实验内容及步骤1、顺序查找算法实现```pythondef sequential_search(arr, target):for i in range(len(arr)):if arri == target:return ireturn -1```2、二分查找算法实现```pythondef binary_search(arr, target):low = 0high = len(arr) 1while low <= high:mid =(low + high) // 2if arrmid == target:return midelif arrmid < target:low = mid + 1else:high = mid 1return -1```3、哈希查找算法实现(采用简单的线性探测解决冲突)```pythonclass HashTable:def __init__(self):selfsize = 10selftable = None selfsizedef hash_function(self, key):return key % selfsizedef insert(self, key):index = selfhash_function(key)while selftableindex is not None:index =(index + 1) % selfsize selftableindex = keydef search(self, key):index = selfhash_function(key)original_index = indexwhile selftableindex is not None:if selftableindex == key:return indexindex =(index + 1) % selfsizeif index == original_index:return -1return -1```4、生成不同规模和分布的数据进行测试```pythonimport random生成有序数据def generate_sorted_data(size):return i for i in range(size)生成随机分布数据def generate_random_data(size):return randomrandint(0, size 10) for _ in range(size)```5、性能测试与分析```pythonimport time测试不同算法在不同数据上的查找时间def test_search_algorithms(data, target):start_time = timetime()sequential_search(data, target)sequential_time = timetime() start_timestart_time = timetime()binary_search(sorted(data), target)binary_time = timetime() start_timeht = HashTable()for num in data:htinsert(num)start_time = timetime()htsearch(target)hash_time = timetime() start_timereturn sequential_time, binary_time, hash_time 进行多组实验并取平均值def perform_experiments():sizes = 100, 500, 1000, 5000, 10000 sequential_avg_times =binary_avg_times =hash_avg_times =for size in sizes:sequential_times =binary_times =hash_times =for _ in range(10):进行 10 次实验取平均值sorted_data = generate_sorted_data(size)random_data = generate_random_data(size)target = randomchoice(sorted_data)sequential_time, binary_time, hash_time =test_search_algorithms(random_data, target)sequential_timesappend(sequential_time)binary_timesappend(binary_time)hash_timesappend(hash_time)sequential_avg_timesappend(sum(sequential_times) /len(sequential_times))binary_avg_timesappend(sum(binary_times) / len(binary_times))hash_avg_timesappend(sum(hash_times) / len(hash_times))return sizes, sequential_avg_times, binary_avg_times, hash_avg_times sizes, sequential_avg_times, binary_avg_times, hash_avg_times =perform_experiments()```五、实验结果与分析通过对不同规模数据的实验,得到了以下平均查找时间的结果:|数据规模|顺序查找平均时间|二分查找平均时间|哈希查找平均时间|||||||100|0000123 秒|0000008 秒|0000005 秒||500|0000567 秒|0000021 秒|0000007 秒||1000|0001234 秒|0000035 秒|0000008 秒||5000|0005789 秒|0000123 秒|0000012 秒||10000|0012345 秒|0000234 秒|0000015 秒|从结果可以看出,在数据规模较小时,顺序查找和哈希查找的性能差距不大,二分查找由于需要先对数据进行排序,所以优势不明显。

数据结构试验查找排序

数据结构试验查找排序

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

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

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

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

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

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

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

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

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

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

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

2、掌握直接排序方法。

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

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

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

一、需求分析设计一个学生信息管理系统,学生对象包含:学号、姓名、性别、班级、成绩1、成绩2、总成绩,要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序二、概要设计typedef struct{float num;//学生学号string name;//学生姓名string sex;//性别char className[20];//班级名称float mark1;//第1门成绩float mark2;//第2门成绩float sum;//第3门成绩}DataType;typedef struct //定义顺序表的结构{DataType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;int menu()菜单函数void CreatList(SqList &ST) //创建学生的相关信息void sort(SqList &ST) //排序void Query(SqList &ST) //查询信息void main()三、详细设计#include <iostream>#include<string>#include <iomanip>using namespace std;#define MAXSIZE 100typedef struct{float num;//学生学号string name;//学生姓名string sex;//性别char className[20];//班级名称float mark1;//第1门成绩float mark2;//第2门成绩float sum;//第3门成绩}DataType;typedef struct //定义顺序表的结构{DataType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;int menu(){int i;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 学生信息管理系统清单\n "<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 1.成绩的输入"<<endl;cout<<" 2.成绩查询"<<endl;cout<<" 3.成绩排序"<<endl;cout<<" 4.退出"<<endl;cout<<"请选择1-4:"<<endl;cin>>i;while(i<0||i>4){cout<<"系统提示: 您输入错误!"<<endl; //提示输入是否错误cout<<"请重新输入1-4: "<<endl;cin>>i;}return i;}void CreatList(SqList &ST) //创建学生的相关信息{cout<<"输入学生个数"<<endl;cin>>ST.length;cout<<" 学号姓名性别班级成绩1 成绩2 "<<endl;for(int i=0;i<ST.length;i++){cout<<"输入第"<<i+1<<"学生的信息"<<endl;cin>>ST.r[i].num>>ST.r[i].name>>ST.r[i].sex>>ST.r[i].className>>ST.r[i].mar k1>>ST.r[i].mark2;}cout<<"输入完毕"<<endl;}void output(SqList &ST)//输出{cout<<"学生的信息如下"<<endl;cout<<" 学号姓名性别班级成绩1 成绩2 总分"<<endl;for(int i=0;i<ST.length;i++)cout<<setw(6)<<ST.r[i].num<<setw(6)<<ST.r[i].name<<setw(6)<<ST.r[i].se x<<setw(6)<<ST.r[i].className<<setw(8)<<ST.r[i].mark1<<setw(8)<<ST.r[i].mark2 <<setw(8)<<ST.r[i].mark1+ST.r[i].mark2<<" "<<endl;}void Query(SqList &ST) //查询信息{cout<<endl;cout<<" (1)根据学号查询"<<endl;cout<<" (2)根据姓名查询"<<endl; cout<<" (3)根据性别查询"<<endl; cout<<" (4)退出"<<endl;int a,m,n,i,j;int low,high,mid;DataType LI; //使学号变为有序string name;string xb;cin>>m;switch(m){case 1: //折半查找for(i=1;i<ST.length;i++){for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}}a=0;cout<<"输入要查找的学号"<<endl;cin>>n;low=0;high=ST.length-1; // 置区间初值while (low<=high){mid=(low+high)/2;if(n==ST.r[mid].num){cout<<ST.r[mid].num<<" "<<ST.r[mid].name<<" "<<ST.r[mid].sex<<" "<<ST.r[mid].className<<" "<<ST.r[mid].mark1<<" "<<ST.r[mid].mark2<<" "<<(ST.r[mid].mark1+ST.r[mid].mark2)<<endl;a=1;break;}else if(n<ST.r[mid].num)high=mid-1; // 继续在前半区间进行查找elselow=mid+1; // 继续在后半区间进行查找}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;case 2: //顺序查找{a=0;cout<<"输入要查找的姓名"<<endl;cin>>name;for(i=0;i<ST.length;i++){if(name==ST.r[i].name){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 3: //顺序查找{a=0;cout<<"输入要查找性别"<<endl;cin>>xb;for(i=0;i<ST.length;i++){if(xb==ST.r[i].sex){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 4:menu();break;}}void sort(SqList &ST) //排序{int n,i,j;DataType LI; //定义存储学号向量cout<<endl;cout<<" (1)根据学号排序"<<endl;cout<<" (2)根据成绩1排序"<<endl;cout<<" (3)根据成绩2排序"<<endl;cout<<" (4)根据总成绩排序"<<endl;cout<<" (5)退出"<<endl;cin>>n;switch(n){case 1: //按学号排序,使用插入排序for(i=1;i<ST.length;i++)for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}output(ST);cout<<"排序完毕"<<endl;break;case 2: //按成绩1排序,用选择排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark1>ST.r[j].mark1){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序完毕"<<endl;break;case 3: // 根据成绩2排序,使用选择法排for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark2>ST.r[j].mark2){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}output(ST);cout<<"排序完毕"<<endl;break;case 4: //根据总成绩排序,使用选择法排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].sum>ST.r[j].sum){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序完毕"<<endl;break;case 5: //退出menu();break;}}}#include"查找排序.h"void main(){SqList ST;while(1){switch(menu()){case 1:cout<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 1.成绩的输入"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;CreatList(ST);break;case 2:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 2.成绩的查询"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;Query(ST);break;case 3:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 3.成绩的排序"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;sort(ST);break;case 4:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 4.退出"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;exit(0);break;}}}四、运行结果图表1图表2图表3图表 4图表 5图表 6图表7图表8五、心得体会整个程序前前后后整整用了一个星期,每天只要有空闲时间就在翻书本,画流程图,写代码,反反复复一点一点。

数据结构实验8 查找与排序

数据结构实验8 查找与排序
查询菜单: (查找方法任选一种)
1.按学号查询
2.按姓名查询
3.按房号查询
打印任一查询结果(可以连续操作)。
参考:
typedef struct {
char sno[10];
char sname[2];
int sex; //以0表示女,1表示男
int roomno;
}ElemType;
struct SqList
注意事项:
在磁盘上创建一个目录,专门用于存储数据结构实验的程序。因为机房机器有还原卡,请同学们将文件夹建立在最后一个盘中,以学号为文件夹名。
实验八查找和排序
一、实验目的
掌握运用数据结构两种基本运算查找和排序,并能通过其能解决应用问题。
二、实验要求
1.掌握本实验的算法。
2.上机将本算法实现。
三Hale Waihona Puke 实验内容for(i=0;i<L.length;i++)
cout<<setw(7)<<L.elem[i].sno<<setw(10)<<L.elem[i].sname<<setw(3)<<L.elem[i].sex<<setw(6)<<L.elem[i].roomno<<endl;
}
为宿舍管理人员编写一个宿舍管理查询软件,程序采用交互工作方式,其流程如下:
建立数据文件,数据结构采用线性表,存储方式任选(建议用顺序存储结构),数据元素是结构类型(学号,姓名,性别,房号),元素的值可从键盘上输入,可以在程序中直接初始化。
数据文件按关键字(学号、姓名、房号)进行排序(排序方法任选一种),打印排序结果。(注意字符串的比较应该用strcmp(str1,str2)函数)

查找和排序 实验报告

查找和排序 实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验七、八查找排序及其应用

数据结构实验七、八查找排序及其应用

实验七、八 查找排序应用问题实现 一、实验目的1.理解掌握动态查找表在计算机中的各种实现方法。

2.熟练掌握顺序查找、折半查找在顺序表上的实现及解决简单的应用问题。

3.熟练掌握常用排序算法在顺序表上的实现,能解决简单的应用问题。

二、实验内容题目:从键盘上输入n个学生的基本信息(学号、姓名、班级、年龄等),建立其顺存储结构,然后执行如下操作:1、分别按学号、姓名、班级、年龄进行插入排序、交换排序和选择排序并显示排序结果(排序算法任选,但必须保证每种算法至少使用一次);2、可按学号、姓名、班级或其组合查找某一学生,若查找成功,则输出其基本信息,否则提示出错。

试设计程序完成上述功能。

提示:上述操作可用菜单方式实现,字符数据类型可用字符串比较函数在string.h 头文件中strcmp (const char *, const char *) ,测试数据:自定设计要求:1、上机前,认真学习教材,理解掌握各种查找算法、排序算法的特点及在计算机中的实现方法2、上机前,认真独立地写出本次程序清单,流程图,该程序包括数据类型以及每一种操作的具体的函数定义和主函数。

有关算法分别参阅讲义和参考教材事例。

头文件中数据结构设计及相关函数声明:#include<iostream.h>#include<string.h>#define MAXSIZE 20 //设记录不超过20个typedef struct { //学生数据结构体定义int Snumber; //学号char Name[10]; //姓名char Class[20]; //班级int Age; //年龄char Sex[10]; //性别}RecordType;typedef struct { //定义顺序表的结构RecordType r [ MAXSIZE +1 ]; //存储顺序表的向量int length ; //顺序表的长度}SqList ;void DataInput(SqList &L); //数据输入void DataPrint(SqList &L); //数据输出void InsertSort(SqList &L); //直接插入排序void QuickSort(SqList &L); //快速排序void SelectSort(SqList &L); //直接选择排序三、实验步骤(一)、数据结构与核心算法的设计描述根据实验题目及要求,宜采用顺序表的线性结构,实验中最重要的是三种排序算法的理解和实现,只有真正理解算法的内涵,才能熟练地应用,并解决相应的问题。

数据结构实验5查找排序算法

数据结构实验5查找排序算法

实验五、查找排序算法的实现一、实验目的1.掌握顺序、二分法查找方法及适用场合,并能在解决实际问题时灵活应用。

2.掌握各种排序(直接插入,希尔,冒泡,快速排序,简单选择,堆排序等)方法及适用场合,并能在解决实际问题时灵活应用。

二、实验内容随机输入(或随机产生)30个数(1)采用冒泡排序完成对这30个数的排序(2)采用顺序、折半查找在(1)中排好序的数据中完成查找任务(3)分别采用插入、快速和希尔完成对这30个数的排序任务,并输出每一趟排序后的结果三、实验代码:#include <stdio.h>#include <time.h>#include <stdlib.h>#define MaxSize 100typedef struct{int key;}RecordType;//直接插入排序void InsertSort(RecordType r[], int length){for (int i=2; i<=length;i++){r[0]=r[i];int j=i-1;while (r[0].key<r[j].key){r[j+1]=r[j];j=j-1;}r[j+1]=r[0];}}//冒泡排序void BubbleSort(RecordType r[], int length){int t;for (int i=1; i<=length; i++){for (int j=1; j<=length-i; j++){if (r[j].key>r[j+1].key){t = r[j+1].key;r[j+1].key=r[j].key;r[j].key=t;}}}}//快速排序int QKPass(RecordType r[], int left, int right){int low=left;int high=right;r[0]=r[left];while (low < high){while (low<high && r[high].key>r[0].key){high--;}if (low < high){r[low] = r[high];low++;}while (low < high && r[low].key < r[0].key){low++;}if (low < high){r[high] = r[low];high--;}}r[low] = r[0];return low;}void QKSort(RecordType r[], int low, int high){if (low < high){int pos=QKPass(r,low,high);QKSort(r, low, pos-1);QKSort(r, pos+1, high);}}//希尔排序void ShellInsert(RecordType r[], int length, int delta){int i, j;for (i=1+delta; i<=length; i++){if (r[i].key < r[i-delta].key){r[0] = r[i];for (j=i-delta; j>0 && r[j].key>r[0].key; j-= delta){r[j+delta] = r[j];}r[j+delta] = r[0];}}}void ShellSort(RecordType r[], int length, int delta[], int n){for (int i=0; i<n; i++){ShellInsert(r, length, delta[i]);}}void ShowResult(RecordType* r, int length){for (int i=1; i<=length; i++){printf("%-5d", r[i]);if (i%10==0){printf("\n");}}}void RandNum(RecordType r[MaxSize]){srand((unsigned)time(NULL));for (int i=1; i<=30;i++){r[i].key=rand()%100+1;printf("%-5d",r[i]);if (i%10==0){printf("\n");}}}int SeqSearch(RecordType* r,int length,int n) {int i;for(i=0;i<length;i++)if(r[i].key==n)return i;return(-1);}int BinSearch(RecordType* r,int length,int n) {int low,mid,high;low=0;high=length-1;while(low<=high){mid=(low+high)/2;if(r[mid].key==n) return(mid);else if(r[mid].key>n) high=mid-1;else low=mid+1;}return (-1);}void Select(){printf("------------排序算法-----------\n");printf("* * * * 1:冒泡排序* * * *\n");printf("* * * * 2:插入排序* * * *\n");printf("* * * * 3:快速排序* * * *\n");printf("* * * * 4:希尔排序* * * *\n");printf("-------------------------------\n");}int main(void){int n, m;int j;RecordType r[31] ;int delta[]={15,7,3,1};Select();do{printf("请选择排序算法:");scanf("%d", &m);switch (m){case 1:printf("你选择了冒泡排序!\n");printf("\n");printf("产生的随机待排序列为:\n");RandNum(r);BubbleSort(r, 30);printf("排序结果为:\n");ShowResult(r, 30);printf("请输入要查找的数:");scanf("%d",&j);printf("顺序查找结果:该数是第%d位\n",SeqSearch(r,30,j));printf("折半查找结果:该数是第%d位\n",BinSearch(r,30,j));break;case 2:printf("你选择了直接插入排序!\n");printf("\n");printf("产生的随机待排序列为:\n");RandNum(r);InsertSort(r, 30);printf("排序结果为:\n");ShowResult(r, 30);break;case 3:printf("你选择了快速排序!\n");printf("\n");printf("产生的随机待排序列为:\n");RandNum(r);QKSort(r, 1, 30);printf("排序结果为:\n");ShowResult(r, 30);break;case 4:printf("你选择了希尔排序!\n");printf("\n");printf("产生的随机待排序列为:\n");RandNum(r);ShellSort(r, 30, delta, 4);printf("排序结果为:\n");ShowResult(r, 30);break;default:printf("输入有误!");return false;break;}} while (true);return 0;}。

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

数据结构 查找排序实验

数据结构  查找排序实验

实验五:查找和排序班级 B09513 学号 200940 姓名一、实验目的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 使用直接插入排序方法,按姓名对学生信息进行排序。

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

4 使用直接选择排序方法,对学生信息中的C成绩进行排序。

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

5使用二分查找方法,从查找表中查找C成绩为79和80的学生。

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

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

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

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

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

注意:每完成一个操作必须进行输出,以验证操作的正确性。

三、实验结果#include <iostream>#include <string>#include <iomanip>using namespace std;const int MAX=100;typedef struct{int num;string name;int classnum;int cs;int ss;}DataType;typedef struct{DataType data[MAX];int length;}SNode;void Init(SNode *t){t->length=0;}void Create(SNode *t,int a[],string b[],int c[],int d[],int e[],int n) //创建{for(int i=0;i<n;i++){t->data[i+1].num=a[i];t->data[i+1].name=b[i];t->data[i+1].classnum=c[i];t->data[i+1].cs=d[i];t->data[i+1].ss=e[i];t->length++;}}void Display(SNode *t,int i) //输出学生的相关信息{cout.setf(ios::right);cout<<setw(8)<<"学号"<<setw(10)<<"姓名"<<setw(10)<<"班级"<<setw(10)<<"C++成绩"<<setw(15)<<"数据结构成绩"<<endl;cout.setf(ios::right);cout<<setw(8)<<t->data[i].num<<setw(10)<<t->data[i].name<<setw(10)<<t->data[i].cl assnum<<setw(10)<<t->data[i].cs<<setw(15)<<t->data[i].ss<<endl;}void N_Search(SNode *t,string kn) //按姓名查找{int i;i=t->length;t->data[0].name=kn;while(t->data[i].name!=kn)i--;if(i==0)cout<<"······对不起,没有该姓名的学生!········"<<endl;else{cout<<"····找到了!······"<<endl;Display(t, i);}}void C_Search(SNode *t,int cs1) //二分查找C成绩{int i=1; int flag,flag1;int low,high,mid,low1,high1,mid1;low=1;low1=1;high=t->length;high1=t->length;flag1=0;flag=0;while(low<=high){mid=(low+high)/2;if(cs1<t->data[mid].cs)high=mid-1;else{if(cs1>t->data[mid].cs)low=mid+1;else{flag=mid;break;}}}if(flag==0)cout<<"没有该成绩的学生!"<<endl;else{cout<<"---------该学生的信息:-----------"<<endl;Display(t,flag);}}void N_Sort(SNode *t,int n) //直接插入法对学生的姓名进行排序{int i;int j;DataType p;for(i=2;i<=n;i++){if(t->data[i].name<t->data[i-1].name){t->data[0].name=t->data[i].name;for(j=i-1;t->data[0].name<t->data[j].name;j--){p=t->data[j];t->data[j]=t->data[j+1];t->data[j+1]=p;}}}}void C_Sort(SNode *t,int n){int i,j,k;for(i=1;i<n;i++){for(k=i,j=i+1;j<=n;j++)if(t->data[j].cs<t->data[k].cs)k=j;if(i!=k){t->data[0]=t->data[k];t->data[k]=t->data[i];t->data[i]=t->data[0];}}}void S_Sort(SNode *t,int n) //冒泡法对数据结构排序{int i,j;int swap;for(i=1;i<n;i++){swap=0;for(j=1;j<=n-i;j++)if(t->data[j].ss>t->data[j+1].ss){t->data[0]=t->data[j];t->data[j]=t->data[j+1];t->data[j+1]=t->data[0];swap=1;}if(swap==0)break;}}int main(){SNode s;Init(&s);int i;int a[8]={1,2,3,4,5,6,7,8};string b[8]={"王立","张秋","刘丽","王通","赵阳","李艳","钱娜","孙胜"};int c[8]={03511,03511,03511,03511,03511,03511,03511,03511};int d[8]={85,78,90,75,60,58,95,45};int e[8]={76,88,79,86,71,68,89,60};Create(&s,a,b,c,d,e,8);string names; int score;cout<<"请输入您要查找的学生的姓名:"; cin>>names;N_Search(&s,names);cout<<"请输入您要查找的学生的姓名:"; cin>>names;N_Search(&s,names);cout<<"--------姓名排序--------"<<endl;cout<<"********排序前的输出结果:********"<<endl;for(i=1;i<9;i++)Display(&s,i);N_Sort(&s,8);cout<<"********排序后的输出结果:********"<<endl;for(i=1;i<9;i++)Display(&s,i);cout<<"------C++成绩排序--------"<<endl;cout<<"********排序前的输出结果:********"<<endl;for(i=1;i<9;i++)Display(&s,i);C_Sort(&s,8);cout<<"********排序后的输出结果:********"<<endl;for(i=1;i<9;i++)Display(&s,i);cout<<"---------二分查找法对C++成绩的查找----------"<<endl;cout<<"请输入您要查找的学生的C++成绩:"; cin>>score;C_Search(&s,score);cout<<"请输入您要查找的学生的C++成绩:"; cin>>score;C_Search(&s,score);cout<<"-------数据结构排序-------"<<endl;cout<<"********排序前的输出结果:********"<<endl;for(i=1;i<9;i++)Display(&s,i);cout<<"********排序后的输出结果:********"<<endl;S_Sort(&s,8);for(i=1;i<9;i++)Display(&s,i);}试验结果:直接插入法按姓名对学生的信息排序:排序前:排序后:直接选择法对C++成绩进行排序:排序前:排序后:二分法队学生的成绩进行查找:冒泡法对学生的数据结构成绩进行排序:排序前:排序后:四、实验总结1、关键码是数据元素中某个数据项的值,它可以标识一个数据元素,能唯一确定一个数据元素的关键码为主关键码,不能唯一确定一个数据元素的关键码为次关键码。

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

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

cout<<"********排序前的输出结果:********"<<endl; for(i=1;i<9;i++) Display(&s,i); cout<<"********排序后的输出结果:********"<<endl; S_Sort(&s,8); for(i=1;i<9;i++) Display(&s,i); } 试验结果: 直接插入法按姓名对学生的信息排序: 排序前:
cout<<setw(8)<<"学号"<<setw(10)<<"姓名"<<setw(10)<<"班级 " <<setw(10)<<"C++成绩"<<setw(15)<<"数据结构成绩"<<endl; cout.setf(ios::right); cout<<setw(8)<<t->data[i].num<<setw(10)<<t>data[i].name<<setw(10)<<t->data[i].classnum<<setw(10)<<t>data[i].cs<<setw(15)<<t->data[i].ss<<endl; } void N_Search(SNode *t,string kn) //按姓名查找 { int i; i=t->length; t->data[0].name=kn; while(t->data[i].name!=kn) i--; if(i==0) cout<<"······对不起,没有该姓名的学生!········"<<endl; else { cout<<"····找到了 !······"<<endl; Display(t, i); } } void C_Search(SNode *t,int cs1) //二分查找C成绩 { int i=1; int flag,flag1; int low,high,mid,low1,high1,mid1; low=1;low1=1; high=t->length;high1=t->length; flag1=0; flag=0; while(low<=high) { mid=(low+high)/2; if(cs1<t->data[mid].cs) high=mid-1; else {
if(cs1>t->data[mid].cs) low=mid+1; else { flag=mid; break; } } } if(flag==0) cout<<"没有该成绩的学生!"<<endl; else { cout<<"---------该学生的信息:-----------"<<endl; Display(t,flag); } } void N_Sort(SNode *t,int n) //直接插入法对学生的姓名进行排 序 { int i; int j; DataType p; for(i=2;i<=n;i++) { if(t->data[i].name<t->data[i-1].name) { t->data[0].name=t->data[i].name; for(j=i-1;t->data[0].name<t->data[j].name;j--) { p=t->data[j]; t->data[j]=t->data[j+1]; t->data[j+1]=p; } } } }
void C_Sort(SNode *t,int n) { int i,j,k; for(i=1;i<n;i++) { for(k=i,j=i+1;j<=n;j++) if(t->data[j].cs<t->data[k].cs) k=j; if(i!=k) { t->data[0]=t->data[k]; t->data[k]=t->data[i]; t->data[i]=t->data[0]; } } } void S_Sort(SNode *t,int n) //冒泡法对数据结构排序 { int i,j; int swap; for(i=1;i<n;i++) { swap=0; for(j=1;j<=n-i;j++) if(t->data[j].ss>t->data[j+1].ss) { t->data[0]=t->data[j]; t->data[j]=t->data[j+1]; t->data[j+1]=t->data[0]; swap=1; } if(swap==0) break; } } int main() {
n)
#include <string> #include <iomanip> using namespace std; const int MAX=100; typedef struct { int num; string name; int classnum; int cs; int ss; }DataType; typedef struct { DataType data[MAX]; int length; }SNode; void Init(SNode *t) { t->length=0; } void Create(SNode *t,int a[],string b[],int c[],int d[],int e[],int //创建 { for(int i=0;i<n;i++) { t->data[i+1].num=a[i]; t->data[i+1].name=b[i]; t->data[i+1].classnum=c[i]; t->data[i+1].cs=d[i]; t->data[i+1].ss=e[i]; t->length++; } } void Display(SNode *t,int i) //输出学生的相关信息 { cout.setf(ios::right);
实验五:查找和排序
班级 B09513 学号 200940 姓名 一、实验目的 1 掌握查找的不同方法,并能用高级语言实现查找算法。 2 熟练掌握顺序表和有序表的顺序查找和二分查找方法。 3 掌握排序的不同方法,并能用高级语言实现排序算法。 4 熟练掌握顺序表的选择排序、冒泡排序和直接插入排序算法的实 现。 二、实验内容 1 创建给定的静态查找表。表中共包含十条学生信息,信息如下: 学号 姓名 班级 C++ 数据结构 1 王立 03511 85 76 2 张秋 03511 78 88 3 刘丽 03511 90 79 4 王通 03511 75 86 5 赵阳 03511 60 71 6 李艳 03511 58 68 7 钱娜 03511 95 89 8 孙胜 03511 45 60 2 使用顺序查找方法,从查找表中查找姓名为赵阳和王夏的学生。 如果查找成功,则显示该生的相关信息;如果查找不成功,则给出相应 的提示信息。 3 使用直接插入排序方法,按姓名对学生信息进行排序。输出排序 前和排序后的学生信息表,验证排序结果。 4 使用直接选择排序方法,对学生信息中的C成绩进行排序。输出排 序前和排序后的学生信息表,验证排序结果。 5使用二分查找方法,从查找表中查找C成绩为79和80的学生。如果 查找成功,则显示该生的相关信息;如果查找不成功,则给出相应的提 示信息。 6 使用冒泡排序方法,对学生信息中的数据结构成绩进行排序。输 出排序前和排序后的学生信息表,验证排序结果。 7 编写一个主函数,将上面函数连在一起,构成一个完整程序。 8 将实验源程序调试并运行。 注意:每完成一个操作必须进行输出,以验证操作的正确性。 三、实验结果 #include <iostream>
排序后:

直接选择法对C++成绩进行排序: 排序前:
排序后:
二分法队学生的成绩进行查找:
冒泡法对学生的数据结构成绩进行排序: 排序前:
排序后:
四、实验总结 1、关键码是数据元素中某个数据项的值,它可以标识一个数据元 素,能唯一确定一个数据元素的关键码为主关键码,不能唯一确定一个 数据元素的关键码为次关键码。 2、此实验所用的是静态查找表,静态查找表仅对查找表进行查找操 作,而不能改变查找表。 3、折半查找也称为二分查找,但是它要求查找表必须是顺序表,且 表中的数据元素按关键码有序排列。 4、排序方法的好坏取决于两个因素:一算法执行所需要的时间,而 执行所需要的辅助存储空间。算法的时间主要由纪录的比较次数和移动 次数来决定。 5、直接排序,折半排序,冒泡排序和选择排序都需要一个辅助存储 单元。
SNode s; Init(&s); int i; int a[8]={1,2,3,4,5,6,7,8}; string b[8]={"王立","张秋","刘丽","王通","赵阳","李艳","钱娜","孙 胜"}; int c[8]={03511,03511,03511,03511,03511,03511,03511,03511}; int d[8]={85,78,90,75,60,58,95,45}; int e[8]={76,88,79,86,71,68,89,60}; Create(&s,a,b,c,d,e,8); string names; int score; cout<<"请输入您要查找的学生的姓名:"; cin>>names; N_Search(&s,names); cout<<"请输入您要查找的学生的姓名:"; cin>>names; N_Search(&s,names); cout<<"--------姓名排序--------"<<endl; cout<<"********排序前的输出结果:********"<<endl; for(i=1;i<9;i++) Display(&s,i); N_Sort(&s,8); cout<<"********排序后的输出结果:********"<<endl; for(i=1;i<9;i++) Display(&s,i); cout<<"------C++成绩排序--------"<<endl; cout<<"********排序前的输出结果:********"<<endl; for(i=1;i<9;i++) Display(&s,i); C_Sort(&s,8); cout<<"********排序后的输出结果:********"<<endl; for(i=1;i<9;i++) Display(&s,i); cout<<"---------二分查找法对C++成绩的查找----------"<<endl; cout<<"请输入您要查找的学生的C++成绩:"; cin>>score; C_Search(&s,score); cout<<"请输入您要查找的学生的C++成绩:"; cin>>score; C_Search(&s,score); cout<<"-------数据结构排序-------"<<endl;
相关文档
最新文档