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

合集下载

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

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

实验报告课程名称数据结构实验名称查找与排序得实现系别专业班级指导教师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.学会针对所给问题选用最适合的算法。

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);}。

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

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

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

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

实验五-查找和排序实验报告 查找及排序实验

实验五-查找和排序实验报告 查找及排序实验

并对调试过程中的问题进行分析,对执
输入你晏査找的关键字:阴
第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.熟练掌握顺序表和有序表的顺序查找和二分查找方法。

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

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

二、实验内容1.学生信息如下:学号姓名数据结构程序设计1 王立76 882 张秋88 773 刘丽79 654 王通86 855 赵阳71 906 李艳68 707 钱娜89 958 孙胜60 762.创建顺序查找表,输入学生信息。

【选做:也可以将学生信息存入文件,直接从文件读取学生信息】3.使用顺序查找方法按姓名查找学生。

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

4.使用二分查找方法,查找学生学号信息。

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

5.使用直接插入排序方法,对学生信息中的姓名进行排序。

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

6.使用直接选择排序方法,对学生信息中的数据结构成绩进行排序。

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

7.使用冒泡排序方法,对学生信息中的程序设计成绩进行排序。

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

8.编写一个菜单,来实现各项功能的选择。

*******************学生成绩管理系统****************** 1.信息初始化2.顺序查找** 3.二分查找4.直接插入排序** 5.冒泡排序6.直接选择排序** 0.退出*****************************************************9.利用工程完成本次实验任务,各个功能分别放到一个函数中。

三、实验结果#include<iostream>#include<string>using namespace std;# define size 10struct student{string num;string name;string classnum;int datascore;int cxscore;};struct seqlist{student stu[size];int len;};void create_seq(seqlist &L){int n;cout<<"请输入学生的人数:";cin>>n;L.len=n;cout<<endl;cout<<"请输入学生信息:"<<endl;cout<<"学号"<<" "<<"姓名"<<" "<<"数据结构"<<" "<<"程序设计"<<endl;for(int i=1;i<=L.len;i++){cin>>L.stu[i].num>>L.stu[i].name>>L.stu[i].datascore>>L.stu[i].cxscore;}}void display(seqlist L){cout<<"学号"<<" "<<"姓名"<<" "<<"数据结构"<<" "<<"程序设计"<<endl;for(int i=1;i<=L.len;i++){cout<<L.stu[i].num<<" "<<L.stu[i].name<<" "<<L.stu[i].datascore<<" "<<L.stu[i].cxscore<<endl;}cout<<endl;}void seq_search(seqlist L,string n){int i=1;while(i<=L.len&&L.stu[i].name!=n){i++;}if(i>L.len){cout<<"该生不存在"<<endl;return;}cout<<L.stu[i].num<<" "<<L.stu[i].name<<" "<<L.stu[i].datascore<<" "<<L.stu[i].cxscore<<endl;}void bin_search(seqlist L,string n){int low,high,mid;low=1;high=L.len;while(low<=high){mid=(low+high)/2;if(L.stu[mid].num==n){cout<<L.stu[mid].num<<" "<<L.stu[mid].name<<" "<<L.stu[mid].datascore<<" "<<L.stu[mid].cxscore<<endl;return;}else if(n<L.stu[mid].num){high=mid-1;}else{low=mid+1;}}cout<<"该学生不存在"<<endl;}void selectsort(seqlist L){int k;student temp;for(int i=1;i<=L.len-1;i++){k=i;for(int j=i+1;j<=L.len;j++){if(L.stu[j].datascore<L.stu[k].datascore)k=j;}if(k!=i){temp=L.stu [i];L.stu[i]=L.stu[k];L.stu[k]=temp;}}display(L);}void bubblesort(seqlist L){int i,j,flag=1;student w;for(i=1;(i<=L.len-1)&&(flag);i++){flag=0;for(j=L.len;j>=j+1;j--)if(L.stu[j].cxscore<L.stu[j-1].cxscore){w=L.stu[j];L.stu[j]=L.stu[j-1];L.stu[j-1]=w;flag=1;}}display(L);}void insertsort2(seqlist L){int i,j;for(i-2;i<=L.len;i++)if(L.stu[i].name<L.stu[i-1].name){L.stu[0]=L.stu[i];for(j=i-1;L.stu[0].name<L.stu[j].name;j--)L.stu[j+1]=L.stu[j];L.stu[j+1]=L.stu[0];}cout<<"排序后学生的信息如下:"<<endl;display(L);}int main(){seqlist L;cout<<"创建顺序表"<<endl;create_seq(L);cout<<"输出顺序表"<<endl;display(L);7 cout<<"顺序查找"<<endl;seq_search(L,"赵阳");seq_search(L,"王通");cout<<"折半查找"<<endl;bin_search(L,"7");bin_search(L,"12");cout<<"直接插入排序"<<endl;insertsort2(L);cout<<"直接选择排序"<<endl;selectsort(L);cout<<"冒泡排序"<<endl;bubblesort(L);return 0;}这个代码没法运行出来,vc6显示有一个错误。

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

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

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

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

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

