数据结构实验查找和排序
查找和排序算法实验报告
查找和排序算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的查找和排序算法，通过实际编程实现和性能比较，分析不同算法在不同数据规模和数据分布情况下的效率和优劣，为在实际应用中选择合适的算法提供依据。
二、实验环境本次实验使用的编程语言为 Python 3x，开发环境为 PyCharm。
实验中使用的操作系统为 Windows 10。
三、实验内容（一）查找算法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｀｀｀（二）排序算法1、冒泡排序冒泡排序通过反复比较相邻的元素并交换位置，将最大的元素逐步“浮”到数组的末尾。
｀｀｀pythondef bubble_sort(arr)：n ＝ len(arr)for i in range(n)：for j in range(0, n i 1)：if arrj ＞ arrj ＋ 1 ：arrj, arrj ＋ 1 ＝ arrj ＋ 1, arrj｀｀｀2、插入排序插入排序将未排序的元素逐个插入到已排序的部分中，保持已排序部分始终有序。
数据结构实验五-查找与排序的实现
实验报告课程名称数据结构实验名称查找与排序得实现系别专业班级指导教师１1学号姓名实验日期实验成绩一、实验目得(1)掌握交换排序算法（冒泡排序)得基本思想;(2)掌握交换排序算法（冒泡排序)得实现方法；(3)掌握折半查找算法得基本思想；(4)掌握折半查找算法得实现方法;二、实验内容1.对同一组数据分别进行冒泡排序，输出排序结果。
要求：1)设计三种输入数据序列：正序、反序、无序2)修改程序:a)将序列采用手工输入得方式输入b)增加记录比较次数、移动次数得变量并输出其值,分析三种序列状态得算法时间复杂性2.对给定得有序查找集合,通过折半查找与给定值k相等得元素。
3.在冒泡算法中若设置一个变量lａstEｘchaｎｇｅIndex来标记每趟排序时经过交换得最后位置,算法如何改进？三、设计与编码1、本实验用到得理论知识2、算法设计３、编码packａｇe soｒt_seaｒch；imｐoｒｔ javａ、utｉl、Sｃａnner；ｐuｂliｃｃlass Ｓoｒｔ_Sｅaｒch｛／/冒泡排序算法ﻩｐuｂｌｉc voiｄBubblｅSoｒt（ｉnt r[］){ｉnt temp;ﻩｉｎｔ couｎt＝0，move=0；ﻩｂｏｏｌean ｆlaｇ=trｕｅ;ﻩfｏｒ(int ｉ＝1;i〈r、lｅnｇｔh＆＆flag；i++){ﻩﻩｆlaｇ=fａlse；ﻩﻩcｏｕｎt++；ﻩｆor（inｔｊ=０;j<r、leｎgｔｈ－i;j＋＋）{if(ｒ[ｊ］＞ｒ[j＋1]）{ﻩteｍp=ｒ[j]；ﻩﻩﻩｒ［ｊ］=ｒ［j+1］;r［j+1］＝temp；ﻩﻩmoｖe＋+；flａg＝true;ﻩﻩ}ﻩﻩﻩ｝ﻩ｝ﻩﻩＳystem、oｕt、priｎtｌｎ（＂排序后得数组为:”）;ﻩfor（iｎt i=０;i〈r、length；ｉ++）{ﻩﻩSystｅｍ、oｕt、prinｔ（r［ｉ］＋" ”);ﻩ｝Sysｔｅｍ、out、println（)；ﻩSystem、out、printlｎ(＂比较次数为:"+cｏunt)；ﻩﻩSysteｍ、oｕt、prｉnｔｌn（"移动次数为:”＋ｍove);｝ﻩｐublic ｓtatiｃｉnt ＢinaｒySeaｒcｈ（iｎｔ r[],int key)｛//折半查找算法ﻩiｎｔ low=０，hｉgh=ｒ、ｌeｎｇtｈ-1；ﻩwhｉｌe（ｌow＜=hｉgh）{ﻩinｔ miｄ=（low+hｉgh）/2；ﻩﻩif（r［ｍｉd］==key)｛ﻩｒetuｒn mｉd；ﻩﻩ｝ﻩﻩelse if(r［mid］>ｋｅy)｛high=miｄ—1；ﻩﻩ｝ﻩﻩelsｅ{ﻩﻩﻩlｏw=mid＋１;ﻩﻩ｝ﻩ}ﻩﻩretｕrn －１；ﻩ}//测试publｉc ｓtaｔic void main（Ｓtｒing[］ａrgs)｛ﻩＳoｒｔ_Ｓearch sｓ=new Soｒt＿Searｃh(）；ｉｎtｔ［]=nｅw int［1３]；ﻩSｙsｔｅｍ、oｕt、prinｔln(”依次输入１3个整数为："）；ﻩＳcanner ｓc＝new Scanner（Sｙstem、in）；ﻩｆor（ｉnt i=0;ｉ〈t、length；i++）｛ﻩﻩt[i］=sｃ、nextＩnt()；ﻩ}ﻩﻩSyｓtｅm、ｏuｔ、pｒｉnｔｌｎ("排序前得数组为： "）;ﻩfor（iｎｔ i=0；i＜t、length；ｉ+＋）｛ﻩSysｔem、ouｔ、print（t［ｉ］+"”）；ﻩ}ﻩSystｅm、ｏut、pｒintln(）；ﻩﻩｓｓ、BubblｅSort(t）;//查找ﻩｗｈile（true）{ﻩﻩSｙstｅm、oｕt、ｐｒinｔｌｎ（＂请输入要查找得数: ”); ﻩﻩint k=ｓc、nexｔInt（）;ﻩif（BｉnarySeａrch(t,k）>0）System、oｕt、println（k＋＂在数组中得位置就是第：＂+ BｉnａrySeａrcｈ(t,k）)；ﻩﻩｅｌseﻩﻩSｙsｔeｍ、oｕｔ、prｉntｌn（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;②实现直接插入排序：每次将一个待排序的记录，按其关键字大小插入到前面已排序好的子文件中的适当位置，直到全部记录插入完成为止。
数据结构与算法实验报告5-查找与排序
北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法；
2.了解树表查找思想；
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法；
二、实验内容
查找部分
1.实现顺序查找的两个算法（P307）, 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果；
2.实现对有序表的二分查找；
3.实现散列查找算法(链接法)，应能够解决冲突；
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
（描述实验步骤及中间的结果或现象。
在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落）
五、实验结果
六、总结
（说明实验过程中遇到的问题及解决办法；个人的收获；未解决的问题等）。
数据结构实验(6)查找和排序
计算机系数据结构实验报告（x）姓名：陈科健学号：6100113017 专业班级：电子商务131 实验名称：查找和排序实验目的：深入了解各种内部排序方法及效率分析。
问题描述：各种内部排序算法的时间复杂度分析，试通过随机数据比较算法的关键字比较次数和关键字移动次数。
实验要求：1、对起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序这六种常用排序算法进行分析。
2、用代码实现上述算法中任意两种排序算法。
3、设计待排序表的表长不超过100（其中数据最好用伪随机数产生程序产生，也可以自己设计一组待排序数据）。
4、要对实验结果做简单分析。
算法分析：实验内容和过程：#include<stdio.h>#include<stdlib.h>typedef struct{int key;}Key;typedef struct{Key r[6];}SqList;void BubbleSort(int *a,int n){int i, j,t;for (i = 0; i < n - 1; i++){for (j = 0; j <n-i-1;j++){if (a[j]>a[j+1]){t = a[j];a[j] = a[j+1];a[j+1] = t;}}}for (i = 0; i < n ; i++){printf("%5d", a[i]);}}int Partition(SqList &L, int low, int high){int pivotkey;L.r[0] = L.r[low];pivotkey = L.r[low].key;while (low < high){while (low < high && L.r[high].key >= pivotkey) --high;L.r[low] = L.r[high];while (low < high && L.r[high].key <= pivotkey) ++low;L.r[high] = L.r[low];}L.r[low] = L.r[0];return low;}void QSort(SqList &L, int low, int high){int pivotloc;if (low < high){pivotloc = Partition(L, low, high);QSort(L, low, pivotloc-1);QSort(L, pivotloc + 1, high);}}void QuickSort(SqList &L){int i;QSort(L,0,5);for (i = 0; i < 6; i++){printf("%5d", L.r[i].key);}}int main(){int i, a[6]; SqList L;printf(" ** 起泡排序**\n\n");printf("请输入6个数：\n");for (i = 0; i < 6; i++){scanf_s("%d", &a[i]);}printf("排序后：\n");BubbleSort(a, 6);printf("\n\n ** 快速排序**\n\n");printf("请输入6个数：\n");for (i = 0; i < 6; i++){scanf_s("%d", &L.r[i].key);}printf("排序后：\n");QuickSort(L);system("pause");}实验结果：总结和感想：起泡还好做。
数据结构实验报告五,查找与排序-
数据结构实验报告五,查找与排序-查找与排序一、实验目的：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）排序算法性能测试在数据量较大的情况下，快速排序和归并排序的性能明显优于冒泡排序、选择排序和插入排序。
排序和查找的实验报告
排序和查找的实验报告实验报告：排序和查找引言排序和查找是计算机科学中非常重要的基本算法。
排序算法用于将一组数据按照一定的顺序排列，而查找算法则用于在已排序的数据中寻找特定的元素。
本实验旨在比较不同排序和查找算法的性能，并分析它们的优缺点。
实验设计为了比较不同排序算法的性能，我们选择了常见的几种排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
我们使用相同的随机数据集对这些算法进行了测试，并记录了它们的执行时间和占用空间。
在查找算法的比较实验中，我们选择了顺序查找和二分查找两种常见的算法。
同样地，我们使用相同的随机数据集对这些算法进行了测试，并记录了它们的执行时间和占用空间。
实验结果在排序算法的比较实验中，我们发现快速排序和归并排序在大多数情况下表现最好，它们的平均执行时间和空间占用都要优于其他排序算法。
而冒泡排序和插入排序则表现较差，它们的执行时间和空间占用相对较高。
在查找算法的比较实验中，二分查找明显优于顺序查找，尤其是在数据规模较大时。
二分查找的平均执行时间远远小于顺序查找，并且占用的空间也更少。
结论通过本实验的比较，我们得出了一些结论。
首先，快速排序和归并排序是较优的排序算法，可以在大多数情况下获得较好的性能。
其次，二分查找是一种高效的查找算法，特别适用于已排序的数据集。
最后，我们也发现了一些排序和查找算法的局限性，比如冒泡排序和插入排序在大数据规模下性能较差。
总的来说，本实验为我们提供了对排序和查找算法性能的深入了解，同时也为我们在实际应用中选择合适的算法提供了一定的参考。
希望我们的实验结果能够对相关领域的研究和应用有所帮助。
数据结构实验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>根据提示输入股票代码及交易日期，以空格隔开。
数据结构实验查找和排序
查找、排序算法的应用班级学号姓名一、实验目的1 掌握查找的不同方法，并能用高级语言实现查找算法。
2 熟练掌握顺序表和有序表的顺序查找和二分查找方法。
3 掌握排序的不同方法，并能用高级语言实现排序算法。
4 熟练掌握顺序表的选择排序、冒泡排序和直接插入排序算法的实现。
二、实验内容1 创建给定的顺序表。
表中共包含八条学生信息，信息如下：学号姓名班级C++ 数据结构1 王立03511 85 762 张秋03511 78 883 刘丽03511 90 794 王通03511 75 865 赵阳03511 60 716 李艳03511 58 687 钱娜03511 95 898 孙胜03511 45 602 使用顺序查找方法，从查找表中查找姓名为赵阳和王夏的学生。
如果查找成功，则显示该生的相关信息；如果查找不成功，则给出相应的提示信息。
3 使用二分查找方法，从查找表中查找学号为7和12的学生。
如果查找成功，则显示该生的相关信息；如果查找不成功，则给出相应的提示信息。
（注意：创建静态查找表时必须按学号的从小到大排列！）4 使用直接插入排序方法，对学生信息中的姓名进行排序。
输出排序前和排序后的学生信息表，验证排序结果。
5 使用直接选择排序方法，对学生信息中的C成绩进行排序。
输出排序前和排序后的学生信息表，验证排序结果。
6 使用冒泡排序方法，对学生信息中的数据结构成绩进行排序。
输出排序前和排序后的学生信息表，验证排序结果。
7 编写一个主函数，将上面函数连在一起，构成一个完整程序。
8 将实验源程序调试并运行。
三、实验结果#include<iostream>#include<string>using namespace std;# define size 10struct student{string num;string name;string classnum;int cscore;int datascore;};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<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构成绩"<<endl;for(int i=1;i<=L.len;i++ ){cin>>L.stu [i].num >>L.stu [i].name >>L.stu[i].classnum >>L.stu[i].cscore >>L.stu [i].datascore ;}}//输出顺序表的信息void display(seqlist L){cout<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构成绩"<<endl;for(int i=1;i<=L.len;i++){cout<<L.stu [i].num<<" "<<L.stu [i].name<<" "<<L.stu [i].classnum <<" "<<L.stu [i].cscore <<" "<<L.stu [i].datascore <<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].classnum <<" "<<L.stu [i].cscore <<" "<<L.stu [i].datascore <<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].classnum <<" "<<L.stu [mid].cscore <<" "<<L.stu [mid].datascore <<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].cscore<L.stu[k].cscore)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>=i+1;j--)if(L.stu [j].datascore <L.stu [j-1].datascore ){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);}void main(){seqlist L;cout<<"创建顺序表"<<endl;create_seq(L);cout<<"输出顺序表"<<endl;display(L);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);}执行结果如下:四、实验总结1.对于String 类的应用时要用using namespace std; 而不能直接用<Sting.h>,那样总是说前面少一个分号。
数据结构试验查找排序
实验七查找、排序的应用一、实验目的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 查找与排序
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. 快速排序快速排序是一种高效的排序算法，它的基本思想是通过递归地将数据集合划分为较小和较大的两个子集合，然后对子集合进行排序，最后将排序好的子集合合并起来。
查找排序算法实验报告(3篇)
第1篇一、实验目的1. 熟悉常见的查找和排序算法。
2. 分析不同查找和排序算法的时间复杂度和空间复杂度。
3. 比较不同算法在处理大数据量时的性能差异。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 实现以下查找和排序算法：（1）查找算法：顺序查找、二分查找（2）排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序2. 分析算法的时间复杂度和空间复杂度。
3. 对不同算法进行性能测试，比较其处理大数据量时的性能差异。
四、实验步骤1. 实现查找和排序算法。
2. 分析算法的时间复杂度和空间复杂度。
3. 创建测试数据，包括小数据量和大数据量。
4. 对每种算法进行测试，记录运行时间。
5. 分析测试结果，比较不同算法的性能。
五、实验结果与分析1. 算法实现（1）顺序查找def sequential_search(arr, target): for i in range(len(arr)):if arr[i] == target:return ireturn -1（2）二分查找def binary_search(arr, target):low, high = 0, len(arr) - 1while low <= high:mid = (low + high) // 2if arr[mid] == target:return midelif arr[mid] < target:low = mid + 1else:high = mid - 1return -1（3）冒泡排序def bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]（4）选择排序def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]（5）插入排序def insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = key（6）快速排序def quick_sort(arr):if len(arr) <= 1:pivot = arr[len(arr) // 2]left = [x for x in arr if x < pivot]middle = [x for x in arr if x == pivot]right = [x for x in arr if x > pivot]return quick_sort(left) + middle + quick_sort(right)（7）归并排序def merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = merge_sort(arr[:mid])right = merge_sort(arr[mid:])return merge(left, right)def merge(left, right):result = []i = j = 0while i < len(left) and j < len(right):if left[i] < right[j]:result.append(left[i])i += 1else:result.append(right[j])result.extend(left[i:])result.extend(right[j:])return result2. 算法时间复杂度和空间复杂度分析（1）顺序查找：时间复杂度为O(n)，空间复杂度为O(1)。
数据结构课程设计——排序与查找
数据结构课程设计——排序与查找一、排序算法介绍排序算法是数据结构课程设计中的重要内容之一。
排序是将一组数据按照特定的规则进行重新排列的过程，常用于数据的整理和查找。
在排序算法中，我们主要讨论常见的几种排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。
1. 冒泡排序冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较相邻的元素，并按照升序或降序交换它们。
通过多次遍历，最大（或最小）的元素会逐渐移动到列表的末尾，直到整个列表排序完成。
2. 选择排序选择排序是一种简单直观的排序算法，它通过不断选择剩余元素中的最小（或最大）元素，并将其放置在已排序部分的末尾。
选择排序的主要思想是每次从剩余元素中选择最小（或最大）的元素，并将其与当前位置交换。
3. 插入排序插入排序是一种简单且直观的排序算法，它通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序的核心思想是将待排序元素插入到已排序序列中的适当位置，从而得到一个新的有序序列。
4. 快速排序快速排序是一种高效的排序算法，它采用分治的思想，通过一趟排序将待排序序列分割成独立的两部分，其中一部分的所有元素都比另一部分的所有元素小（或大），然后再对这两部分分别进行排序，最终得到整个序列有序。
5. 归并排序归并排序是一种稳定的排序算法，它采用分治的思想，将待排序序列递归地分成两个子序列，分别进行排序，然后将两个有序子序列合并成一个有序序列。
归并排序的核心思想是将两个有序子序列合并为一个有序序列。
6. 堆排序堆排序是一种高效的排序算法，它利用堆这种数据结构来实现排序。
堆是一种完全二叉树，它满足堆的性质：父节点的值大于（或小于）其子节点的值。
堆排序的主要思想是将待排序序列构建成一个大顶堆（或小顶堆），然后依次取出堆顶元素，再重新调整堆，直到整个序列有序。
二、查找算法介绍查找算法是数据结构课程设计中另一个重要的内容。
数据结构中查找和排序算法实验报告
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)
通过本次实验，我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候，需要我把理论变为上机调试，这无疑是最难的部分，有时候我想不到合适的算法去解决问题，就请教同学，上网搜索，逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高，以前我很不懂这门课，觉得它很难，但是现在明白了一些代码的应用，明白了每个程序都有相似的特点，通用的结构，也学会了静下心来写程序。我以后还要把没学好的知识点补齐，克服编程过程中的难关，打实基础，向更深入的层次发展。
数据结构实验报告2-排序和查找
广东金融学院实验报告课程名称：数据结构实验编号实验二：排序和查找实验系别计科系及实验名称姓名学号班级实验地点实验日期2013.4.25-2013.6.5 实验时数 6指导教师刘秋莲同组其他成员成绩一、实验目的及要求1、通过编写和调用直接插入排序、希尔排序、冒泡排序和快速排序四种排序算法实现数据排序，充分理解各种排序算法的算法思想、排序过程及各自的时间复杂度、稳定性。
2、通过编写和调用顺序查找和二分查找算法实现数据查找，掌握两个查找算法的基本思想、实现方法和时间性能。
二、实验环境及相关情况（包含使用软件、实验设备、主要仪器及材料等）使用微机、Java jdk1.6.0 开发环境三、实验内容及步骤（包含简要的实验步骤流程）（一）排序（1）参照课本，分别编写Java程序，实现顺序表记录类RecordNode、类KeyType。
（2）参照课本，编写一个Java程序，实现顺序表类SeqList，并在其中添加成员函数：length()求顺序表的当前长度；display()输出数组元素的关键字；直接插入排序算法；带监视哨的直接插入排序；希尔排序算法；起泡排序算法；快速排序算法。
（3）编写主程序，循环选择调用以上5个排序算法，对数组元素排序,并输出排序过程。
（二）查找（1）在排序实验的基础上，在类SeqList中添加成员函数：不带监视哨的顺序查找算法；带监视哨的顺序查找算法；二分查找算法。
（2）编写主程序，循环选择调用以上3个查找算法，分别对键入的关键字记录进行成功和不成功查找。
四、五、实验结果（包括程序或图表、结论陈述、数据记录及分析等，可附页）六、实验总结（包括心得体会、问题回答及实验改进意见，可附页）七、教师评语1．完成所有规定的实验内容，实验步骤正确，结果正确；2．完成绝大部份规定的实验内容，实验步骤正确，结果正确；3．完成绝大部份规定的实验内容，实验步骤基本正确，结果基本正确；4．基本完成规定的实验内容，实验步骤基本正确，所完成的结果基本正确；5．未能很好地完成规定的实验内容或实验步骤不正确或结果不正确。
数据结构 试验五 查找与排序
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>
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
班级 学号 姓名 一、实验目的 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 使用二分查找方法，从查找表中查找学号为 7 和 12 的学生。如果查找成功，则 显示该生的相关信息；如果查找不成功，则给出相应的提示信息。 （注意：创建静态查 找表时必须按学号的从小到大排列！ ） 4 使用直接插入排序方法，对学生信息中的姓名进行排序。输出排序前和排序后 的学生信息表，验证排序结果。 5 使用直接选择排序方法，对学生信息中的 C 成绩进行排序。输出排序前和排序 后的学生信息表，验证排序结果。 6 使用冒泡排序方法，对学生信息中的数据结构成绩进行排序。输出排序前和排 序后的学生信息表，验证排序结果。 7 编写一个主函数，将上面函数连在一起，构成一个完整程序。 8 将实验源程序调试并运行。 三、实验结果 #include<iostream> #include<string> using namespace std; # define size 10 struct student
} 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].classnum <<" "<<L.stu [i].cscore <<" "<<L.stu [i].datascore <<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].classnum <<" "<<L.stu [mid].cscore <<" "<<L.stu [mid].datascore <<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].cscore<L.stu[k].cscore) 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>=i+1;j--) if(L.stu [j].datascore <L.stu [j-1].datascore ) { w=L.stu [j]; L.stu [j]=L.stu [j-1]; L.stu [j-1]=w; flag=1; } }
{ string num; string name; string classnum; int cscore; int datascore; }; 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<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构成 绩"<<endl; for(int i=1;i<=L.len;i++ ) { cin>>L.stu [i].num >>L.stu [i].name >>L.stu[i].classnum >>L.stu [i].cscore >>L.stu [i].datascore ; } } //输出顺序表的信息 void display(seqlist L) { cout<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构成 绩"<<endl; for(int i=1;i<=L.len;i++) { cout<<L.stu [i].num<<" "<<L.stu [i].name<<" "<<L.stu [i].classnum <<" "<<L.stu [i].cscore <<" "<<L.stu [i].datascore <<endl;
四、实验总结 1.对于 String 类的应用时要用 using namespace std; 而不能直接用<Sting.h>,那样总是 说前面少一个分号。 2.书写时要认真， 总是会写错一些字母， 有些错误也不会显示， 到输出结果时没有结果， 注意这种问题。
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); } void main() { seqlist L; cout<<"创建顺序表"<<endl; create_seq(L); cout<<"输出顺序表"<<endl; display(L); 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); } 执行结果如下: