实验6 查找和排序 (2)(1)
查找的实验报告
实验名称：查找算法性能分析实验目的：比较不同查找算法的效率，并分析其性能。
实验时间：2022年3月15日实验地点：计算机实验室实验器材：计算机、实验软件一、实验背景随着计算机技术的发展，数据量越来越大，查找算法在数据处理中的应用越来越广泛。
查找算法的效率直接影响到数据处理的速度，因此研究不同查找算法的性能具有重要意义。
本实验旨在比较几种常见的查找算法的效率，并分析其性能。
二、实验内容1. 算法介绍（1）顺序查找顺序查找是一种最简单的查找方法，其基本思想是从线性表的第一个元素开始，依次将线性表中的元素与要查找的元素进行比较，直到找到目标元素或者查找结束。
（2）二分查找二分查找是一种效率较高的查找方法，其基本思想是将待查找的序列分为两半，每次将中间位置的元素与要查找的元素进行比较，如果相等，则查找成功；如果中间位置的元素大于要查找的元素，则将查找范围缩小到左半部分；如果中间位置的元素小于要查找的元素，则将查找范围缩小到右半部分。
重复此过程，直到找到目标元素或者查找结束。
（3）散列查找散列查找是一种基于散列函数的查找方法，其基本思想是将要查找的元素通过散列函数映射到散列表中的一个位置，然后直接访问该位置，如果找到目标元素，则查找成功；如果未找到，则查找失败。
2. 实验步骤（1）生成随机数据使用实验软件生成一组随机数据，包括顺序查找和二分查找的数据。
（2）编写查找算法根据上述算法介绍，编写顺序查找、二分查找和散列查找的代码。
（3）测试算法性能分别对三种查找算法进行测试，记录查找成功和失败的情况，统计查找成功和失败的平均时间。
三、实验结果与分析1. 顺序查找（1）查找成功实验结果显示，顺序查找在查找成功的情况下，平均查找时间为0.1秒。
（2）查找失败实验结果显示，顺序查找在查找失败的情况下，平均查找时间为0.2秒。
2. 二分查找（1）查找成功实验结果显示，二分查找在查找成功的情况下，平均查找时间为0.05秒。
实验报告-排序与查找
电子科技大学实验报告课程名称：数据结构与算法学生姓名：学号：点名序号：指导教师：实验地点：基础实验大楼实验时间： 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．需求分析1．编写一个程序输出在顺序表{3，6，2，10，1，8，5，7，4，9}中采用顺序方法查找关键字5的过程；2．编写一个程序输出在顺序表{1，2，3，4，5，6，7，8，9，10}中采用顺序方法查找关键字9的过程；3．编写一个程序实现直接插入排序算法，并输出{9，8，7，6，5，4，3，2，1，0}的排序过程；4．编写一个程序实现快速排序算法，并输出{6，8，7，9，0，1，3，2，4，5}的排序过程2．系统设计1．静态查找表的抽象数据类型定义：ADT StaticSearchTable{数据对象D：D是具有相同特性的数据元素的集合。
各个数据元素均含有类型相同，可惟一标识数据元素的关键字数据关系R：数据元素同属一个集合基本操作P：Create(&ST,n)操作结果：构造一个含n个数据元素的静态查找表STDestroy(&ST)初始条件：静态查找表ST存在操作结果：销毁表STSearch(ST,key)初始条件：静态查找表ST存在，key为和关键字类型相同的给定值操作结果：若ST中存在其关键字等于key的数据元素，则函数值为该元素的值或在表中的位置，否则为“空”Traverse(ST,V isit())初始条件：静态查找表ST存在，Visit是对元素操作的应用函数操作结果：按某种次序对ST的每个元素调用函数Visit()一次且仅一次。
一旦Visit()失败，则操作失败}ADT StaticSearchTable3．调试分析（1）要在适当的位置调用Print函数，以正确显示排序过程中顺序表的变化（2）算法的时间复杂度分析：顺序查找：T(n)=O(n)折半查找：T(n)=O(logn)直接插入排序：T(n)=O(n2)快速排序：T(n)=O(nlogn)4．测试结果用需求分析中的测试数据顺序查找：顺序表3，6，2，10，1，8，5，7，4，9，查找5折半查找：顺序表1，2，3，4，5，6，7，8，9，10，查找9直接插入排序：顺序表9，8，7，6，5，4，3，2，1，0，从小到大排序快速排序：顺序表6，8，7，9，0，1，3，2，4，5，从小到大排序5．用户手册（1）输入表长；（2）依次输入建立顺序表；（3）查找：输入要查找的关键字（4）回车输出，查找为下标的移动过程；排序为顺序表的变化过程6．附录源程序：（1）顺序查找#include <stdio.h>#include <stdlib.h>#define ST_INIT_SIZE 200#define EQ(a,b) ((a)==(b))#define OVERFLOW -2typedef int KeyType;typedef struct{KeyType key;}ElemType;typedef struct{ElemType *elem;//数据元素存储空间基址,建表时按实际长度分配,0号单元留空int length;//表长度}SSTable;void InitST(SSTable &ST){ST.elem=(ElemType*)malloc(ST_INIT_SIZE*sizeof(ElemType));if(!ST.elem)exit(OVERFLOW);ST.length=0;}void CreateST(SSTable &ST){int i;printf("输入表长:");scanf("%d",&ST.length);for(i=1;i<=ST.length;i++)scanf("%d",&ST.elem[i].key);}void PrintST(SSTable ST){int i;for(i=1;i<=ST.length;i++)printf("%2d",ST.elem[i].key);printf("\n");}int Search_Seq(SSTable ST,KeyType key){//在顺序表ST中顺序查找其关键字等于key的数据元素//若找到则函数值为该元素在表中的位置,否则为0int i;ST.elem[0].key=key;printf("下标:");for(i=ST.length;!EQ(ST.elem[i].key,key);--i)printf("%d→",i);//从后往前找return i;}void main(){SSTable ST;KeyType key;InitST(ST);CreateST(ST);printf("顺序查找表:");PrintST(ST);printf("输入要查找的关键字:");scanf("%d",&key);int found=Search_Seq(ST,key);if(found)printf("找到,为第%d个数据\n",found);else printf("没有找到!\n");}（2）折半查找#include <stdio.h>#include <stdlib.h>#define ST_INIT_SIZE 200#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))#define OVERFLOW -2typedef int KeyType;typedef struct{KeyType key;}ElemType;typedef struct{ElemType *elem;//数据元素存储空间基址,建表时按实际长度分配,0号单元留空int length;//表长度}SSTable;void InitST(SSTable &ST){ST.elem=(ElemType*)malloc(ST_INIT_SIZE*sizeof(ElemType));if(!ST.elem)exit(OVERFLOW);ST.length=0;}void CreateST(SSTable &ST){int i;printf("输入表长:");scanf("%d",&ST.length);for(i=1;i<=ST.length;i++)scanf("%d",&ST.elem[i].key);}void PrintST(SSTable ST){int i;for(i=1;i<=ST.length;i++)printf("%2d",ST.elem[i].key);printf("\n");}int Search_Bin(SSTable ST,KeyType key){//在有序表ST中折半查找其关键字等于key的数据元素//若找到,则函数值为该元素在表中的位置,否则为0int low,high,mid;low=1;high=ST.length;//置区间初值printf("下标:");while(low<=high){mid=(low+high)/2;printf("%d→",mid);if(EQ(key,ST.elem[mid].key))return mid;//找到待查元素else if(LT(key,ST.elem[mid].key))high=mid-1;//继续在前半区间进行查找else low=mid+1;}return 0;//顺序表中不存在待查元素}void main(){SSTable ST;KeyType key;InitST(ST);CreateST(ST);printf("顺序查找表:");PrintST(ST);printf("输入要查找的关键字:");scanf("%d",&key);int found=Search_Bin(ST,key);if(found)printf("找到,为第%d个数据\n",found);else printf("没有找到!\n");}（3）直接插入排序#include <stdio.h>#define MAXSIZE 20#define LT(a,b) ((a)<(b))typedef int KeyType;typedef struct{KeyType key;}RedType;//记录类型typedef struct{RedType r[MAXSIZE+1];//r[0]闲置或用作哨兵单元int length;//顺序表长度}SqList;//顺序表类型void CreateSq(SqList &L){int i;printf("输入表长:");scanf("%d",&L.length);for(i=1;i<=L.length;i++)scanf("%d",&L.r[i].key);}void PrintSq(SqList L){int i;for(i=1;i<=L.length;i++)printf("%2d",L.r[i].key);printf("\n");}void InsertSort(SqList &L){//对顺序表L作直接插入排序int i,j;printf("排序过程:\n");for(i=2;i<=L.length;++i){if(LT(L.r[i].key,L.r[i-1].key)){//"<",需将L.r[i]插入有序子表L.r[0]=L.r[i];//复制为哨兵L.r[i]=L.r[i-1];for(j=i-2;LT(L.r[0].key,L.r[j].key);--j)L.r[j+1]=L.r[j];//记录后移L.r[j+1]=L.r[0];//插入到正确位置}PrintSq(L);}}//InsertSortvoid main(){SqList L;CreateSq(L);printf("原始顺序表:");PrintSq(L);InsertSort(L);printf("排序后的顺序表:");PrintSq(L);}（4）快速排序#include <stdio.h>#define MAXSIZE 20typedef int KeyType;typedef struct{KeyType key;}RedType;//记录类型typedef struct{RedType r[MAXSIZE+1];//r[0]闲置或用作哨兵单元int length;//顺序表长度}SqList;//顺序表类型void CreateSq(SqList &L){int i;printf("输入表长:");scanf("%d",&L.length);for(i=1;i<=L.length;i++)scanf("%d",&L.r[i].key);}void PrintSq(SqList L){int i;for(i=1;i<=L.length;i++)printf("%2d",L.r[i].key);printf("\n");}int Partition(SqList &L,int low,int high){//交换顺序表L中子表r[low…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[low].key<=pivotkey)++low;L.r[high]=L.r[low];//将比枢轴记录大的记录移到高端}L.r[low]=L.r[0];//枢轴记录到位PrintSq(L);return low;//返回枢轴位置}//Partitionvoid QSort(SqList &L,int low,int high){//对顺序表L中的子序列L.r[low…high]作快速排序int pivotloc;if(low<high){//长度大于1pivotloc=Partition(L,low,high);//将L.r[low…high]一分为二QSort(L,low,pivotloc-1);//对低子表递归排序,pivotloc是枢轴位置QSort(L,pivotloc+1,high);//对高子表递归排序}}//QSortvoid QuickSort(SqList &L){//对顺序表L作快速排序printf("排序过程:\n");QSort(L,1,L.length);}//QuickSortvoid main(){SqList L;CreateSq(L);printf("原始顺序表:");PrintSq(L);QuickSort(L);printf("快速排序后的顺序表:");PrintSq(L);}。
数据结构实验六 查找与排序
数据结构实验六查找与排序班级学号姓名分数一、实验目的：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趟。
数据结构中查找和排序算法实验报告
for(i=ST.length; !EQ(ST.elem[i].key,key); --i);
return i;
}
3.归并排序算法描述如下：
merge(ListType r,int l,int m,int n,ListType &r2)
{
i=l;j=m+1;k=l-1;
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)
将两个或两个以上的有序表组合成一个新的有序表的方法叫归并。
假设初始序列含有n个记录，则可看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或1的有序子序列；再两两归并，如此重复。
4.堆排序分析:
只需要一个记录大小的辅助空间，每个待排序的记录仅占有一个存储空间。
什么是堆？n个元素的序列{k1,k2,...,kn}当且仅当满足下列关系时，称之为堆。关系一：ki<=k2i关系二：ki<=k2i+1（i=1,2,...,n/2)
静态查找表的顺序存储结构：
typedef struct {ElemType *e源自em;int length;
}SSTable;
顺序查找：从表中最后一个记录开始，逐个进行记录的关键字和给定值的比较，若某个记录的关键字和给定值比较相等，则查找成功，找到所查记录；反之，查找不成功。
实验六 查找和排序
实验六查找
一、实验目的：
1．掌握顺序查找、折半查找及二叉排序树上查找的基本思想和算法实现，了解怎样对各种查找方法进行时间性能（平均查找长度）分析。
2．掌握各种排序方法的基本思想、排序过程、算法实现，能进行时间和空间性能的分析，根据实际问题的特点和要求选择合适的排序方法。
二、实验内容：
1．将（45，24，55，12，37，53，60，28，40，70）中关键字依次插入初态为空的二叉排序树中，给出树的中序序列。
2．设计一组随机数据输入，分别对线性表进行顺序查找；选择一种合适排序算法排序，排序后对线性表采用折半查找（递归和非递归）。
3．实现直接插入排序、快速排序、归并排序算法。
三、实验要求：
1. 根据实验内容编程，上机调试、得出正确的运行程序。
2．写出实验报告（包括源程序和运行结果）。
五、主要算法及其流程图
六、输入数据和运行结果
七、算法复杂度（时间和空间）
八、实验小结。
查找排序实验报告
查找排序实验报告一、实验目的本次实验的主要目的是深入理解和比较不同的查找和排序算法在性能和效率方面的差异。
通过实际编程实现和测试，掌握常见查找排序算法的原理和应用场景，为今后在实际编程中能够选择合适的算法解决问题提供实践经验。
二、实验环境本次实验使用的编程语言为 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 语言实现上述六种查找排序算法，并分别封装成函数，以便后续调用和测试。
查找和排序实验报告
附件（四）深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：查找排序实验.学院：计算机与软件学院专业：指导教师：报告人：学号：班级：实验时间：实验报告提交时间：教务处制①②③④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。
实验6 排序和查找
实验6 排序和查找
1实验目的
1)掌握常见的排序算法(插入排序、交换排序、选择排序等)的思想、特点及其适用条件；
2)熟练掌握常见的排序算法（直接插入排序、冒泡排序和简单选择排序）的程序实现；
3)掌握有序表、无序表查找的基本思想及存储、运算的实现。
2 实验环境
1）硬件：每个学生需配备计算机一台
2）操作系统：Windows；
3）开发环境：eclipse。
3 实验学时
3学时
4 实验内容
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));}【实验心得】这是本学期的最后一节实验课，实验的内容是查找与排序。
查找、排序的应用实验
淮海工学院计算机科学系实验报告书课程名：《数据结构》题目：查找、排序的应用实验班级：软件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.不能太过死板，要灵活运用所学知识。
数据结构实验报告——查找与排序
哈尔滨工业大学(深圳)数据结构实验报告查找与排序学院: 计算机科学与技术一、问题分析此题是一道排序问题，排序的方法有很多种，此题我用的是堆排序，这是一种不稳定排序，但时间复杂度较低，比较快。
计算机首先需要把文件中的数据读入内存中，用动态数组存储数据，然后建立数据结构，然后建立堆，比较子节点和父节点大小，降序排列，之后互换头结点与尾节点，再递归重复即可。
查找的话，依次查找对比即可。
二、详细设计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>根据提示输入股票代码及交易日期，以空格隔开。
实验6 查找和排序
实验六、七：查找、排序算法的应用班级 10512 学号 20103051224 姓名苏晓菲一、实验目的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.h>#define maxsize 50typedef int KeyType;KeyType key;typedef struct{int number;int chengji1,chengji2;char name[20];char banji;}DataType;typedef struct{DataType data[maxsize];int len;}Seqlist;void InitSeqlist(Seqlist &L){L.len=0;}void CreateSeqlist(Seqlist &L){cout<<"请输入线性表的长度:";cin>>L.len;cout<<"请输入学生信息:"<<endl<<"学号姓名班级C++ 数据结构"<<endl;for(int i=0;i<L.len;i++){cin>>L.data[i].number>>L.data[i].name>>L.data[i].banji>>L.data[i].chengji1>>L .data[i].chengji2;}cout<<"当前学生信息为:"<<endl;for(int j=0;j<L.len;j++){cout<<L.data[j].number<<" "<<L.data[j].name<<" "<<L.data[j].banji<<" "<<L.data[j].chengji1<<" "<<L.data[j].chengji2;cout<<endl;}}//顺序查找方法void S_Search(SeqList L,char na[20]){int result;for(int i=1;i<=L.len;i++)result=strcmp(L.data[i].name,na);if(result==0){cout<<L.data[i].number<<" "<<L.data[i].name<<" "<<L.data[i].banji<<" "<<L.data[i].score1<<" "<<L.data[i].score2<<endl;break;}}if(i>L.len)cout<<"不存在该学生"<<endl;}//二分查找方法void Binary_Search(SeqList &L,int nu){ int low=1,high=L.len,mid;while(low<=high){mid=(low+high)/2;if(L.data[mid].number==nu){cout<<L.data[mid].number<<" "<<L.data[mid].name<<" "<<L.data[mid].banji<<" "<<L.data[mid].score1<<" "<<L.data[mid].score2<<endl;break;}else if(L.data[mid].number>nu)high=mid-1;else low=mid+1;}if(low>high)cout<<"不存在该学生！"<<endl;}//直接插入排序void InsertSort(SeqList &L){int i, j;for( i=2; i<=L.len; i++ )int result1=strcmp(L.data[i].name , L.data[i-1].name);if (result1<0){L.data[0]=L.data[i]; // 复制为哨兵for(j=i-1;strcmp(L.data[0].name,L.data[j].name)<0; j-- )L.data[j+1]=L.data[j]; // 记录后移L.data[j+1]=L.data[0]; // 插入到正确位置}}}//直接选择排序void SelectSort(SeqList &L){ int i, j,k;DataType temp;for( i=1; i<L.len; i++ ){ k = i;for( j=i+1; j<=L.len; j++ ){if( L.data[j].score1 < L.data[k].score1 )k = j ;}if( k != i ){temp = L.data[i];L.data[i] = L.data[k];L.data[k] =temp;}}}//冒泡排序void BubbleSort(SeqList &L){ int i,j,flag=1; DataType x;for(i=1;((i<L.len)&&(flag==1));i++){ flag=0;for(j=1;j<L.len-i+1;j++)if(L.data[j].score2>L.data[j+1].score2){ x=L.data[j];L.data[j]=L.data[j+1];L.data[j+1]=x; flag=1;}}}void Print_SeqList(SeqList L){for(int i=1;i<=L.len;i++){cout<<L.data[i].number<<" ";cout<<L.data[i].name<<" ";cout<<L.data[i].banji<<" ";cout<<L.data[i].score1<<" ";cout<<L.data[i].score2<<endl;}}void main(){SeqList L;Init_SeqList(L);Create_SeqList(L);char na[20];for(int i=0;i<2;i++){cout<<"请输入要查找的学生姓名："<<endl;cin>>na;S_Search(L,na);cout<<"----------------------------"<<endl;}int nu;for(int j=0;j<2;j++){cout<<"请输入要查找的学生学号："<<endl;cin>>nu;Binary_Search(L,nu);cout<<"----------------------------"<<endl;}InsertSort(L);cout<<"按姓名进行排序后的结果："<<endl;Print_SeqList( L);cout<<"----------------------------"<<endl;SelectSort(L);cout<<"按C++成绩进行排序后的结果："<<endl;Print_SeqList( L);cout<<"----------------------------"<<endl;BubbleSort(L);cout<<"按数据结构成绩进行排序后的结果："<<endl;Print_SeqList( L);}程序运行结果如下：四、实验总结在按姓名查找和排序时，忘记字符数组有自己的方法来实现数组的大小比较，应使用strcmp(a,b)方法。
查找排序算法实验报告(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. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 排序算法（1）冒泡排序冒泡排序是一种简单的排序算法，基本思想是通过相邻元素的比较和交换，逐步将较大的元素移动到序列的后面，较小的元素移动到序列的前面，直到整个序列有序。
（2）选择排序选择排序是一种简单直观的排序算法，基本思想是遍历整个序列，每次从剩余未排序的元素中找到最小（或最大）的元素，将其与未排序序列的第一个元素交换，然后继续在剩余未排序的元素中寻找最小（或最大）的元素。
（3）插入排序插入排序是一种简单直观的排序算法，基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
（4）快速排序快速排序是一种效率较高的排序算法，基本思想是选取一个基准值，将待排序序列分为两个子序列，一个子序列中所有元素都比基准值小，另一个子序列中所有元素都比基准值大，然后递归地对两个子序列进行快速排序。
2. 查找算法（1）顺序查找顺序查找是一种最简单的查找算法，基本思想是从线性表的第一个元素开始，依次将线性表中的元素与要查找的元素进行比较，若相等，则查找成功；若线性表中所有元素都与要查找的元素不相等，则查找失败。
（2）二分查找二分查找是一种效率较高的查找算法，基本思想是对于有序的线性表，通过将待查找元素与线性表中间的元素进行比较，逐步缩小查找范围，直到找到目标元素或查找失败。
四、实验结果与分析1. 排序算法分析（1）冒泡排序：时间复杂度为O(n^2)，空间复杂度为O(1)，稳定排序。
（2）选择排序：时间复杂度为O(n^2)，空间复杂度为O(1)，不稳定排序。
（3）插入排序：时间复杂度为O(n^2)，空间复杂度为O(1)，稳定排序。
查找排序实验报告
查找、排序实验班级学号姓名一、实验目的1 掌握不同的查找和排序方法，并能用高级语言实现相应算法。
2 熟练掌握顺序查找和二分查找方法。
3 熟练掌握直接插入排序、选择排序、冒泡排序、快速排序。
二、实验内容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> using namespace std; #include <string>#include <iomanip> #define M 100 typedef string Keytype; typedef struct{Keytype classNum;Keytype name;int studentNum;int C;int structure;}Student;typedef struct{Student s[M];int length;}s_t;int creat(s_t *t,int Num){int i;t->length=Num;for(i=1;i<=t->length;i++){cout<<"请输入第"<<i<<"个学生的信息(学号，姓名，班级，C++，数据结构):"<<endl;cin>>t->s[i].studentNum>>t->s[i].n ame>>t->s[i].classNum>>t->s[i].C>>t->s [i].structure;}return 0;}int print(s_t *t){int i;cout<<" "<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构"<<" "<<endl;for(i=1;i<=t->length;i++){cout<<" "<<t->s[i].studentNum<<""<<t->s[i].name<<""<<t->s[i].classNum<<""<<t->s[i].C<<""<<t->s[i].structure<<" "<<endl;}return 0;}int S_Search(s_t *t,Keytype kx){int i;t->s[0].name=kx;for(i=t->length;i>=0;i--)if(t->s[i].name==kx)return i;}void InserSort(s_t *t){int i;for(i=2;i<=t->length;i++)if(t->s[i].name<t->s[i-1].name){t->s[0]=t->s[i];for(intj=i-1;t->s[0].name<t->s[j].name;j--)t->s[j+1]=t->s[j];t->s[j+1]=t->s[0];}}int Select_Sort(s_t *t){int i,j,k;for(i=0;i<t->length;i++){k=i;for(j=i+1;j<=t->length;j++)if(t->s[k].C>t->s[j].C)k=j;if(i!=k){t->s[0]=t->s[k];t->s[k]=t->s[i];t->s[i]=t->s[0];}}return 0;}int Half_Sort(s_t *t,int num){int flag=0;int low,high,mid;low=1;high=t->length;while(low<=high){mid=(low+high)/2;if(t->s[mid].studentNum>num)high=mid-1;elseif(t->s[mid].studentNum<num)low=mid+1;else{flag=mid;break;}}return flag;}int Bu_Sort(s_t *t){int i,j,swap;for(i=1;i<t->length;i++){swap=0;for(j=1;j<=t->length-i;j++)if(t->s[j].structure>t->s[j+1].structur e){t->s[0]=t->s[j];t->s[j]=t->s[j+1];t->s[j+1]=t->s[0];swap=1;}if(swap==0)break;}return 0;}int Partition(s_t *t,int i,int j){t->s[0]=t->s[i];while(i<j){while(i<j&&t->s[j].studentNum>=t->s[0] .studentNum)j--;if(i<j){t->s[i]=t->s[j];i++;}while(i<j&&t->s[i].studentNum<t->s[0].stude ntNum)i++;if(i<j){t->s[j]=t->s[i];j--;}}t->s[i]=t->s[0];return i;}void Quick_sort(s_t *t,int s,int p){int i;if(s<p){i=Partition(t,s,p);Quick_sort(t,s,i-1);Quick_sort(t,i+1,p);}}void Quick(s_t *t,int n){Quick_sort(t,1,n);}int main(){s_t *t;int i,n,n1,Num;int flag=1;Keytype kx;t=new s_t;cout<<" *********欢迎进入学生管理系统************** "<<endl;cout<<" 1 按姓名顺序查找2 输出所有学生信息 3 直接插入排序"<<endl;cout<<" 4 按C++选择排序5 按学号二分查找 6 按数据结构冒泡排序"<<endl;cout<<" 7 按学号快速排序8 建立学生的信息0 退出程序"<<endl;cout<<"********************************* *********** "<<endl;while(flag){cout<<"请选择要进行的操作:";cin>>n;switch(n){case 1:cout<<"请输入要查找的学生的姓名:"<<endl;cin>>kx;i=S_Search(t,kx);if(i){cout<<" "<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构"<<" "<<endl;cout<<""<<t->s[i].studentNum<<""<<t->s[i].name<<""<<t->s[i].classNum<<""<<t->s[i].C<<""<<t->s[i].structure<<" "<<endl;cout<<endl;}else cout<<"没有此人！"<<endl;break;case 2:cout<<"输出现在学生的全部信息:"<<endl;print(t);break;case 3:cout<<"直接插入排序:"<<endl;cout<<"排序前的学生信息"<<endl;print(t);cout<<"排序后的学生信息"<<endl;InserSort(t);print(t);break;case 4:cout<<"选择排序:"<<endl;cout<<"排序前的学生信息"<<endl;print(t);Select_Sort(t);cout<<"排序后的学生信息"<<endl;print(t);break;case 5:Select_Sort(t);cout<<"输入要查找的学号"<<endl;cin>>n1;i=Half_Sort(t,n1);if(i){cout<<" "<<"学号"<<" "<<"姓名"<<" "<<"班级"<<" "<<"C++成绩"<<" "<<"数据结构"<<" "<<endl;cout<<""<<t->s[i].studentNum<<""<<t->s[i].name<<""<<t->s[i].classNum<<""<<t->s[i].C<<""<<t->s[i].structure<<" "<<endl;cout<<endl;}else cout<<"不存在此学号!"<<endl;break;case 6:cout<<"冒泡排序"<<endl;cout<<"排序前的学生信息"<<endl;print(t);Bu_Sort(t);cout<<"排序后的学生信息"<<endl;print(t);break;case 7:cout<<""<<endl;print(t);cout<<""<<endl;Quick(t ,Num);print(t);break;case 8:cout<<"请输入学生的个数：";cin>>Num;creat(t,Num);break;case 0: return 0;default:cout<<"没有此功能，请选择正确的操作！"<<endl;break;}}return 0;} else cout<<"没人得此成绩！"<<endl;break;case 6:Bu_Sort(t);print(t);break;case 7:Quick(t ,Num);break;case 8:cout<<"请输入学生的个数：";cin>>Num;creat(t,Num);break;case 0: return 0;default:cout<<"没有此功能，请选择正确的操作！"<<endl;break;}}return 0;}运行结果：表1 输入学生信息表2 顺序查找方法表3 按姓名直接插入表4 按C成绩选择排序表5 按学号进行二分法查找表6 按数据结构成绩进行冒泡法排序四、实验总结（1）直接插入排序时，要明确后移的结束条件，以便进行正确插入。
数据结构实验报告五,查找与排序-
实验六查找与排序一、实验目的：1．理解掌握查找与排序在计算机中的各种实现方法。
2．学会针对所给问题选用最适合的算法。
3．熟练掌握常用排序算法在顺序表上的实现。
二、实验要求：掌握利用常用的查找排序算法的思想来解决一般问题的方法和技巧，进行算法分析并写出实习报告。
三、实验内容及分析：设计一个学生信息管理系统，学生对象至少要包含：学号、性别、成绩1、成绩总成绩等信息。
要求实现以下功能：1．平均成绩要求自动计算；2．查找：分别给定学生学号、性别，能够查找到学生的基本信息（要求至少用两种查找算法实现）；3．排序：分别按学生的学号、成绩1、成绩2、平均成绩进行排序（要求至少用两种排序算法实现）。
四、程序的调试及运行结果五、程序代码#include<stdio.h>#include<string.h>struct student//定义结构体{char name[30];int a1,a2,a3,num;double pow;}zl[100];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",&a);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",&a);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",&b);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'&&count<100);//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'&&count<100);paixv(count);diaoyong(count);}void xianshi() //显示{int i;printf("学号\t \t姓名\t\t\t平均成绩\n");for(i=0;i<count;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;i<count;i++){for(j=1;j<count-i;j++){if(zl[j-1].pow<zl[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;i<count;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;i<count;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;i<count;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;i<count;i++){if(zl[i].num==num){for(j=i;j<count;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、插入排序每步将一个待排序的记录，按其关键码大小，插入到前面已经排好序的一组记录的适当位置上，直到记录全部插入为止。
查找排序实验报告
《编程实训》实验报告书专业：计算机科学与技术班级：151班学号：姓名：指导教师：日期：2016年6月30日目录一、需求分析 (3)1.任务要求 (3)2.软件功能分析 (3)3.数据准备 (3)二、概要设计 (3)1.功能模块图 (4)2.模块间调用关系 (4)3.主程序模块 (5)4.抽象数据类型描述 (5)三、详细设计 (6)1.存储结构定义 (6)2.各功能模块的详细设计 (7)四、实现和调试 (7)1.主要的算法 (7)2.主要问题及解决 (8)3.测试执行及结果 (8)五、改进 (9)六、附录 (9)1.查找源程序 (9)2.排序源程序 (9)目录1 需求分析1.1 任务要求对于从键盘随机输入的一个序列的数据，存入计算机内，给出各种查找算法的实现；以及各种排序算法的实现。
1.2 软件功能分析任意输入n个正整数，该程序可以实现各类查找及排序的功能并将结果输出。
1.3 数据准备任意输入了5个正整数如下：12 23 45 56 782 概要设计（如果2，3合并可以省略2.4）2.1 功能模块图（注：含功能说明）2.2 模块间调用关系2.3 主程序模块2.4 抽象数据类型描述存储结构：数据结构在计算机中的表示（也称映像）叫做物理结构。
又称为存储结构。
数据类型（data type）是一个“值”的集合和定义在此集合上的一组操作的总称。
3 详细设计3.1 存储结构定义查找：typedef int ElemType ;//顺序存储结构typedef struct{ElemType *elem; //数据元素存储空间基址，建表时按实际长度分配，号单元留空int length; //表的长度}SSTable;排序：typedef struct{ //定义记录类型int key; //关键字项}RecType;typedef RecType SeqList[Max+1]; //SeqList为顺序表，表中第0个元素作为哨兵3.2 各功能模块的详细设计查找：void Create(SSTable *table, int length); // 构建顺序表void FillTable(SSTable *table) // 无序表的输入int Search_Seq(SSTable *table, ElemType key); //哨兵查找算法void Sort(SSTable *table ) // 排序算法int Search_Bin(SSTable *table, ElemType key) // 二分法查找（非递归）排序：void InsertSort(SeqList R) //对顺序表R中的记录R[1‥n]按递增序进行插入排序void BubbleSort(SeqList R) //自下向上扫描对R做冒泡排序int Partition(SeqList R,int i,int j)//对R[i‥j]做一次划分，并返回基准记录的位置void QuickSort(SeqList R,int low,int high) //R[low..high]快速排序void SelectSort(SeqList R) //直接选择排序void Heapify(SeqList R,int low,int high) //大根堆调整函数void MergePass(SeqList R,int length) //归并排序4 实现和调试4.1 主要的算法查找：①建立顺序存储结构，构建一个顺序表，实现顺序查找算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验六、七：查找、排序算法的应用班级 10511 学号 20103051114 姓名高卫娜一、实验目的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.h>#include<string.h>#include <stdlib.h>#define MAXSIZE 10typedef char KeyType1;typedef int KeyType2;typedef struct{//学号姓名班级C++ 数据结构KeyType1 name[20];KeyType2 xuehao;KeyType1 Class[20];double score[2];} DataType;typedef struct{DataType data[MAXSIZE+1];int len;} SeqList;//顺序表的创建void create(SeqList &L){cout<<"请输入顺序表的大小:"<<endl;cin>>L.len;cout<<"请输入顺序表中八条学生信息（学号姓名班级C++ 数据结构）:"<<endl;for(int i=1;i<=L.len;i++){cin>>L.data[i].xuehao;cin>>L.data[i].name;cin>>L.data[i].Class;cin>>L.data[i].score[0];cin>>L.data[i].score[1];}}void Input(SeqList &L){for(int i=1;i<=L.len;i++){cin>>L.data[i].xuehao;cin>>L.data[i].name;cin>>L.data[i].Class;cin>>L.data[i].score[0];cin>>L.data[i].score[1];}}//顺序表的显示void print(SeqList L){cout<<"学号姓名班级C++ 数据结构"<<endl;if(L.len==0){cout<<"该表是空表！"<<endl;return;}for(int i=1;i<=L.len;i++){cout<<" "<<L.data[i].xuehao<<" "<<L.data[i].name<<" "<<L.data[i].Class<<" "<<L.data[i].score[0]<<" "<<L.data[i].score[1];cout<<endl;}}//顺序查找方法从查找表中查找姓名为赵阳和王夏的学生void S_Search(SeqList L){char na[20];cout<<"请输入要查找的同学的姓名："<<endl;cin>>na;strcpy(L.data[0].name,na); //监视哨int i=L.len;while(strcmp(L.data[i].name,na)>0||strcmp(L.data[i].name,na)<0)i--;if(i>0){cout<<"您要查找的学生的信息："<<endl; cout<<"学号姓名班级C++ 数据结构"<<endl;cout<<" "<<L.data[i].xuehao<<" "<<L.data[i].name<<" "<<L.data[i].Class<<" "<<L.data[i].score[0]<<" "<<L.data[i].score[1];cout<<endl;}if(i<=0){cout<<"对不起，没有该同学的信息！"<<endl;}}//二分查找方法从查找表中查找学号为7和12的学生//非递归void Binary_Search(SeqList &L){int kx;cout<<"请输入您要查找的学生信息的学号："<<endl;cin>>kx;int low=1,high=L.len,mid;while(low<=high){mid=(low+high)/2;if(L.data[mid].xuehao==kx){cout<<"您要查找的学生的信息："<<endl; cout<<"学号姓名班级C++ 数据结构"<<endl;cout<<" "<<L.data[mid].xuehao<<" "<<L.data[mid].name<<" "<<L.data[mid].Class<<" "<<L.data[mid].score[0]<<" "<<L.data[mid].score[1];cout<<endl;break;}else if(L.data[mid].xuehao>kx)high=mid-1;elselow=mid+1;}if(low>high){cout<<"没有该学号的学生信息！"<<endl;}}//直接插入排序方法对顺序表直接插入排序的算法对学生信息中的姓名进行排序：void InsertSort( SeqList &L ){int i, j;for( i=2; i<=L.len; i++ )if(strcmp(L.data[i].name, L.data[i-1].name)<0){L.data[0]=L.data[i]; // 复制为哨兵for(j=i-1; strcmp(L.data[0].name, L.data[j].name)<0; j-- )L.data[j+1]=L.data[j]; // 记录后移L.data[j+1]=L.data[0]; // 插入到正确位置}print(L);}//直接选择排序方法对学生信息中的C成绩进行排序void SelectSort(SeqList &L){int i, j,k;DataType temp;for( i=1; i<L.len; i++ ){k = i;for( j=i+1; j<=L.len; j++ )if( L.data[j].score[0] < L.data[k].score[0] )k = j ;if( k != i ){temp = L.data[i];L.data[i] = L.data[k];L.data[k] =temp;}}print(L);}//冒泡排序方法对学生信息中的数据结构成绩进行排序void BubbleSort(SeqList &L){int i,j,flag=1;DataType x;for(i=1;((i<L.len)&&(flag==1));i++){flag=0;for(j=1;j<L.len-i+1;j++)if(L.data[j].score[1]>L.data[j+1].score[1]){x=L.data[j];L.data[j]=L.data[j+1];L.data[j+1]=x;flag=1;}}print(L);}void main(){SeqList L;int a;cout<<endl;while(a!=0){cout<<endl;cout<<"-------------------------欢迎使用学生信息系统----------------------------\n"<<endl;cout<<endl;cout<<" 1 ：录入学生信息 2 ：按姓名查找学生信息3：按学号查找学生信息"<<endl;cout<<endl;cout<<" 4 ：按姓名排序后学生信息5 ：按c成绩排序学生信息"<<endl;cout<<endl;cout<<" 6 ：按数据结构成绩排序后学生信息7 ：显示0 ：退出"<<endl;cout<<endl;cout<<"--------------------------------------------------------------------------"<<endl;cout<<endl;cout<<"输入您的选择为：";cin>>a;switch(a){case 1:{ create(L); break; }case 2: //顺序查找方法从查找表中查找姓名为赵阳和王夏的学生{ S_Search(L); break; }case 3:{ Binary_Search(L); break; }case 4:{cout<<"对学生信息中的姓名进行排序为："<<endl;InsertSort(L);break;}case 5:{cout<<"对学生信息中的C成绩进行从低到高排序为："<<endl;SelectSort(L);break;}case 6:{cout<<"对学生信息中的数据结构成绩进行从低到高排序为："<<endl;BubbleSort(L);break;}case 7:{ print(L); break; }case 0: exit(0);default:{cout<<"您输入的序号不正确，请重新输入："<<endl;break;}}}}建立顺序表的运行结果为图1-1：图1-1录入学生信息查找的运行结果如图1-2,图1-3：图1-2按姓名查找图1-3按学号查询排序的运行结果如下图1-4,图1-5,图1-6：图1-4按姓名排序图1-5按c成绩排序图1-6按数据结构成绩排序结束结果如图1-7:图1-7推出程序四、实验总结（1）exit(0)需要头文件#include<stdlib.h>退出程序；（2）比较字符串使用头文件#<string.h>中得strcmp（）；复制字符串使用strcpy（）；（3）从表的一端开始，向另一端逐个将给定值x与关键码进行比较；使用折半查找的前提：查找表必须是有序表；在有序表中，取中间元素作为比较对象（4）直接插入排序是一种稳定的排序方法。