二、详细设计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>根据提示输入股票代码及交易日期,以空格隔开。

实习五:查找与排序

实习五:查找与排序

实习五:查找与排序
实验内容:
1.按照要求建立相应的数组。

2.使用起泡排序法对该数组作非递减排序,并输出排序过程中各趟
的结果以及最终的结果。

3.对排好序的数组采用折半查找法查找关键字值等于给定值的数据
单元在数组中所处的位置(以下标表示),同时输出查找过程中各趟的指针low、high及mid的位置(以下标表示)。

要求按不同的给定值做两次。

注意要对讲义中给出的折半查找算法作相应的改写。

实验要求:
要求建立的数组其值如下:{ 79,46,56,38,56,31,80 }。

折半查找时的给定值:第一次是79,第二次是50。

输入输出时应同时显示必要的说明。

当操作不合理或不能完成时,程序应能处理并输出相应信息。

附:
1.相关说明和数据结构
#include<stdio.h> //需要的头文件
int V[7];
2. 主程序的参考算法
void main()
{
{ 对V[n]按要求进行初始化; }
BubbleSort (V, n); //起泡排序,并按要求输出各趟的结果
scanf(“%d”, kval ); //输入待查关键字值
Search_Bin (V, n, kval ); //要求输出各趟中各指针的位置
}。

查找和排序实验报告

查找和排序实验报告

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


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

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

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

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

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

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

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

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

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

数据结构实验五 查找的实现

数据结构实验五   查找的实现

实验五查找的实现一、实验内容1、建立一个线性表,对表中数据元素存放的先后次序没有任何要求。

输入待查数据元素的关键字进行查找。

为了简化算法,数据元素只含一个整型关键字字段,数据元素的其余数据部分忽略不考虑。

建议采用前哨的作用,以提高查找效率。

2、查找表的存储结构为有序表,输入待查数据元素的关键字利用折半查找方法进行查找。

此程序中要求对整型量关键字数据的输入按从小到大排序输入。

二、源代码和执行结果1、#include<iostream>using namespace std ;#define MAX 100#define KeyType inttypedef struct{KeyType key ;}DataType ;typedef struct{DataType elem[MAX] ;int length ;}SeqTable , *PSeqTable ;PSeqTable Init_SeqTable(){PSeqTable p = (PSeqTable)malloc(sizeof(SeqTable)) ;if(p != NULL){p->length = 0 ;return p ;}else{cout<<"Out of space!"<<endl ;return NULL ;}}int insert_SeqTable(PSeqTable p ,KeyType x) {if(p->length >= MAX){cout<<"overflow!"<<endl ;return 0 ;}p->elem[p->length].key = x ;p->length ++ ;return 1 ;}int SeqSearch(SeqTable s ,KeyType k){int n , i = 0 ;n = s.length ;s.elem[n].key = k ;while(s.elem[i].key != k)i ++ ;if(i == n)return -1 ;elsereturn i ;}void main(){PSeqTable p ;int i , n ;KeyType a ;p = Init_SeqTable() ;cout<<"请输入数据个数:" ;cin>>n ;cout<<"请输入数据:"<<endl ;for(i = 0 ; i < n ; i ++){cin>>a ;insert_SeqTable(p , a) ;}cout<<"请输入要查找的数据,输入32767结束:" ;cin>>a ;while(a != 32767){i =SeqSearch(*p , a) ;if(i == -1){cout<<"无此数据!请重新输入:"<<endl ;cin>>a ;}else{cout<<"该数据的位置是:"<<i+1<<endl ;cout<<"请输入要查找的数据:" ;cin>>a ;}}}2、#include<iostream>using namespace std ;#define MAX 100#define KeyType inttypedef struct{KeyType key ;}DataType ;typedef struct{DataType elem[MAX] ;int length ;}BinTable , *PBinTable ;PBinTable Init_BinTable(){PBinTable p = (PBinTable)malloc(sizeof(BinTable)) ;if(p != NULL){p->length = 0 ;return p ;}else{cout<<"Out of space!"<<endl ;return NULL ;}}int insert_BinTable(PBinTable p ,KeyType x){if(p->length >= MAX){cout<<"overflow!"<<endl ;return 0 ;}p->elem[p->length].key = x ;p->length ++ ;return 1 ;}int BinSearch(BinTable s ,KeyType k){int low , mid , high ;low = 0 ;high = s.length-1 ;while(low <= high){mid = (low+high)/2 ;if(s.elem[mid].key == k)return mid ;else if(s.elem[mid].key > k)high = mid - 1 ;elselow = mid +1 ;}return -1 ;}void main(){PBinTable p ;int i , n ;KeyType a ;p = Init_BinTable() ;cout<<"请输入数据个数:" ;cin>>n ;cout<<"请按从小到大的顺序输入数据:"<<endl ;for(i = 0 ; i < n ; i ++){cin>>a ;insert_BinTable(p , a) ;}cout<<"请输入要查找的数据,输入32767结束:" ;cin>>a ;while(a != 32767){i =BinSearch(*p , a) ;if(i == -1){cout<<"无此数据!请重新输入:"<<endl ;cin>>a ;}else{cout<<"该数据的位置是:"<<i+1<<endl ;cout<<"请输入要查找的数据:" ;cin>>a ;}}}。

数据结构实验报告排序

数据结构实验报告排序

数据结构实验报告排序数据结构实验报告:排序引言:排序是计算机科学中常见的算法问题之一,它的目标是将一组无序的数据按照特定的规则进行排列,以便于后续的查找、统计和分析。

在本次实验中,我们将学习和实现几种常见的排序算法,并对它们的性能进行比较和分析。

一、冒泡排序冒泡排序是最简单的排序算法之一,它通过不断交换相邻的元素,将较大(或较小)的元素逐渐“冒泡”到数组的一端。

具体实现时,我们可以使用两层循环来比较和交换元素,直到整个数组有序。

二、插入排序插入排序的思想是将数组分为两个部分:已排序部分和未排序部分。

每次从未排序部分中取出一个元素,插入到已排序部分的适当位置,以保持已排序部分的有序性。

插入排序的实现可以使用一层循环和适当的元素交换。

三、选择排序选择排序每次从未排序部分中选择最小(或最大)的元素,与未排序部分的第一个元素进行交换。

通过不断选择最小(或最大)的元素,将其放置到已排序部分的末尾,从而逐渐形成有序序列。

四、快速排序快速排序是一种分治的排序算法,它通过选择一个基准元素,将数组划分为两个子数组,其中一个子数组的所有元素都小于等于基准元素,另一个子数组的所有元素都大于基准元素。

然后对两个子数组分别递归地进行快速排序,最终将整个数组排序。

五、归并排序归并排序也是一种分治的排序算法,它将数组划分为多个子数组,对每个子数组进行排序,然后再将排好序的子数组合并成一个有序的数组。

归并排序的实现可以使用递归或迭代的方式。

六、性能比较与分析在本次实验中,我们对以上几种排序算法进行了实现,并通过对不同规模的随机数组进行排序,比较了它们的性能。

我们使用了计算排序时间的方式,并记录了每种算法在不同规模下的运行时间。

通过对比实验结果,我们可以得出以下结论:1. 冒泡排序和插入排序在处理小规模数据时表现较好,但在处理大规模数据时性能较差,因为它们的时间复杂度为O(n^2)。

