软基上机实验报告-查找与排序(拓展题)
实验五-查找和排序实验报告范文查找及排序实验
实验五-查找和排序实验报告范文查找及排序实验-可编辑修改---可编辑修改-实验五查找和排序1、实验目的掌握顺序查找的基本方法掌握简单排序和二分法查找的算法。
2.能运用线性表的查找方法解决实际问题。
2、实验内容1、给出在一个无序表A,采用顺序查找算法查找值为某的元素的算法2、给出一个无序表B,采用简单排序方法使该表递增有序,并采用二分查找算法查找值为某的元素的算法。
3、实验步骤(1)仔细分析实验内容,给出其算法和流程图;(2)用C语言实现该算法;(3)给出测试数据,并分析其结果;(4)在实验报告册上写出实验过程。
4、实验报告要求实验报告要求书写整齐,步骤完整,实验报告格式如下:1、[实验目的]2、[实验设备]3、[实验步骤]4、[实验内容]5、[实验结果(结论)]排序创建二叉捌L「1折半查找算法描述如下:intSearch_Bin(SSTableST,KeyTypekey)low=1;high=ST.length; while(low<=high){mid=(low+high)/2;ifEQ(key,ST.elem[mid].key)returnmid;eleifLT(key,ST.elem[mid].key)high=mid-1;elelow=mid+1;}return0;}//Search_Bin;2.顺序查找算法描述如下:typedeftruct{ElemType某elem;intlength;}SSTable;顺序查找:从表中最后一个记录开始,逐个进行记录的关键字和给定值的比较,若某个记录的关键字和给定值比较相等,则查找成功,找到所查记录;反之,查找不成功。
intSearch_Seq(SSTableST,KeyTypekey){ST.elme[O].key=key;for(i=ST.Iength;!EQ(ST.elem[i].key,key);--i);returni;}(3)写出源程序清单(加适当的注释)。
实验7 查找和排序实验(最后一次实验)
云南大学软件学院实验报告课程:数据结构实验学期:2014-2015学年第一学期任课教师:谢仲文专业:信息安全学号:姓名:成绩:实验7 查找和排序实验(最后一次实验)一、实验目的1.理解有关查找的基本思想以及使用的数据存储结构;2.掌握有关排序的相关算法以及各种算法使用的数据存储结构。
二、实验软硬件环境(CPU、OS、IDE):三、实验任务(要求写出核心代码,并对运行结果截图)对数据序列:{55,13,23,72,109,67,2,78,13}分别实现如下操作:必做:1) 顺序查找;2) 使用直接插入排序或冒泡排序(二选一)、快速排序(必做)对原纪录序列进行排序;3) 对排好序的纪录序列表进行折半查找;4) 利用原纪录序列建立一颗二叉排序树,并在其上实现特定关键字值结点的查找;选做:5) 按照“除留余数法”哈希构造函数和线性探测法的冲突处理方法创建表长为m=11的哈希表;6) 实现5)创建哈希表上的查找。
实验代码:#include<stdio.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define MAX 100typedef int ElemType;typedef struct BTNode //树节点定义{ElemType data;struct BTNode *lchild, *rchild;}BTNode,*BiTree;typedef struct{int key;int flag; //falg=1时表示有关键字,falg=0时表示没有关键字}Elemtype;typedef struct{Elemtype *elem; //动态分配的哈希表的首地址int count; //当前数据元素个数}HashTable;int Sequential_Search(int a[],int n,int key) //顺序查找;{int i=1;a[0]=key; //设置a[0]为关键字值,即哨兵。
软基第五次上机实验报告
软基第五次上机实验报告EX5_1一、程序流程设有序序列的数据元素为: (3, 10, 13, 17, 40, 43, 50, 70)1)编写顺序查找函数2)编写二分查找函数3)在主程序中输入关键字(43和5), 分别调用两种查找函数, 输出结果。
数据结构描述: 二分查找二、程序代码:#include<stdio.h>#include<stdlib.h>#define N 20void search_sequence(int *a,int x){int i;for(i=0;a[i+1]!=0;i++)if (a[i]==x) {printf("Location:%d\n",i);return;}if (a[i+1]==0) printf("Can not find!\n");}void search_dichotomy(int *a,int x){int i=-1,length,head,trail,p;while(a[++i]!=0);length=i;head=0;trail=length-1;while(head<trail){p=(head+trail)/2;if (a[p]<x) head=p+1;else if (a[p]>x) trail=p-1;else {printf("Location:%d\n",p);return;}}printf("Can not find!\n");}void main(){int a[]={3,10,13,17,40,43,50,70,0};printf("顺序查找43和5: \n");search_sequence(&a,43);search_sequence(&a,5);printf("二分查找43和5: \n");search_dichotomy(&a,43);search_dichotomy(&a,5);}三、典型测试数据1: 3, 10, 13, 17, 40, 43, 50, 70四上机时遇到的问题:1、文件头缺失解决办法: 添加#include<stdlib.h>五、实际运行结果:六、个人体会: 在此次实验中让我更深的认识到了顺序查找。
软基上机实验报告-顺序表
一、实验项目名称:ex1_1——基本题:1)首先创建一个顺序表:从键盘读入一组整数(长度小于等于20),按输入顺序放入顺序表,输入以-1结束(注意-1不放到顺序表内);将创建好的顺序表元素依次输出到屏幕上。
2)在已创建好的顺序表中插入一个元素:从键盘读入需插入的元素值和插入位置,调用插入函数完成插入操作;然后将顺序表元素依次输出到屏幕上。
3)在已创建好的顺序表中删除一个元素:从键盘读入欲删除的元素位置(序号),调用删除函数完成删除操作;然后将顺序表元素依次输出到屏幕上。
软件技术基础实验table.cpp二、程序代码#include "stdafx.h"#include "mystruct.h"#include "ui.h"/******************************************************************************************* ** Function name: init_table()** Descriptions : 初始化顺序表,顺序表利用数组作为基础,其特点是需要事先获得全部元素空间,因此本函数的主要功能就是向系统申请足够的空间作为顺序表的存储空间。
涉及的系统函数为:malloc()** 此外,良好的习惯是将空间内的各项数据进行适当的初始化** Input: NONE** Output: NONE** return: 类型:table_t *,返回顺序表的结构指针** Created by :** Created Date :**-------------------------------------------------------------------------** Modified by :** Modified Date:**-------------------------------------------------------------------------*******************************************************************************************/ table_t * init_table( ){table_t * t;t=(table_t *)malloc(sizeof(table_t));t->length = 0;return t;}/******************************************************************************************* ** Function name: free_table()** Descriptions : 释放顺序表空间** 当程序结束时会通过本函数来释放通过malloc获得的顺序表空间** Input: table_t * t; 顺序表指针** Output: NONE** return: 类型:void** Created by :** Created Date :**------------------------------------------------------------------------------------------** Modified by :** Modified Date:**------------------------------------------------------------------------------------------*******************************************************************************************/ void free_table(table_t * t){free(t);}/******************************************************************************************* ** Function name: get_table()** Descriptions : 查询顺序表** 查询顺序表中第i个元素** Input:** table_t * table; 顺序表指针** int index; 查询位置,即第i个元素** Output:** element_t * elem; 元素域指针,用来存放被查询到的元素内容,** (注意,需要将元素全部内容拷贝到该指针所记录的空间中,即,使用memcpy())** return: 类型:int,返回查询是否成功,为0表示找到指定元素,为-1表示没有找到,一般是因为** index指示的位置超出了顺序表的范围** Created by :** Created Date :**-------------------------------------------------------------------------** Modified by :** Modified Date:**-------------------------------------------------------------------------*******************************************************************************************/ int get_table(table_t * table,int index, element_t * elem){//判断index是否超出顺序表范围if(index <= 0 || index > table->length){return -1;}//复制元素内容到指定空间中;memcpy(elem,&(table->data[index-1]),sizeof(element_t));//errorreturn 0;}/******************************************************************************************* ** Function name: add_table()** Descriptions : 将指定元素放入到顺序表的末尾** Input:** table_t * table; 顺序表指针** element_t data; 待放入的元素** Output:** table_t * table; 添加新元素后的顺序表指针** return: 类型:int; 为-1表示放入失败,一般是因为顺序表已经放满,为0表示正确放入** Created by :** Created Date :**-------------------------------------------------------------------------** Modified by :** Modified Date:**-------------------------------------------------------------------------*******************************************************************************************/ int add_table(table_t * table, element_t data){table->data[table->length] = data;table->length ++;return 0;}/******************************************************************************************* ** Function name: insert_table()** Descriptions : 将指定元素插入到顺序表的指定位置之前** Input:** table_t * table; 顺序表指针** element_t data; 待放入的元素** int location; 插入位置,语义是:第X个元素前,,当location大于链表元素总数时,该元素** 将插入到表尾。
查找排序实验报告
查找排序实验报告一、实验目的本次实验的主要目的是深入理解和比较不同的查找和排序算法在性能和效率方面的差异。
通过实际编程实现和测试,掌握常见查找排序算法的原理和应用场景,为今后在实际编程中能够选择合适的算法解决问题提供实践经验。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
计算机配置为:处理器_____,内存_____,操作系统_____。
三、实验内容1、查找算法顺序查找二分查找2、排序算法冒泡排序插入排序选择排序快速排序四、算法原理1、顺序查找顺序查找是一种最简单的查找算法。
它从数组的一端开始,依次比较每个元素,直到找到目标元素或者遍历完整个数组。
其时间复杂度为 O(n),在最坏情况下需要遍历整个数组。
2、二分查找二分查找适用于已排序的数组。
它通过不断将数组中间的元素与目标元素进行比较,将查找范围缩小为原来的一半,直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n),效率较高。
3、冒泡排序冒泡排序通过反复比较相邻的两个元素并交换它们的位置,将最大的元素逐步“浮”到数组的末尾。
每次遍历都能确定一个最大的元素,经过 n-1 次遍历完成排序。
其时间复杂度为 O(n^2)。
4、插入排序插入排序将数组分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的合适位置。
其时间复杂度在最坏情况下为 O(n^2),但在接近有序的情况下性能较好。
5、选择排序选择排序每次从待排序数组中选择最小的元素,与当前位置的元素交换。
经过 n-1 次选择完成排序。
其时间复杂度为 O(n^2)。
6、快速排序快速排序采用分治的思想,选择一个基准元素,将数组分为小于基准和大于基准两部分,然后对这两部分分别递归排序。
其平均时间复杂度为 O(n log n),在大多数情况下性能优异。
五、实验步骤1、算法实现使用Python 语言实现上述六种查找排序算法,并分别封装成函数,以便后续调用和测试。
数据结构实验报告五,查找与排序-
数据结构实验报告五,查找与排序-查找与排序一、实验目的:1.理解掌握查找与排序在计算机中的各种实现方法。
2.学会针对所给问题选用最适合的算法。
3.熟练掌握常用排序算法在顺序表上的实现。
二、实验要求:掌握利用常用的查找排序算法的思想来解决一般问题的方法和技巧,进行算法分析并写出实习报告。
三、实验内容及分析:设计一个学生信息管理系统,学生对象至少要包含:学号、性别、成绩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、学会针对所给问题选用最适合的算法。
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、插入排序每步将一个待排序的记录,按其关键码大小,插入到前面已经排好序的一组记录的适当位置上,直到记录全部插入为止。
查找与排序实验报告
实验四:查找与排序【实验目的】1.掌握顺序查找算法的实现。
2.掌握折半查找算法的实现。
【实验内容】1.编写顺序查找程序,对以下数据查找37所在的位置。
5,13,19,21,37,56,64,75,80,88,922.编写折半查找程序,对以下数据查找37所在的位置。
5,13,19,21,37,56,64,75,80,88,92【实验步骤】1.打开VC++。
2.建立工程:点File->New,选Project标签,在列表中选Win32 ConsoleApplication,再在右边的框里为工程起好名字,选好路径,点OK->finish。
至此工程建立完毕。
3.创建源文件或头文件:点File->New,选File标签,在列表里选C++ SourceFile。
给文件起好名字,选好路径,点OK。
至此一个源文件就被添加到了你刚创建的工程之中。
4.写好代码5.编译->链接->调试#include "stdio.h"#include "malloc.h"#define OVERFLOW -1#define OK 1#define MAXNUM 100typedef int Elemtype;typedef int Status;typedef struct{Elemtype *elem;int length;}SSTable;Status InitList(SSTable &ST ){int i,n;ST.elem = (Elemtype*) malloc (MAXNUM*sizeof (Elemtype)); if (!ST.elem) return(OVERFLOW);printf("输入元素个数和各元素的值:");scanf("%d\n",&n);for(i=1;i<=n;i++){scanf("%d",&ST.elem[i]);}ST.length = n;return OK;}int Seq_Search(SSTable ST,Elemtype key){int i;ST.elem[0]=key;for(i=ST.length;ST.elem[i]!=key;--i);return i;}int BinarySearch(SSTable ST,Elemtype key){int low,high,mid;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(ST.elem[mid]==key)return mid;else if(key<ST.elem[mid])high=mid-1;elselow=mid+1;}return 0;}void main(){int key;SSTable ST;InitList(ST);printf("输入查找的元素的值:");scanf("%d",&key);Seq_Search(ST,key);printf("查找的元素所在的位置:%d\n",Seq_Search(ST,key));printf("输入查找的元素的值:");scanf("%d",&key);BinarySearch(ST,key);printf("查找的元素所在的位置:%d\n",BinarySearch(ST,key));}【实验心得】这是本学期的最后一节实验课,实验的内容是查找与排序。
查找排序操作实验报告
一、实验目的1. 熟悉常用的查找和排序算法,掌握它们的原理和实现方法。
2. 提高编程能力,提高算法分析能力。
3. 通过实验验证查找和排序算法的性能。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm三、实验内容1. 查找算法:二分查找、线性查找2. 排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序四、实验步骤1. 设计一个数据结构,用于存储待查找和排序的数据。
2. 实现二分查找算法,用于查找特定元素。
3. 实现线性查找算法,用于查找特定元素。
4. 实现冒泡排序、选择排序、插入排序、快速排序、归并排序算法,对数据进行排序。
5. 分别测试查找和排序算法的性能,记录时间消耗。
五、实验结果与分析1. 查找算法(1)二分查找算法输入数据:[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]查找目标:11查找结果:成功,位置为5(2)线性查找算法输入数据:[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]查找目标:11查找结果:成功,位置为52. 排序算法(1)冒泡排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](2)选择排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](3)插入排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](4)快速排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8](5)归并排序输入数据:[5, 3, 8, 4, 2]排序结果:[2, 3, 4, 5, 8]3. 性能测试(1)查找算法性能测试二分查找算法在数据量较大的情况下,查找效率明显优于线性查找算法。
(2)排序算法性能测试在数据量较大的情况下,快速排序和归并排序的性能明显优于冒泡排序、选择排序和插入排序。
排序和查找的实验报告
排序和查找的实验报告实验报告:排序和查找引言排序和查找是计算机科学中非常重要的基本算法。
排序算法用于将一组数据按照一定的顺序排列,而查找算法则用于在已排序的数据中寻找特定的元素。
本实验旨在比较不同排序和查找算法的性能,并分析它们的优缺点。
实验设计为了比较不同排序算法的性能,我们选择了常见的几种排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。
在查找算法的比较实验中,我们选择了顺序查找和二分查找两种常见的算法。
同样地,我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。
实验结果在排序算法的比较实验中,我们发现快速排序和归并排序在大多数情况下表现最好,它们的平均执行时间和空间占用都要优于其他排序算法。
而冒泡排序和插入排序则表现较差,它们的执行时间和空间占用相对较高。
在查找算法的比较实验中,二分查找明显优于顺序查找,尤其是在数据规模较大时。
二分查找的平均执行时间远远小于顺序查找,并且占用的空间也更少。
结论通过本实验的比较,我们得出了一些结论。
首先,快速排序和归并排序是较优的排序算法,可以在大多数情况下获得较好的性能。
其次,二分查找是一种高效的查找算法,特别适用于已排序的数据集。
最后,我们也发现了一些排序和查找算法的局限性,比如冒泡排序和插入排序在大数据规模下性能较差。
总的来说,本实验为我们提供了对排序和查找算法性能的深入了解,同时也为我们在实际应用中选择合适的算法提供了一定的参考。
希望我们的实验结果能够对相关领域的研究和应用有所帮助。
查找、排序的应用实验1
淮海工学院计算机科学系实验报告书课程名:《数据结构》题目:查找、排序的应用实验班级:软件081学号:110831123姓名:XX排序、查找的应用实验报告要求1目的与要求:1)查找、排序是日常数据处理过程中经常要进行的操作和运算,掌握其算法与应用对于提高学生数据处理能力和综合应用能力显得十分重要。
2)本次实验前,要求同学完整理解有关排序和查找的相关算法和基本思想以及种算法使用的数据存储结构;3)利用C或C++语言独立完成本次实验内容或题目,程序具有良好的交互性(以菜单机制实现实验程序的交互运行)和实用性;4)本次与第七次实验已合二为一,实验结果在机房现场验收和评分,希望同学们认真对待,并于2009年12月20日按时提交本次实验报告(含电子和纸质报告),任何同学不得拖延。
5)如果验收时间紧张,不能再正课时间完成者,由老师择机决定另行通知专门验收时间。
凡无故不主动或拖延验收者,均按照不及格处理。
5)认真书写实验报告(包括程序清单及相关实验数据与完整运行结果),并于按时提交。
2 实验内容或题目题目:对数据序列(查找表):{55,13,23,72,109,67,2,78,13}分别实现如下操作:1)顺序查找;2)分别使用直接插入排序、冒泡排序、快速排序对原纪录序列进行排序;3)对排好序的纪录序列表进行折半查找;4)利用原纪录序列建立一颗二叉排序树,并在其上实现特定关键字值结点的查找;5)按照“除留余数法”哈希构造函数和线性探测再散列的冲突处理方法创建表长为m=11的哈希表;6)实现5)创建哈希表上的查找。
7)分别简单选择排序、堆排序、链式基数排序算法对数据序列进行排序,并显示排序结果。
3 实验步骤与源程序#include <stdio.h>#include <stdlib.h>#include<malloc.h>#include <math.h>#define LIST_SIZE 20#define KEY_SIZE 6#define RADIX 10#define TRUE 1#define FALSE 0#define SUCCESS 1#define UNSUCCESS -1#define MAX 20typedef char KeyType;typedef int OtherType;typedef struct{KeyType key;OtherType other_data;}RecordType;typedef struct{KeyType key[KEY_SIZE];int type;int next;}RecordType1;typedef struct{RecordType1 R[LIST_SIZE+1];int length;int keynum;}SLinkList;typedef int PVector[RADIX];typedef struct{RecordType r[LIST_SIZE+1]; /* r[0]为工作单元 */ int length;}RecordList;//二叉排序树的创建与查找#define ENDKEY 0typedef struct node{KeyType key ; /*关键字的值*/struct node *lchild,*rchild;/*左右指针*/}BSTNode, *BSTree;/*哈希表的创建*/typedef struct{int key;int flag;//falg=1时表示有关键字,=0时表示没有关键字}Elemtype;typedef struct{Elemtype *elem;//动态分配的哈希表的首地址int sizeindex;//hashsize[sizeindex]为当前容量int count;//当前数据元素个数}HashTable;/*顺序查找*/void SeqSearch(RecordList l, KeyType k)/*在顺序表l中顺序查找其关键字等于k的元素,若找到,则函数值为该元素在表中的位置,否则为0*/{int i;l.r[0].key=k;i=l.length;while (l.r[i].key!=k) i--;if (i>=1){printf("该元素k所在的位置是:");printf("%d",i);}elseprintf("该元素不存在");}//直接插入排序void InsSort(RecordType r[], int length)/* 对记录数组r做直接插入排序,length为数组中待排序记录的数目*/{int i,j;for (i=2; i<=length; i++){r[0]=r[i]; /*将待插入记录存放到监视哨r[0]中*/j=i-1;while (r[0].key< r[j].key ) /* 寻找插入位置 */{r[j+1]= r[j];j=j-1;}r[j+1]=r[0]; /*将待插入记录插入到已排序的序列中*/}} /* InsSort *//*冒泡排序*/void BubbleSort(RecordType r[],int length)/*对记录数组r做冒泡排序,length为数组的长度*/{int x,i,n,change,j;n=length;change=TRUE;for(i=1;i<=n-1&&change;++i){change=FALSE;for(j=1;j<=n-i;++j)if(r[j].key>r[j+1].key){x=r[j].key;r[j]=r[j+1];r[j+1].key=x;change=TRUE;}}}//快速排序int Partition(RecordList &L,int low,int high) //Partition() sub-function { 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];return(low);} //Partition() endvoid Qsort(RecordList &L,int low,int high) //Qsort() sub-function{ int pivotloc;if(low<high){ pivotloc=Partition(L,low,high);Qsort(L,low,pivotloc-1);Qsort(L,pivotloc+1,high);}}void QuickSort(RecordList &L) //QuickSort() sub-function{ Qsort(L,1,L.length); //call Qsort()}/*对排好的序进行折半查找算法*/void BinSrch(RecordList l,KeyType k)/*在有序表l中折半查找其关键字等于k的元素,若找到,则函数值为该元素在表中的位置*/{int low,high,mid;low=1;high=l.length;/*置区间初值*/while(low<=high){mid=(low+high)/2;if (k==l.r[mid].key){printf("找到该元素,其位置为%d",mid);break;}/*找到待查元素*/elseif (k<l.r[mid]. key)high=mid-1;/*未找到,则继续在前半区间进行查找*/ elselow=mid+1;/*继续在后半区间进行查找*/}if(low>high) printf("没有找到该元素");}void InsertBST(BSTree *bst, KeyType key)/*若在二叉排序树中不存在关键字等于key的元素,插入该元素*/{BSTree s;if (*bst == NULL)/*递归结束条件*/{s=(BSTree)malloc(sizeof(BSTNode));/*申请新的结点s*/s-> key=key;s->lchild=NULL;s->rchild=NULL;*bst=s;}elseif (key < (*bst)->key)InsertBST(&((*bst)->lchild), key);/*将s插入左子树*/ elseif (key > (*bst)->key)InsertBST(&((*bst)->rchild), key); /*将s插入右子树*/ }void CreateBST(BSTree *bst)/*从键盘输入元素的值,创建相应的二叉排序树*/{KeyType key;*bst=NULL;scanf("%d", &key);while (key!=ENDKEY) /*ENDKEY为自定义常量*/{InsertBST(bst, key);scanf("%d", &key);}}void PreOrder(BSTree root)/*先序遍历二叉树, root为指向二叉树根结点的指针*/{if (root!=NULL){printf("%d ",root->key); /*输出结点*/PreOrder(root->lchild); /*先序遍历左子树*/PreOrder(root->rchild); /*先序遍历右子树*/}}BSTree SearchBST(BSTree bst, KeyType key)/*在根指针bst所指二叉排序树中,递归查找某关键字等于key的元素,若查找成功,返回指向该元素结点指针,否则返回空指针*/{if (!bst)return NULL;elseif (bst->key == key)return bst;/*查找成功*/elseif (bst->key > key)return SearchBST(bst->lchild, key);/*在左子树继续查找*/elsereturn SearchBST(bst->rchild, key);/*在右子树继续查找*/}BSTNode * DelBST(BSTree t, KeyType k) /*在二叉排序树t中删去关键字为k的结点*/{BSTNode *p, *f,*s ,*q;p=t;f=NULL;while(p) /*查找关键字为k的待删结点p*/{if(p->key==k ) break; /*找到则跳出循环*/f=p; /*f指向p结点的双亲结点*/if(p->key>k)p=p->lchild;elsep=p->rchild;}if(p==NULL) return t; /*若找不到,返回原来的二叉排序树*/if(p->lchild==NULL) /*p无左子树*/{if(f==NULL)t=p->rchild; /*p是原二叉排序树的根*/elseif(f->lchild==p) /*p是f的左孩子*/f->lchild=p->rchild ; /*将p的右子树链到f的左链上*/ else /*p是f的右孩子*/f->rchild=p->rchild ; /*将p的右子树链到f的右链上*/ free(p); /*释放被删除的结点p*/}else /*p有左子树*/{q=p;s=p->lchild;while(s->rchild) /*在p的左子树中查找最右下结点*/{q=s;s=s->rchild;}if(q==p)q->lchild=s->lchild ; /*将s的左子树链到q上*/ elseq->rchild=s->lchild;p->key=s->key; /*将s的值赋给p*/free(s);}return t;} /*DelBST*//*建立哈希表*/int CreatHashTable(HashTable &H,int m){int i,keys,p,len;H.elem = (Elemtype *)malloc(MAX * sizeof(Elemtype));H.sizeindex = MAX;//初始存储容量H.count=0;printf("请输入该组关键字的个数:");scanf("%d",&m);printf("请输入表长len:");scanf("%d",&len);H.sizeindex = len;for(i = 0;i < m;++i){H.elem[i].flag = 0;printf("请输入该组关键字:");for(i = 0;i < m;++i){scanf("%d",&keys);p = keys %m;while(H.elem[p].flag == 1)//处理冲突{int d=1;p = (p +d)% m;d++;}H.elem[p].key = keys;H.elem[p].flag = 1;H.count++;}for(int j=H.count;j<len;j++)H.elem[j].key=0;printf("哈希表创建完毕!\n");printf("下标关键字\n");for(i = 0;i<len;i++){printf("%d ",i);printf("%d",H.elem[i].key);printf("\n");}return SUCCESS;}void SearchHashTable(HashTable H){int keys,p;printf("请输入您要查找的关键字:\n");scanf("%d",&keys);for(int i=0;i<H.count;i++){if( keys == H.elem[i].key)//p是找到的关键字的下标{p=i;}}if(p>-1&&p<H.count){printf("查找成功!\n");printf("该关键字在哈希表中的下标为:%d \n",p); }elseprintf("查找失败,表中无此关键字!\n");/*简单选择排序*/void SelectSort(RecordType r[],int length)/*对记录数组r做简单选择排序,length为数组的长度*/{int i,j,k,x,n=length;for(i=1;i<=n-1;++i){k=i;for(j=i+1;j<=n;++j)if(r[j].key<r[k].key) k=j;if(k!=i){x=r[i].key;r[i]=r[k];r[k].key=x;}}}/*筛选算法*/void sift(RecordType r[],int k,int m)/*假设r[k..m]是以r[k]为根的完全二叉树,且分别以r[2k]和r[2k+1]为根的左右子树为大根堆,调整r[k],使整个序列r[k..m]满足堆的性质*/{int i,t,j,x,finished;t=r[k].key;x=r[k].key;i=k;j=2*i;finished=FALSE;while(j<=m&&!finished){if(j<m&&r[j].key<r[j+1].key) j=j+1;/*若存在右子树,且右子树的关键字大,则沿右分支“筛选”*/if(x>=r[j].key) finished=TRUE; /*筛选完毕*/else{r[i]=r[j];i=j;j=2*i;} /*继续筛选*/}r[i].key=t;/*r[k]填入到恰当位置*/}/*建立堆*/void crt_heap(RecordType r[],int length)/*对记录数组r建堆,length为数组的长度*/{int i,n=length;for(i=n/2;i>=1;--i) /*自第n/2个记录开始进行筛选建堆*/sift(r,i,n);}/*堆排序*/void HeapSort(RecordType r[],int length)/*对r[1..n]进行堆排序,执行本算法后,r中记录按关键字由大到小有序排列*/ {crt_heap(r,length);int i,b,n=length;for(i=n;i>=2;--i){b=r[1].key; /*将堆顶记录和堆中的最后一个记录互换*/r[1]=r[i];r[i].key=b;sift(r,1,i-1); /*进行调整,使r[1..i-1]变成堆*/}}//链式基数排序void Distribute (SLinkList *L,int i,PVector head,PVector tail){int j,p;for(j=0;j<=RADIX-1;++j)head[j]=0;p=L->R[0].next;while(p){j=L->R[p].key[i];if(head[j]==0) head[j]=p;else L->R[tail[j]].next=p;tail[j]=p;p=L->R[p].next;}}void Collect(SLinkList *L,PVector head,PVector tail){int j=0,t;while(head[j]==0)++j;L->R[0].next=head[j];t=tail[j];while(j<RADIX-1){++j;while((j<RADIX-1)&&(head[j]==0))++j;if(head[j]!=0){L->R[t].next=head[j];t=tail[j];}}L->R[t].next=0;}void RadixSort(SLinkList *L ){int n,i,d,j,x,k;printf("输入链表长度 :");scanf("%d",&(L->length));printf("输入最大位数 :");scanf("%d",&(L->keynum));PVector head,tail;n=L->length;for(i=0;i<=n-1;++i) L->R[i].next=i+1; L->R[n].next=0;printf("输入各记录 :");for(j=1;j<=L->length;j++){scanf("%d",&(L->R[j].type));}for(i=1;i<=L->length;i++){x=L->R[i].type;for(j=0;j<L->keynum;j++){L->R[i].key[j]=x%10;x=x/10;}}d=L->keynum;for(i=0;i<L->keynum;++i){Distribute(L,i,head,tail);Collect(L,head,tail);}k=0;printf("排序后为 :");while(L->R[k].next){printf("%d ",L->R[L->R[k].next].type);k=L->R[k].next;}}void main(){int i,j,select,a,flag=1,m=0;printf("1 记录序列 \n2 进行顺序查找 \n3 进行直接排序 \n4 进行冒泡排序 \n5 进行快速排序 \n6进行简单选择排序并输出 \n7进行堆排序并输出 \n");printf("\n8 进行链式基数排序并输出 \n9 对排好序的纪录序列表进行折半查找 \n10 利用原纪录序列建立一颗二叉排序树,并在其上实现特定关键字值结点的查找 \n11 建立哈希表,并对其进行查找 \n12 退出");RecordType r[20];BSTree bst,result,T;RecordList L,Q;int length,k,low;while(flag){printf("请选择:");scanf("%d",&a);switch(a){case 1:printf("请输入待排序记录的长度:"); //交互创建纪录表scanf("%d",&length);for(i=1;i<=length;i++){printf("请输入第%d个记录元素:",i);fflush(stdin);scanf("%d",&j);r[i].key = j;}printf("你输入的各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 2:printf("请输入你要查找的元素k:");fflush(stdin);scanf("%d",&k);L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}SeqSearch(L,k);printf("\n");break;case 3:InsSort(r,length);printf("按直接排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 4:BubbleSort(r,length);printf("按冒泡排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 5:L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}QuickSort(L);printf("进行快速排序后各元素为: ");for(i=1;i<=L.length;i++)printf("%d ",L.r[i].key);printf("\n");break;case 6: SelectSort(r,length);printf("按简单选择排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 7: HeapSort(r,length);printf("按堆排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 8: SLinkList l;RadixSort(&l);printf("\n");break;case 9:InsSort(r,length);L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}printf("请输入要查找的元素:");scanf("%d",&k);BinSrch(L,k);printf("\n");break;case 10:int k;printf("建立二叉排序树,请输入序列(以0结束):\n"); CreateBST(&T);printf("先序遍历输出序列为:");PreOrder(T);printf("\n请输入要查找的元素:");fflush(stdin);scanf("%d",&k);result = SearchBST(T,k);if (result != NULL)printf("存在要查找的元素为%d\n",result->key);elseprintf("未找到!\n");result = DelBST(T,k);// getch();break;case 11:HashTable H;CreatHashTable(H,m);SearchHashTable(H);break;case 12:flag=0;}}}4 测试数据与实验结果(可以抓图粘贴)简单选择排序、堆排序与基数排序,见下图:5 结果分析与实验体会在这次试验中的第7题中前两个排序:简单选择排序与堆排序都直接从书上摘下来的,可对于基数排序,还需要自己写点,比如Order函数,在这里我没有直接调用,他表示用记录中的第i位关键字求相应队列号,而是写在了RadixSort函数中。
查找和排序实验报告
查找和排序实验报告
本实验主要针对以查找、排序算法为主要实现目标的软件开发,进行实验室研究。
实
验包括:冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序,
以及折半查找算法。
实验采用C语言编写,在完成以上排序以及查找方法的基础上,针对实验的工程要求,进行了性能分析,分析了算法空间复杂度以及时间复杂度。
通过首先采用循环方式,构建未排序数组,在此基础上,调用算法实现查找和排序。
也对不同算法进行对比分析,将数据量在100个至30000个之间进行测试。
结果表明:快速排序与希尔排序在时间复杂度方面具有最好的表现,而冒泡排序和选
择排序时间复杂度较高。
在空间复杂度方面,基数排序表现最佳,折半查找的空间复杂度
则比较可观。
在工程应用中,根据对不同排序算法的研究,可以更准确、有效地选择正确的算法实现,有效应用C语言搭建软件系统,提高软件应用效率。
(建议加入算法图)
本实验结束前,可以得出结论:
另外,也可以从这些研究中发现,在使用C语言实现软件系统时,应该重视算法支持
能力,以提高软件应用效率。
由于查找和排序算法在软件应用中占有重要地位,此次实验
对此有贡献,可为未来开发提供支持。
查找排序实验报告总结
一、实验目的本次实验旨在通过编写程序实现查找和排序算法,掌握基本的查找和排序方法,了解不同算法的优缺点,提高编程能力和数据处理能力。
二、实验内容1. 查找算法本次实验涉及以下查找算法:顺序查找、二分查找、插值查找。
(1)顺序查找顺序查找算法的基本思想是从线性表的第一个元素开始,依次将线性表中的元素与要查找的元素进行比较,若找到相等的元素,则查找成功;若线性表中所有的元素都与要查找的元素进行了比较但都不相等,则查找失败。
(2)二分查找二分查找算法的基本思想是将待查找的元素与线性表中间位置的元素进行比较,若中间位置的元素正好是要查找的元素,则查找成功;若要查找的元素比中间位置的元素小,则在线性表的前半部分继续查找;若要查找的元素比中间位置的元素大,则在线性表的后半部分继续查找。
重复以上步骤,直到找到要查找的元素或查找失败。
(3)插值查找插值查找算法的基本思想是根据要查找的元素与线性表中元素的大小关系,估算出要查找的元素应该在大致的位置,然后从这个位置开始进行查找。
2. 排序算法本次实验涉及以下排序算法:冒泡排序、选择排序、插入排序、快速排序。
(1)冒泡排序冒泡排序算法的基本思想是通过比较相邻的元素,将较大的元素交换到后面,较小的元素交换到前面,直到整个线性表有序。
(2)选择排序选择排序算法的基本思想是在未排序的序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
(3)插入排序插入排序算法的基本思想是将一个记录插入到已排好序的有序表中,从而得到一个新的、记录数增加1的有序表。
(4)快速排序快速排序算法的基本思想是选择一个元素作为基准元素,将线性表分为两个子表,一个子表中所有元素均小于基准元素,另一个子表中所有元素均大于基准元素,然后递归地对两个子表进行快速排序。
三、实验结果与分析1. 查找算法通过实验,我们发现:(1)顺序查找算法的时间复杂度为O(n),适用于数据量较小的线性表。
排序查找实验报告
排序查找实验报告排序查找实验报告一、引言排序和查找是计算机科学中非常重要的基础算法。
排序算法可以将一组无序的数据按照某种规则重新排列,而查找算法则可以在大量数据中快速找到目标元素。
本实验旨在通过实际操作和观察,对比不同的排序和查找算法的性能和效果,以便更好地理解和应用这些算法。
二、实验目的本实验的主要目的有以下几点:1. 理解不同排序算法的原理和特点;2. 掌握不同排序算法的实现方法;3. 比较不同排序算法之间的性能差异;4. 理解不同查找算法的原理和特点;5. 掌握不同查找算法的实现方法;6. 比较不同查找算法之间的性能差异。
三、实验过程1. 排序算法实验在排序算法实验中,我们选择了冒泡排序、选择排序和快速排序三种常见的排序算法进行比较。
首先,我们编写了一个随机生成一组无序数据的函数,并将其作为排序算法的输入。
然后,分别使用冒泡排序、选择排序和快速排序对这组数据进行排序,并记录下每种算法的执行时间。
最后,我们比较了三种算法的执行效率和排序结果的准确性。
2. 查找算法实验在查找算法实验中,我们选择了顺序查找、二分查找和哈希查找三种常见的查找算法进行比较。
首先,我们编写了一个生成有序数据的函数,并将其作为查找算法的输入。
然后,分别使用顺序查找、二分查找和哈希查找对这组数据进行查找,并记录下每种算法的执行时间。
最后,我们比较了三种算法的执行效率和查找结果的准确性。
四、实验结果1. 排序算法实验结果经过实验比较,我们发现快速排序算法在大多数情况下具有最好的性能表现,其平均时间复杂度为O(nlogn)。
冒泡排序算法虽然简单,但其时间复杂度为O(n^2),在数据量较大时效率较低。
选择排序算法的时间复杂度也为O(n^2),但相对于冒泡排序,其交换次数较少,因此效率稍高。
2. 查找算法实验结果顺序查找算法是最简单的一种查找算法,其时间复杂度为O(n),适用于小规模数据的查找。
二分查找算法的时间复杂度为O(logn),适用于有序数据的查找。
查找和排序 实验报告
查找和排序实验报告查找和排序实验报告一、引言查找和排序是计算机科学中非常重要的基础算法之一。
查找(Search)是指在一组数据中寻找目标元素的过程,而排序(Sort)则是将一组数据按照特定的规则进行排列的过程。
本实验旨在通过实际操作和实验验证,深入理解查找和排序算法的原理和应用。
二、查找算法实验1. 顺序查找顺序查找是最简单的查找算法之一,它的基本思想是逐个比较待查找元素与数据集合中的元素,直到找到目标元素或遍历完整个数据集合。
在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用顺序查找算法查找指定的目标元素。
实验结果显示,顺序查找的时间复杂度为O(n)。
2. 二分查找二分查找是一种高效的查找算法,它要求待查找的数据集合必须是有序的。
二分查找的基本思想是通过不断缩小查找范围,将待查找元素与中间元素进行比较,从而确定目标元素的位置。
在本实验中,我们首先对数据集合进行排序,然后使用二分查找算法查找指定的目标元素。
实验结果显示,二分查找的时间复杂度为O(log n)。
三、排序算法实验1. 冒泡排序冒泡排序是一种简单但低效的排序算法,它的基本思想是通过相邻元素的比较和交换,将较大(或较小)的元素逐渐“冒泡”到数列的一端。
在本实验中,我们设计了一个包含1000个随机整数的数据集合,并使用冒泡排序算法对其进行排序。
实验结果显示,冒泡排序的时间复杂度为O(n^2)。
2. 插入排序插入排序是一种简单且高效的排序算法,它的基本思想是将数据集合分为已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的适当位置。
在本实验中,我们使用插入排序算法对包含1000个随机整数的数据集合进行排序。
实验结果显示,插入排序的时间复杂度为O(n^2)。
3. 快速排序快速排序是一种高效的排序算法,它的基本思想是通过递归地将数据集合划分为较小和较大的两个子集合,然后对子集合进行排序,最后将排序好的子集合合并起来。
软件基础排序实验报告
一、实验目的1. 理解并掌握几种常见的排序算法的基本原理。
2. 能够熟练运用C语言实现这些排序算法。
3. 分析不同排序算法的时间复杂度和空间复杂度。
4. 比较不同排序算法的效率,了解其适用场景。
二、实验环境1. 操作系统:Windows 102. 编程语言:C语言3. 开发环境:Visual Studio 2019三、实验内容本次实验主要实现了以下排序算法:1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序四、实验步骤1. 定义一个整数数组,用于存放待排序的数据。
2. 根据算法要求,实现排序算法。
3. 对排序后的数组进行输出,验证排序结果。
五、实验结果与分析1. 冒泡排序(1)算法原理:冒泡排序是一种简单的排序算法。
它重复地遍历要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。
遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
(2)代码实现:```cvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```(3)时间复杂度:O(n^2)(4)空间复杂度:O(1)2. 选择排序(1)算法原理:选择排序是一种简单直观的排序算法。
它的工作原理是:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
(2)代码实现:```cvoid selectionSort(int arr[], int n) {int i, j, min_idx;for (i = 0; i < n - 1; i++) {min_idx = i;for (j = i + 1; j < n; j++) {if (arr[j] < arr[min_idx]) {min_idx = j;}}swap(&arr[min_idx], &arr[i]);}}```(3)时间复杂度:O(n^2)(4)空间复杂度:O(1)3. 插入排序(1)算法原理:插入排序是一种简单直观的排序算法。
查找排序算法实验报告(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)。
实验报告_排序与查找
电子科技大学实验报告课程名称:数据结构与算法学生姓名:学号:点名序号:指导教师:实验地点:基础实验大楼实验时间: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)
通过本次实验,我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候,需要我把理论变为上机调试,这无疑是最难的部分,有时候我想不到合适的算法去解决问题,就请教同学,上网搜索,逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高,以前我很不懂这门课,觉得它很难,但是现在明白了一些代码的应用,明白了每个程序都有相似的特点,通用的结构,也学会了静下心来写程序。我以后还要把没学好的知识点补齐,克服编程过程中的难关,打实基础,向更深入的层次发展。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
四、程序流程说明ex5_2:Hash查找——扩展题1)一个班有30位同学,安排装进一个有30个元素的数组,以姓名作为关键字进行哈希存储,具体方法如下:将姓名字符串中的每个字节按ASCII码(中文也支持的哦)加起来,除以30,取得的余数作为元素存放位置(数组下标)。
冲突解决采用线性探查法。
2)输入少于30个学生姓名,按Hash方式存入表中。
3)验证能够按Hash方式找到表中学生,不在表中将提示错误ex5_3:排序——基本题1)编写简单选择法函数2)编写直接插入法函数3)编写冒泡法排序函数4)在主程序中输入一组数据元素,如513,87,512,61,908,170,897,275,653,462,分别调用三种排序函数,输出每趟排序结果。
ex5-4:排序——扩展题编写快速排序函数五、实验程序代码:Ex.2#include<stdio.h>#include<string.h>struct student{char name[20];};struct student s[30];int hash(char *cp)//哈希查找{int sum=0;int n,k;char *q;q=cp;int i;n=strlen(cp);for(i=0;i<n;i++){sum+=(*cp);cp++;}k=sum%30;while(s[k].name[0]!='\0'&&strcmp(s[k].name,q)!=0) {k=(k+1)%30;}if(s[k].name[0]!='\0'){printf("searching success\n");}elseprintf("searching failed\n");return 0;}void hash_save()//哈希表的建立{int i=0,n,sum=0;int k;char name[20];char *p;printf("input the number of the names:\t");scanf("%d",&n);while(n--){printf("input the name:");scanf("%s",name);p=name;k=strlen(p);for(i=0;i<k;i++){sum+=(*p);p++;}k=sum%30;while(s[k].name[0]!='\0'){k=(k+1)%30;}i=0;while(name[i]!='\0'){s[k].name[i]=name[i];i++;}}}main(){void hash_save();int hash(char *cp);hash_save();char name[20];printf("input one name to search:\t");scanf("%s",name);hash(name);printf("input the another name to search:\t");scanf("%s",name);hash(name);}Ex.3#include<stdio.h>#define N 10void selectsort(int s[])//简单选择排序{int i,j,k,small;int swap;for(i=0;i<N-1;i++){small=i;for(j=i+1;j<N;j++){if(s[j]<s[small])small=j;}if(small!=i){swap=s[i];s[i]=s[small];s[small]=swap;}printf("第%d趟:\t",i+1);for(k=0;k<N;k++){printf("%d ",s[k]);}printf("\n");}}void insertsort(int s[])//简单插入排序{int i,j,k;int a;for(i=0;i<N-1;i++){a=s[i+1];j=i;while(j>-1&&a<s[j]){s[j+1]=s[j];j--;}s[j+1]=a;printf("第%d趟:\t",i+1);for(k=0;k<N;k++){printf("%d ",s[k]);}printf("\n");}}void bubblesort(int s[])//冒泡排序{int i,j,k;int swap;for(i=0;i<N-1;i++){for(j=0;j<N-1-i;j++)if(s[j]>s[j+1]){swap=s[j];s[j]=s[j+1];s[j+1]=swap;}}printf("第%d趟:\t",i+1);for(k=0;k<N;k++){printf("%d ",s[k]);}printf("\n");}}main(){void selectsort(int s[]);void insertsort(int s[]);void bubblesort(int s[]);int s1[N]={513,87,512,61,908,170,897,275,653,462};int s2[N]={513,87,512,61,908,170,897,275,653,462};int s3[N]={513,87,512,61,908,170,897,275,653,462};printf("\n简单选择排序:\n");selectsort(s1);printf("\n简单插入排序:\n");insertsort(s2);printf("\n简单冒泡排序:\n");bubblesort(s3);}Ex.3#include<stdio.h>#define N 10void selectsort(int s[])//简单选择排序{int i,j,k,small;int swap;for(i=0;i<N-1;i++){small=i;for(j=i+1;j<N;j++){if(s[j]<s[small])small=j;if(small!=i){swap=s[i];s[i]=s[small];s[small]=swap;}printf("第%d趟:\t",i+1);for(k=0;k<N;k++){printf("%d ",s[k]);}printf("\n");}}void insertsort(int s[])//简单插入排序{int i,j,k;int a;for(i=0;i<N-1;i++){a=s[i+1];j=i;while(j>-1&&a<s[j]){s[j+1]=s[j];j--;}s[j+1]=a;printf("第%d趟:\t",i+1);for(k=0;k<N;k++){printf("%d ",s[k]);}printf("\n");}}void bubblesort(int s[])//冒泡排序{int i,j,k;int swap;for(i=0;i<N-1;i++){for(j=0;j<N-1-i;j++){if(s[j]>s[j+1]){swap=s[j];s[j]=s[j+1];s[j+1]=swap;}}printf("第%d趟:\t",i+1);for(k=0;k<N;k++){printf("%d ",s[k]);}printf("\n");}}main(){void selectsort(int s[]);void insertsort(int s[]);void bubblesort(int s[]);int s1[N]={513,87,512,61,908,170,897,275,653,462};int s2[N]={513,87,512,61,908,170,897,275,653,462};int s3[N]={513,87,512,61,908,170,897,275,653,462};printf("\n简单选择排序:\n");selectsort(s1);printf("\n简单插入排序:\n");insertsort(s2);printf("\n简单冒泡排序:\n");bubblesort(s3);}Ex.4void quicksort(int s[],int l,int r){int i,j;int swap;i=l;j=r;swap=s[l];while(i<j){while(i<j&&swap<=s[j]){j--;}if(i<j){s[i]=s[j];i++;}while(i<j&&swap>=s[i])i++;if(i<j){s[j]=s[i];j--;}}s[i]=swap;if(l<i) quicksort(s,l,i-1);if(i<r) quicksort(s,j+1,r); }六、测试数据:如图七、实际输出:如图Ex2:Ex3:八,上机问题:(1)在哈希表建立的时候,在编写输入循环函数时,条件为while(n>0), 却不能按照所想的输入名字。
解决问题:将while(n>0)改为while(n--),即添加一个循环条件,使程序能在输入一个名字后输入下一个名字。
(2)在冒泡函数编写的时候,第二趟没有引入临时变量,导致后面的数与第一个完全相同。
解决办法:引入临时变量swap,swap=s[j];s[j]=s[j+1];s[j+1]=swap;九、体会查找运算依赖于查找表中各数据元素在计算机存储系统的组织与存储结构。