实验四查找和排序应用
实验报告-排序与查找
电子科技大学实验报告课程名称：数据结构与算法学生姓名：学号：点名序号：指导教师：实验地点：基础实验大楼实验时间： 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、学会比较各种排序与查找算法的优劣。
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、插入排序每步将一个待排序的记录，按其关键码大小，插入到前面已经排好序的一组记录的适当位置上，直到记录全部插入为止。
实验四 查找和排序
实验四查找和排序一实验目的：了解和掌握查找和排序算法的基本与原理与实现方法，掌握分析算法时间复杂度和空间复杂度的方法。
二实验内容：编制程序完成查找和排序算法的实例化。
要求上机实现两种以上的查找算法及排序算法。
分析和比较各算法的时间和空间复杂度。
三实验原理：查找是为了得到某些特定信息而进行的信息搜索工作。
查找算法的种类很多：顺序查找又称线性查找，是最基本的查找方法之一。
其查找方法为：从表的一端开始，向另一端逐个按给定值kx与关键码进行比较，若找到，查找成功，并给出数据元素在表中的位置；若整个表检测完，仍未找到与kx相同的关键码，则查找失败，给出失败信息。
有序表即是表中数据元素按关键码升序或降序排列。
折半查找在有序表中，取中间元素作为比较对象，若给定值与中间元素的关键码相等，则查找成功；若给定值小于中间元素的关键码，则在中间元素的左半区继续查找；若给定值大于中间元素的关键码，则在中间元素的右半区继续查找。
不断重复上述查找过程，直到查找成功，或所查找的区域无数据元素，查找失败。
分块查找又称索引顺序查找，是对顺序查找的一种改进。
分块查找要求将查找表分成若干个子表，并对子表建立索引表，查找表的每一个子表由索引表中的索引项确定。
索引项包括两个字段：关键码字段 (存放对应子表中的最大关键码值) ；指针字段 (存放指向对应子表的指针) ，并且要求索引项按关键码字段有序。
查找时，先用给定值kx在索引表中检测索引项，以确定所要进行的查找在查找表中的查找分块 (由于索引项按关键码字段有序，可用顺序查找或折半查找) ，然后，再对该分块进行顺序查找。
二叉排序树查找二叉排序树的查找过程为：①若查找树为空，查找失败。
②查找树非空，将给定值kx与查找树的根结点关键码比较。
③若相等，查找成功，结束查找过程，否则，a．当给kx小于根结点关键码，查找将在以左子女为根的子树上继续进行，转①b．当给kx大于根结点关键码，查找将在以右子女为根的子树上继续进行，转①排序(Sorting)是对一个数据元素集合或序列重新排列成一个按数据元素某个项值有序的序列。
查找和排序实验报告
附件（四）深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：查找排序实验.学院：计算机与软件学院专业：指导教师：报告人：学号：班级：实验时间：实验报告提交时间：教务处制①②③④Problem B: 数据结构实验--二叉排序树之查找QSort(a,1,1);④(①b)low=4;high=5;6 22 55 111 333 444↑↑privotloc=4;a. QSort(a,low,pivotloc-1);QSort(a,4,3);b. QSort(a,pivotloc+1,high);QSort(a,5,5);排序完毕。
流程图：四、实验结论：1、根据你完成的每个实验要求，给出相应的实验结果图，并结合图来解析运行过程2、如果运行过程简单，只要贴出VC运行的结果图。
3、如果无结果图，有网站的判定结果，贴出相应结果Contest1657 - DS实验--静态查找Problem A: 数据结构实验--静态查找之顺序查找Sample Input833 66 22 88 11 27 44 553221199Sample Output35errorProblem B: 数据结构实验--静态查找之折半查找Sampl e Input811 22 33 44 55 66 77 883228899Sampl e Output28errorProblem C: 数据结构实验--静态查找之顺序索引查找Sampl e Input1822 12 13 8 9 20 33 42 44 38 24 48 60 58 74 57 86 53322 48 86613548405390Sampl e Output3-4error12-8error18-9errorContest1040 - DS实验--动态查找Problem A: 数据结构实验--二叉排序树之创建和插入Sample Input1622 33 55 66 11 443775010Sample Output11 22 33 44 55 6611 22 33 44 55 66 7711 22 33 44 50 55 66 7710 11 22 33 44 50 55 66 77Problem B: 数据结构实验--二叉排序树之查找Sample Input1622 33 55 66 11 44711223344556677Sample Output11 22 33 44 55 66212434-1Problem C: 数据结构实验--二叉排序树之删除Sample Input1622 33 55 66 11 443662277Sample Output11 22 33 44 55 6611 22 33 44 5511 33 44 5511 33 44 55Contest1050 - DS实验--哈希查找Problem A: 数据结构实验--哈希查找Sample Input11 23 39 48 75 626395252636352Sample Output6 1error8 1error8 18 2Contest1060 - DS实验--排序算法Problem A: 数据结构实验--希尔排序Sample Input6111 22 6 444 333 55877 555 33 1 444 77 666 2222Sample Output6 22 55 111 333 4441 33 77 77 444 555 666 2222Problem B: 数据结构实验--快速排序Sample Input26111 22 6 444 333 55877 555 33 1 444 77 666 2222Sample Output6 22 55 111 333 4441 33 77 77 444 555 666 2222。
《食品感官评定》实验实训试验四 排序试验(以饼干为样品).doc
《食品感官评定》实验实训试验四排序试验（以饼干为样品）实验目的：通过对不同品牌的饼干进行排序试验，了解消费者对不同品牌饼干的偏好程度，分析影响消费者偏好的因素。
实验原理：排序试验是一种常用的感官评价方法，通过让受试者按照自己的喜好顺序将样品排序，来确定他们的偏好程度。
对于食品来说，排序试验可以用于确定消费者对不同品牌、不同风味的偏好程度。
实验步骤：1. 调制样品：选择几个不同品牌的饼干作为样品，准备适量的样品。
2. 调制控制样品：选择一个相对较为普遍接受的品牌饼干作为控制样品，制作适量的控制样品。
3. 记录受试者信息：记录每位受试者的基本信息，包括性别、年龄、饮食习惯等。
4. 实施排序试验：将样品和控制样品按照随机顺序摆放在试验台上，让受试者根据自己的喜好顺序对样品进行排序。
记录每位受试者的排序结果。
5. 数据处理：根据排序结果计算受试者对每个样品的平均排位数，即越靠前的样品越受受试者喜欢。
6. 统计分析：使用适当的统计方法对数据进行分析，比较不同品牌饼干的受欢迎程度，找出影响消费者偏好的因素。
实验注意事项：1. 样品选择要具有代表性，尽量包括市场上常见的品牌和风味。
2. 受试者选择要具有一定的代表性，可以根据实验目的确定特定的受试者群体。
3. 在实施排序试验时，要确保受试者对所有样品都有足够的时间和机会进行排序，避免时间和空间的压力对结果产生影响。
4. 数据的分析要结合实际情况和实验目的，选择适当的统计方法。
实验结果：通过排序试验，可以得到每个样品的平均排位数，根据排位数可以判断受试者对不同品牌饼干的喜好程度。
同时，还可以通过统计分析找出影响消费者偏好的因素，比如品牌、风味等。
实验总结：排序试验是一种简单有效的感官评价方法，可以用于确定消费者对不同品牌饼干的偏好程度，帮助企业改进产品，满足消费者需求。
在进行实验时，要注意样品的选择和受试者的选择，保证实验结果的准确性和可靠性。
同时，还要结合实际情况和实验目的，选择适当的统计方法进行数据分析，找出影响消费者偏好的因素。
查找与排序实验报告
实验四：查找与排序【实验目的】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));}【实验心得】这是本学期的最后一节实验课，实验的内容是查找与排序。
排序和查找的实验报告
排序和查找的实验报告实验报告：排序和查找引言排序和查找是计算机科学中非常重要的基本算法。
排序算法用于将一组数据按照一定的顺序排列，而查找算法则用于在已排序的数据中寻找特定的元素。
本实验旨在比较不同排序和查找算法的性能，并分析它们的优缺点。
实验设计为了比较不同排序算法的性能，我们选择了常见的几种排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
我们使用相同的随机数据集对这些算法进行了测试，并记录了它们的执行时间和占用空间。
在查找算法的比较实验中，我们选择了顺序查找和二分查找两种常见的算法。
同样地，我们使用相同的随机数据集对这些算法进行了测试，并记录了它们的执行时间和占用空间。
实验结果在排序算法的比较实验中，我们发现快速排序和归并排序在大多数情况下表现最好，它们的平均执行时间和空间占用都要优于其他排序算法。
而冒泡排序和插入排序则表现较差，它们的执行时间和空间占用相对较高。
在查找算法的比较实验中，二分查找明显优于顺序查找，尤其是在数据规模较大时。
二分查找的平均执行时间远远小于顺序查找，并且占用的空间也更少。
结论通过本实验的比较，我们得出了一些结论。
首先，快速排序和归并排序是较优的排序算法，可以在大多数情况下获得较好的性能。
其次，二分查找是一种高效的查找算法，特别适用于已排序的数据集。
最后，我们也发现了一些排序和查找算法的局限性，比如冒泡排序和插入排序在大数据规模下性能较差。
总的来说，本实验为我们提供了对排序和查找算法性能的深入了解，同时也为我们在实际应用中选择合适的算法提供了一定的参考。
希望我们的实验结果能够对相关领域的研究和应用有所帮助。
实验报告4-查找排序的应用实验
淮海工学院计算机工程学院实验报告书课程名：《数据结构》题目：查找、排序的应用实验班级：学号：姓名：实验报告要求1目的与要求:1）完整理解二叉排序树的基本概念;2) 掌握二叉排序树的建立、查找、插入和删除算法实现思想和基本应用方法；3）掌握二叉排序树的建立、查找、插入和删除算法实现的c语言编程技巧；4）完整理解有关排序的基本概念;5) 掌握各种排序方法的算法实现思想和存储表示方法；6）掌握所选排序方法的C语言编程技巧；7）按照实验题目要求独立正确地完成实验内容（提交程序清单及相关实验数据与运行结果）；8）认真书写实验报告,并按时提交。
2 实验内容或题目题目1：用C或C++语言设计实现二叉排序树的基本操作应用程序，功能包括：二叉排序树的建立，二叉排序树的查找，二叉排序树的插入，二叉排序树的删除。
程序实现后，用记录关键字序列：{55，59，45，23，72，109，89，112，48，2，3}进行正确性验证（在建立、删除、插入操作后要给出相应二叉排序树遍历结果）。
题目2：用C或C++语言设计实现快速排序方法的排序应用程序。
程序实现后，以待排序记录序列：{55，13，23，72，109，67，2，78, 23}进行正确性验证。
选做题目：用C或C++语言实现快速排序之外的其他算法，并以序列：{55，13，23，72，109，67，2，78,23}对程序进行正确性验证。
3 实验步骤与源程序（1）#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef struct Bstnode{int key;struct Bstnode *lchild,*rchild;}Bstnode,* Bstree;Bstree Create();Bstree Insert(Bstree tree,int key);Bstree Search(Bstree tree,int key);void Traverse(Bstree tree);Bstree Create(){int key; Bstree tree=NULL; scanf("%d",&key); while(key!=0){tree=Insert(tree,key);scanf("%d",&key);}return tree;}Bstree Insert(Bstree tree,int key){Bstree p=tree;Bstree s,f;while (p!=NULL){f=p;if(key==p->key) return tree;if(key<p->key) p=p->lchild;else p=p->rchild;}s=(Bstree)malloc(sizeof(Bstnode));s->key=key;s->lchild=NULL;s->rchild=NULL;if(tree==NULL)return s;if(key<f->key)f->lchild=s;elsef->rchild=s;return tree;}Bstree Search(Bstree tree,int key){Bstree p=tree;int flag=0;while(p!=NULL){if(p->key==key){printf("查询到该节点！");flag=1;return(p);}if (key<p->key)p=p->lchild;elsep=p->rchild;}if(flag==0){printf("查询不到关键字为%d的节点！",key);return NULL;}}void Traverse(Bstree tree){if(tree){Traverse(tree->lchild);printf("%4d",tree->key);Traverse(tree->rchild);}}Bstree Delete(Bstree tree,int key){Bstree p=tree;Bstree f,s,q;f=NULL;while(p){//查找关键字为key的节点if(p->key==key)break;f=p;if(p->key>key)p=p->lchild;elsep=p->rchild;}if (p==NULL)return tree;if ((p->lchild==NULL)||(p->rchild==NULL)){if(f==NULL) if(p->lchild==NULL)tree=p->rchild;elseelse if (p->lchild==NULL)if(f->lchild==p)f->lchild=p->rchild;elsef->rchild=p->rchild;else if(f->lchild==p)f->lchild=p->lchild;elsef->lchild=p->lchild;free(p);}else{q=p;s=p->lchild;while(s->rchild){q=s;s=s->rchild;}if(q==p) q->lchild=s->lchild;p->key=s->key;free(s);}return tree;}void main(){Bstree tree,p;int key1,key2,key3;int select,flag;printf("############################################\n"); printf("|* 欢迎您使用本系统 *|\n"); printf("|******************************************|\n"); printf("|* 1.创建二叉排序树 *|\n"); printf("|* 2.插入 *|\n"); printf("|* 3.查找 *|\n"); printf("|* 4.遍历 *|\n"); printf("|* 5.删除 *|\n"); printf("|* 6.退出 *|\n"); printf("********************************************\n"); while(select!=6){printf("选择的功能：");scanf("%d",&select);switch(select)case 1: printf("请输入节点信息(0为结束符):\n");tree=Create();break;case 2: printf("插入一个新的节点:");scanf("%d",&key1);Insert(tree,key1);printf("插入后得序列为:\n");Traverse(tree);printf("\n");break;case 3: printf("输入查找的数据:");scanf("%d",&key2);p=Search(tree,key2);printf("\n");break;case 4: printf("遍历所得序列为:\n");Traverse(tree);printf("\n");break;case 5: printf("输入删除的数据:");scanf("%d",&key3);tree=Delete(tree,key3);printf("删除后遍历所得序列:\n");Traverse(tree);printf("\n");break;case 6: printf("谢谢您的使用，再见！\n");flag=0;break;default:printf("输入错误,请重新输入\n");break;}}}（2）#include<stdio.h>typedef int KeyType;typedef int OtherType;typedef struct{KeyType key;}RecordType;int QKPass(RecordType r[],int left,int right){RecordType x;int low=left;int high=right;while(low<high){while(low<high&&r[high].key>=x.key){high--;}if(low<high){r[low]=r[high];low++;}while(low<high&&r[low].key<x.key){low++;}if(low<high){r[high]=r[low];high--;}}r[low]=x;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 main(){RecordType r[9];printf("请输入要排序的数据:\n");for(int i=0;i<9;i++){scanf("%d",&r[i]);}QKSort(r,0,8);printf("快速排序结果为:\n");{printf("%d ",r[i]);}printf("\n");}4 测试数据与实验结果（可以抓图粘贴）（1）（2）5 结果分析与实验体会本次试验是有关查找和排序的一些操作，要求理解二叉排序树的基本概念并实现二叉树的建立、查找、插入和删除算法。
查找、排序的应用实验
淮海工学院计算机科学系实验报告书课程名：《数据结构》题目：查找、排序的应用实验班级：软件112学号：2011122635姓名：排序、查找的应用实验报告要求1目的与要求:1）查找、排序是日常数据处理过程中经常要进行的操作和运算，掌握其算法与应用对于提高学生数据处理能力和综合应用能力显得十分重要。
2）本次实验前，要求同学完整理解有关排序和查找的相关算法和基本思想以及种算法使用的数据存储结构；3）利用C或C++语言独立完成本次实验内容或题目，程序具有良好的交互性（以菜单形式列出实验排序和显示命令，并可进行交互操作）和实用性；4）本次实验为实验成绩评定主要验收内容之一，希望同学们认真对待，并按时完成实验任务；5）本次实验为综合性实验，请于2012年12月23日按时提交实验报告（纸质报告每班10份）；6）下周开始数据结构课程设计，务必按时提交实验报告，任何同学不得拖延。
2 实验内容或题目题目：对记录序列（查找表）：{287，109，063，930，589，184，505，269,008，083}分别实现如下操作：1)分别使用直接插入排序、冒泡排序、快速排序、简单选择排序、堆排序（可选）、链式基数排序算法对纪录序列进行排序，并显示排序结果；2)对上述纪录列表排好序，然后对其进行折半查找或顺序查找；3 实验步骤与源程序#include "stdio.h"#include "stdlib.h"#define LIST_SIZE 20#define TRUE 1#define FALSE 0typedef int KeyType;typedef struct{KeyType key;}RecordType;typedef struct{RecordType r[LIST_SIZE+1];int length;}RecordList;void seqSearch(RecordList *l){KeyType k; int i;printf("请输出要查询的元素k:");fflush(stdin);scanf("%d",&k);i=l->length;while (i>=0&&l->r[i].key!=k)i--;printf("该元素的位置是");printf("%d",i+1);//cout<<"该元素在图中第"<<i<<"个位置"<<endl; printf("\n");}void BinSrch(RecordList *l){KeyType q;int mid;printf("请输入要查询的元素k:");fflush(stdin);scanf("%d",&q);int low=1;int high=l->length;while(low<=high){mid=(low+high)/2;if(q==l->r[mid].key){printf("该元素的位置为:");printf("%d",mid+1);//注意不能随便使用&printf("\n");break;}else if(q<l->r[mid].key)high=mid-1;elselow=mid+1;}}void inputkey(RecordList *l){int i;printf("请输入线性表长度:");//遇到错误：1.print用法scanf("%d",&(l->length));//&将变量的地址赋值，而不是变量的值for(i=1;i<=l->length ;i++){printf("请输入第%d个元素的值:",i);fflush(stdin);scanf("%d",&(l->r[i].key));}}void InsSort(RecordList *l){for(int i=2;i<=l->length;i++){l->r[0].key=l->r[i].key;int j=i-1;while(l->r[0].key<l->r[j].key){l->r[j+1].key=l->r[j].key;j=j-1;}l->r[j+1].key=l->r[0].key;}}//直接插入排序void BubbleSort(RecordList *l){int x,i,n,change,j;n=l->length;change=TRUE;for(i=1;i<=n-1&&change;++i){change=FALSE;for(j=1;j<=n-i;++j)if(l->r[j].key>l->r[j+1].key){x=l->r[j].key;l->r[j].key=l->r[j+1].key ;l->r[j+1].key=x;change=TRUE;}}}//冒泡排序法int QKPass(RecordList *l,int left,int right) {int x;x=l->r[left].key ;int low=left;int high=right;while(low<high){while(low<high&&l->r[high].key>=x)high--;if(low<high){l->r[low].key=l->r[high].key;low++;}while(low<high&&l->r[low].key<=x)low++;if(low<high){l->r[high].key=l->r[low].key;high--;}}l->r[low].key=x;return(low);}void QKSort(RecordList *l,int low,int high){int pos;if(low<high){pos=QKPass(l,low,high);QKSort(l,low,pos-1);QKSort(l,pos+1,high);}}//快速排序void SelectSort(RecordList *l){int n,i,k,j,x;n=l->length;for(i=1;i<=n-1;++i){k=i;for(j=i+1;j<=n;++j)if(l->r[j].key<l->r[k].key) k=j;if(k!=i){x=l->r[i].key;l->r[i].key=l->r[k].key;l->r[k].key=x;} }}void output(RecordList *l){for(int i=1;i<=l->length;i++){printf("%d",l->r[i].key);printf("\n");}}void main(){RecordList *l,*t,*m,*n;l=(RecordList *)malloc(sizeof(RecordList));int low;int high;int flag=1;int xuanze;while(flag!=0){printf("####################################################\n");printf("###### 请选择你要进行的操作! #########\n");printf("###### 1.直接插入排序; #########\n");printf("###### 2.冒泡排序; #########\n");printf("###### 3.快速排序; #########\n");printf("###### 4.简单选择排序; #########\n");printf("###### 5.顺序查找; #########\n");printf("###### 6.折半查找; #########\n");printf("###### 7.退出! #########\n");printf("####################################################\n");scanf("%d",&xuanze);switch(xuanze){case 1:inputkey(l);InsSort(l);printf("直接插入排序结果是:\n");output(l);break;case 2:inputkey(l);BubbleSort(l);printf("冒泡排序结果是:\n");output(l);break;case 3:inputkey(l);low=1;high=l->length;QKSort(l,low,high);printf("快速排序结果是:\n");output(l);break;case 4:inputkey(l);SelectSort(l);printf("简单选择排序结果是:\n");output(l);break;case 5:inputkey(l);InsSort(l);printf("排序结果是:\n");output(l);seqSearch(l);break;case 6:inputkey(l);InsSort(l);printf("排序结果是:\n");output(l);break;BinSrch(l);case 7:flag=0;break;}}}4 测试数据与实验结果（可以抓图粘贴）《数据结构》实验报告- 10 -5 结果分析与实验体会1.编程时要细心，避免不必要的错误；2.要先熟悉书本上的内容，否则编译会有困难；3.不能太过死板，要灵活运用所学知识。
数据结构实验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、熟悉各种内部排序的基本原理和操作方法。
二、实验内容1、对两种查找算法的基本操作。
2、插入排序、冒泡排序、选择排序、快速排序三、问题描述1、插入排序的基本思想是顺序地把待排序列中的各个元素按其排序码的大小，插入到已排序的序列的适当位置上；选择排序的基本思想是不断从待排序的心理中选取排序码最小的数据元素放到已排序的元素序列的后面，直到序列中所有记录都已排序为止；冒泡排序是每次对相邻的两个元素的排序码进行比较，当不符合次序即交换位置，这样顺序码值大的就（或小的）像冒气泡一样逐渐升起，直到所有相邻两元素的次序合理为止。
快速排序是在冒泡法排序基础上发展起来的一种排序算法，它每一步都将待排序列中第一个元素放到最终位置上，并同时将待排序列中其他元素分成两个子序列，一个子序列中元素的顺序码均小于第一个元素的排序没码，另一个子序列中元素的顺序码均不小于第一个元素的排序码。
如此循环处理，直到每个子序列只剩下一个元素，即完成了排序。
四、程序清单1、顺序查找：#include <stdio.h>#define MAX_SIZE 100typedef struct{int key;}element;element list[MAX_SIZE];int seqsearch(element list[],int searchnum,int num);int main()int i,num,searchnum,k;printf("请输入元素的个数："); scanf("%d",&num);printf("请输入元素：\n");for(i=0;i<num;i++){scanf("%d",&list[i].key);}while(1){printf("请输入要查询的数据元素:"); scanf("%d",&searchnum);k=seqsearch(list,searchnum,num); if(k!=-1){printf("所查询元素的下标为："); printf("%d\n",k);}elseprintf("查询元素不存在。
查找排序实验四作业
查找排序实验四作业试验四：查找、排序一、实验描述：1. 简单选择排序算法验证实验目的⑴掌握简单选择排序算法的基本思想；⑵ 掌握简单选择排序算法的实现方法；⑶ 验证简单选择排序算法的时间性能。
实验内容对一组数据进行简单选择排序(按升序排列)。
算法思想与设计1. 采用单链表进行排序操作；2. 简单选择排序的基本思想：对待排序进行若干趟处理，通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小记录和第i(1<=i<=n)个记录进行交换，这样一趟处理就能确定一个数的位置，对n个数如果确定n-1个数的位置，则这n 个数就排序成功。
3. 选择排序算法的时间复杂度为O(n2)。
并且排序是稳定的。
算法设计1.数据结构设计使用一个简单的链表作为选择排序的操作对象。
//单链表结构体定义class Si ngleL ink{private int idata;public int Data;{get{return idata;}set{idata=value;} }public Sin gleL ink n ex t; public Sin gleL in k(){idata = -1;n ext =n ull;} public Sin gleL in k(i nt data){ idata = -1;n ext = nu II;}}2. 算法流程图：2.1初始化单链表循环在单链表尾部初始化完2.2简单选择排序i++ 否排序数据中返回3. 代码算法实现3.1单链表初始化Randomr= new Random();〃从1 〜100 间产生数list.clear();〃清空单链表for(i nt i = 0; i < dlbl on g;i++){list.I nsert(r.Next(100));〃节点插入操作f++;}TextBox1.Text = list.Disply();〃返回整个单链表显示3.2单链表选择排序y = head;flag = head .n ex t;int n = 0,i,j,temp=0,biaoji;y = head .n ex t;p = head .n ex t;q = head .n ex t;for(i = 0 ; i < n -1;i++){flag = p;q = p;biaoji = q.Data;for(j=i;j< n-1;j++){if(q.n ext.Data < biaoji){flag = q.n ex t;fiaoji = q.n ext.Data;}q=q.n ex t;}temp = p.Data;p.Data = flag.Data;flag.Data = temp;P = p.n ex t;}retur n true;4. 测试采用黑盒测试方法测试。
实验4 综合实验-查找与排序
实验环境 计算机、 语言程序设计环境 计算机、C语言程序设计环境 实验学时 4学时，必做实验 学时， 学时 实验内容 题目：用C语言设计实现所选排序方法的排序应用程序。程 语言设计实现所选排序方法的排序应用程序。 题目： 语言设计实现所选排序方法的排序应用程序 序实现后，以待排序记录序列： ， ， ， ， 序实现后，以待排序记录序列：{55，13，23，72，109， ， 67，2，78, 13}进行正确性验证。 进行正确性验证。 ， ， 进行正确性验证 排序方法选择方案： 排序方法选择方案： 直接插入和希尔排序（同时实现）； ① 直接插入和希尔排序（同时实现）； ② 冒泡排序与快速排序 ③ 选择排序与堆排序
实验步骤 C源程序代码。 源程序代码。 源程序代码 测试数据与实验结果 可写出重要操作运行的结果，如下： 可写出重要操作运行的结果，如下：
实验4 综合实验实验4 综合实验-查找与排序 实验目的 完整理解有关排序的基本概念; ① 完整理解有关排序的基本概念 ② 掌握各种排序方法的算法实现思想和存储表示方 法； 掌握所选排序方法的C语言编程技巧 语言编程技巧； ③ 掌握所选排序方法的 语言编程技巧；立正确地完成实验内容（提 交程序清单及相关实验数据与完整运行结果）； 交程序清单及相关实验数据与完整运行结果）； 认真书写实验报告,并按时提交 并按时提交。 ⑤ 认真书写实验报告 并按时提交。
查找和排序 实验报告
查找和排序实验报告查找和排序实验报告一、引言查找和排序是计算机科学中非常重要的基础算法之一。
查找（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. 实验方法（1）查找算法实验：分别使用线性查找、二分查找和哈希查找算法，对含有一定数量元素的数组进行查找操作，并记录比较次数和查找时间。
（2）排序算法实验：分别使用冒泡排序、快速排序和归并排序算法，对含有一定数量元素的数组进行排序操作，并记录比较次数和排序时间。
3. 实验结果（1）查找算法实验结果表明，二分查找在有序数组中的查找效率最高，哈希查找在大规模数据中的查找效率最高。
（2）排序算法实验结果表明，快速排序在平均情况下的排序效率最高，归并排序在最坏情况下的排序效率最高。
4. 实验分析通过实验数据的对比分析，我们得出了以下结论：（1）查找算法：二分查找适用于有序数组的查找，哈希查找适用于大规模数据的查找。
（2）排序算法：快速排序适用于平均情况下的排序，归并排序适用于最坏情况下的排序。
5. 结论不同的查找与排序算法在不同的场景下有着不同的性能表现，选择合适的算法可以提高程序的效率和性能。
本实验为实际应用提供了参考依据，对算法的选择和优化具有一定的指导意义。
通过本次实验，我们深入了解了不同查找与排序算法的原理和性能，为今后的算法设计和优化工作提供了宝贵的经验和参考。
实验四查找和排序应用
数据结构
实验题目
10. 置换-选择排序的实现 问题描述 对文件中的记录的关键字采用外部排序的置换-选择算 法实现。
数据结构
实验题目
10. 置换-选择排序的实现 实验要求 设计置换-选择排序的模拟程序。 1）记录存储在文件中。 2）采用多路归并算法实现。 3）采用置换-选择算法实现。 4）两种方法的性能比较。
数据结构实验
LOGO
数据结构
实验四
实验题目
查找和排序应用
1.索引顺序表应用 问题描述 东北大学信息学院学生信息查询系统。各专业按 名称有序，专业内按班级编号有序，班级内记录无序。
数据结构 实验题目
1. 索引顺序表应用 实验要求 设计索引顺序表的学生信息查询系统。 1)采用顺序表、索引表等存储结构。 2)采用二级顺序表索引。 3)完成表的创建、插入、查询等操作。 4)分析平均查找长度特性。
数据结构
实验题目
7.堆排序 问题描述 应用堆排序求出记录中的前K名。 实验要求 设计堆排序应用程序。 1）采用二叉树的二叉链表结构。 2）完成堆排序的插入、删除、查找等基本操作。 3）给出应用实例。
数据结构
实验题目
8.计数式基数排序 问题描述 统计研究生入学成绩的排名。除了总分的要求外，还有 专业课等单科小分的要求。 实验要求 设计计数式基数排序的应用程序。 1）采用顺序表存储结构。 2）利用对关键字位的统计和复制的方法实现计数式基 数排序。 3）给出应用实例。
数据结构
实验题目
3.互联网域名查询 实验要求 设计基于二叉排序树的搜索互联网域名的程序。 1）采用二叉树的二叉链表存储结构。 2）完成二叉排序树的创建、插入、删除、查询操作。 3）可以考虑两棵二叉排序树的合并。
软件基础实验-查找和排序
elsehigh=mid-1;
}
return (-1);
}
//折半查找：建立一个有序空顺序表，并在表中插入元素{1.5,2.3,5.6,1,2}，并利用折半查找函数，搜索该元dd;
void bub(T p[],int n)
{
int m,k,j,i;
T d;
k=0;
m=n-1;
while(k<m)
{
j=m-1;m=0;
for(i=k;i<=j;i++)
if(p[i]>p[i+1])
{
d=p[i];p[i]=p[i+1];p[i+1]=d;m=i;
}
j=k+1;k=0;
for(i=m;i>=j;i--)
5.快速排序算法程序代码
template<class T>
void qck(T p[],int n)
{
int m,i;
T*s;
if (n>10)
{
i=split(p,n);
qck(p,i);
s=p+(i+1);
m=n-(i+1);
qck(s,m);
}
else
bub(p,n);
return;
}
//表的分割
int p[]={5,6,9,0,1,6,44,26,13,10};
cout<<"排序前的序列："<<endl;
for(i=0;i<10;i++)
cout<<p[i]<<setw(4);
查找、排序的应用实验报告
实验七查找、排序的应用一、实验目的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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
LOGO
数据结构
实验四
实验题目
查找和排序应用
1.索引顺序表应用 问题描述 东北大学信息学院学生信息查询系统。各专业按 名称有序，专业内按班级编号有序，班级内记录无序。
数据结构 实验题目
1. 索引顺序表应用 实验要求 设计索引顺序表的学生信息查询系统。 1)采用顺序表、索引表等存储结构。 2)采用二级顺序表索引。 3)完成表的创建、插入、查询等操作。 4)分析平均查找长度特应用 问题描述 应用3阶B-树，对图书馆的图书进行简单管理。 实验要求 设计基于B-树的图书管理模拟程序。 1）采用3阶B-树存储结构。 2）以书号为关键字，完成图书的入库、出库和查询操 作。 3）自定义显示操作结果的形式。
数据结构
实验题目
6.快速排序应用 问题描述 应用快速排序算法，查找顺序表中的第K小的元素。 实验要求 设计求顺序表中的第K小元素。 1）采用顺序表存储结构。 2）完成顺序表的快速排序。 3）应用快速排序求第K小元素。 4）通过性能分析，尝试如何改进。
数据结构
实验题目
10. 置换-选择排序的实现 问题描述 对文件中的记录的关键字采用外部排序的置换-选择算 法实现。
数据结构
实验题目
10. 置换-选择排序的实现 实验要求 设计置换-选择排序的模拟程序。 1）记录存储在文件中。 2）采用多路归并算法实现。 3）采用置换-选择算法实现。 4）两种方法的性能比较。
数据结构
实验题目
3.互联网域名查询 实验要求 设计基于二叉排序树的搜索互联网域名的程序。 1）采用二叉树的二叉链表存储结构。 2）完成二叉排序树的创建、插入、删除、查询操作。 3）可以考虑两棵二叉排序树的合并。
数据结构
实验题目
4.平衡二叉树演示 问题描述 利用平衡二叉树设计动态查找表。 实验要求 设计平衡二叉树的动态演示的模拟程序。 1）采用平衡二叉树存储结构。 2）完成平衡二叉树的创建、查找、插入和删除的演示 操作。 3）可以考虑两棵平衡二叉树的合并。
数据结构
实验题目
7.堆排序 问题描述 应用堆排序求出记录中的前K名。 实验要求 设计堆排序应用程序。 1）采用二叉树的二叉链表结构。 2）完成堆排序的插入、删除、查找等基本操作。 3）给出应用实例。
数据结构
实验题目
8.计数式基数排序 问题描述 统计研究生入学成绩的排名。除了总分的要求外，还有 专业课等单科小分的要求。 实验要求 设计计数式基数排序的应用程序。 1）采用顺序表存储结构。 2）利用对关键字位的统计和复制的方法实现计数式基 数排序。 3）给出应用实例。
数据结构 实验题目
2. 哈希表应用 问题描述 针对学生的手机号码，设计一个哈希表，使得平均查 找长度不超过给定值R。
数据结构
实验题目
2.哈夫曼编码 实验要求 设计哈希表应用程序。 1）采用顺序或链式存储结构。 2）设计哈希函数。 3）分析平均查找长度特性。
数据结构
实验题目
3. 二叉排序树应用 问题描述 互联网域名系统是一个典型的树形层次结构。从根 节点往下的第一层是顶层域，如cn、com等，最底层 （第四层）是叶子结点，如www等。因此，域名搜索 可以构造树的结构完成。
数据结构
实验题目
9.传统排序与优化排序比较 问题描述 传统的插入、选择、交换排序，对应优化的排序方法有 希尔排序、堆排序和快速排序。
数据结构
实验题目
9.关键路径问题 实验要求 设计传统排序和优化排序算法的比较程序。 1）采用顺序表等存储结构。 2）比较算法的关键字比较次数、移动次数、时间复杂 度、平均性能、空间复杂度等。 3）测试数据由随机数生成器生成。