2. 选择排序的时间复杂度也为O(n^2),与冒泡排序和插入排序相似,但相对而言,选择排序的性能稍好一些。

数据结构_查找和排序

数据结构_查找和排序

西北工业大学《数据结构》实验报告实验题目:排序与查找班号:09040802 学号:2008302360 姓名:崔昌浩完成时间:2011.1.12查找和排序一.需求分析1.对以下4种常用的查找算法进行比较:顺序查找、折半查找、索引查找、二叉排序树查找。

2.对以下6种常用的内部排序算法进行比较:起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

3.待查找或排序的表长不小于5000;其中的数据要用伪随机数产生程序产生;至少要用5 组不同的输入数据作比较;比较的指标为有关键字参加的比较次数或关键字的移动次数(关键字交换计为3 次移动)。

4.要考虑并统计一些特殊情况下(如完全正序、完全逆序)情况下的关键字比较次数或移动次数;要考虑对于随机数据执行某种算法(如折半查找、索引查找、二叉排序树查找)时需要的额外计算。

二.概要设计1.各种查找排序的概念如下:①.直接排序算法描述:经过i-1遍处理后,L[1..i-1]己排好序。

第i遍处理仅将L[i]插入L[1..i-1]的适当位置,使得L[1..i]又是排好序的序列。

要达到这个目的,我们可以用顺序比较的方法。

首先比较L[i]和L[i-1],如果L[i-1]≤ L[i],则L[1..i]已排好序,第i遍处理就结束了;否则交换L[i]与L[i-1]的位置,继续比较L[i-1]和L[i-2],直到找到某一个位置j(1≤j≤i-1),使得L[j] ≤L [j+1]时为止。

②.冒泡排序算法描述:核心思想是扫描数据清单,寻找出现乱序的两个相邻的项目。

当找到这两个项目后,交换项目的位置然后继续扫描。

重复上面的操作直到所有的项目都按顺序排好。

③.快速排序算法描述:首先检查数据列表中的数据数,如果小于两个,则直接退出程序。

如果有超过两个以上的数据,就选择一个分割点将数据分成两个部分,小于分割点的数据放在一组,其余的放在另一组,然后分别对两组数据排序。

通常分割点的数据是随机选取的。

查找和排序 实验报告

查找和排序 实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验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;}。

实验报告_排序与查找

实验报告_排序与查找

电子科技大学实验报告课程名称:数据结构与算法学生姓名:学号:点名序号:指导教师:实验地点:基础实验大楼实验时间: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右边的表中。

查找与排序实验报告

查找与排序实验报告

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

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

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

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)
通过本次实验,我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候,需要我把理论变为上机调试,这无疑是最难的部分,有时候我想不到合适的算法去解决问题,就请教同学,上网搜索,逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高,以前我很不懂这门课,觉得它很难,但是现在明白了一些代码的应用,明白了每个程序都有相似的特点,通用的结构,也学会了静下心来写程序。我以后还要把没学好的知识点补齐,克服编程过程中的难关,打实基础,向更深入的层次发展。

数据结构 试验五 查找与排序

数据结构 试验五 查找与排序
}
return (0);
}
void main()//main() function
{ int i,key;
SSTable ST;
ST.elem=(KeyType *)malloc(sizeof(KeyType));
cout<<endl<<endl<<"Search_Seq.cpp";
cout<<endl<<"==============";
int InserBST(BiTree &T,KeyType key) //SearchBST()
{
BiTree f=NULL,s;
if(!SearchBST(T,key,f)) //查找不成功
{
s=(BiTree)malloc(sizeof(BiTree));
s->data=key;
s->lchild=s->rchild=NULL;
{
if(!T)
{ p=f;
return (0);
}
else if(key==T->data)
{ p=T;
return (1);
}
else if(key<T->data)
SearchBST(T->lchild,key,T);
else
SearchBST(T->rchild,key,T);
}
/*二叉排序树中插入算法*/
//This function is to find location of the inputed element in SSTbale
# include <malloc.h>

数据结构(B)上机实验五__查找和排序

数据结构(B)上机实验五__查找和排序

数据结构上机实验五实验内容:查找表和内部排序的基本算法实验要求:1) 基本操作要作为函数被调用,做到模块化.2) 基本上实现每个实验题目的要求.分组要求:可单独完成,也可两人一组。

实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对查找算法的理解.评分标准:1) 只完成第一和第二题,根据情况得4,5-分;2)完成前3题,根据情况得5,6分;3)在2)基础上,选做四)中题目,根据情况得6,7分。

题目:一)顺序表与有序表的查找(1)建立一个顺序表,利用教材9.1.1的顺序查找算法进行查找;(2)建立一个有序表,利用折半法进行查找;(3)试将把(2)中的折半法改用递归算法实现;二)二叉排序树的一些基本操作(1)利用二叉链表的存储形式,从键盘输入建立一棵二叉排序树;(2)对(1)中建立的二叉排序树进行中序遍历并打印;(3)编写算法,判断一棵二叉树是否为二叉排序树。

(4)在(1)建立的二叉排序树中,查找一个树中不存在的关键字后并插入,之后打印该树;三)排序(1)插入排序——已知序列{17,18,60,40,7,32,73,65,85}建立一个顺序表,采用插入排序算法的实现升序排序,打印排序结果;(2)交换排序——已知序列{503,87,512,61,908,170,897,275,652,462}(1)建立一个顺序表,采用冒泡排序法实现升序排序,并打印每趟排序结果;(2)建立一个顺序表,采用快速排序法实现升序排序,并打印每趟排序结果,与(1)做比较;(3)选择排序——已知序列{42,13,24,91,23,16,05,88}利用简单选择排序,实现上述序列的降序排序;四)选作题(1)试构造一个算法,从键盘输入一组关键字,按哈希函数H(key) = key MOD 13和链地址法处理冲突构来造哈希表,能对关键字进行查找并显示。

如(19,14,23,1,68,20,84,27,55,11,10,79,33).(2)已知序列{503,87,512,61,908,170,897,275,652,462},采用基数排序法对其作升序排序,打印每一趟的结果。

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

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

要求:
1)设计三种输入数据序列:正序、反序、无序
2)修改程序:
a)将序列采用手工输入的方式输入
b)增加记录比较次数、移动次数的变量并输出其值,分析三种序列状态的算法时间复杂

2.对给定的有序查找集合,通过折半查找与给定值k相等的元素。

3.在冒泡算法中若设置一个变量lastExchangeIndex来标记每趟排序时经过交换的最后位置,
算法如何改进?
三、设计与编码
1.本实验用到的理论知识
2.算法设计
3.编码
package sort_search;
import java.util.Scanner;
public class Sort_Search {
//冒泡排序算法
public void BubbleSort(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(int j=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 static int 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();
int t[]=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.在调试程序的过程中遇到什么问题,是如何解决的?
问题:在计算比较次数和移动次数时,计算数据明显出错。

原因:在进行移动和比较的过程中,没有更新标志,导致计数出错。

解决办法:在比较和移动的过程中,有进行比较和移动的操作时,更新标志。

然后按标志计数。

2.设计了哪些测试数据?预计结果是什么?说明:
测试了int类型数据:241 17 23 45 37 4 31 43 11 89 33 101 177
预计排序后结果为:4 11 17 23 31 33 37 43 45 89 101 177 241
比较次数:①无序:8次②正序:1次③反序:12次
移动次数:①无序:30次②正序:0次③反序:78次
查找数33的位置为:5
查找数101的位置为:10
查找数100的结果为:查找不到
3.程序运行的结果如何
I.无序输入:
II.正序输入:
III.反序输入:
五、总结与心得
六、思考题
已知奇偶转换排序如下:第一趟对所有奇数的i,将a[i]和a[i+1]进行比较,第二趟对所有偶数的i,将a[i]和a[i+1]进行比较,每次比较时若a[i]>a[i+1],则将二者交换,以后重复上述二趟过程交换进行,直至整个数组有序。

a)试问排序结束的条件是什么?
b)实现上述排序过程的算法如何?(请用自然语言、代码、伪代码写出该算法)。

相关文档
最新文档