数据结构实验—排序

实验8 快速排序1．需求分析（1）输入的形式和输入值的范围：第一行是一个整数n，代表任务的件数。

接下来一行，有n个正整数，代表每件任务所用的时间。

中间用空格或者回车隔开。

不对非法输入做处理，及假设用户输入都是合法的。

（2）输出的形式：输出有n行，每行一个正整数，从第一行到最后一行依次代表着操作系统要处理的任务所用的时间。

按此顺序进行，则使得所有任务等待时间最小。

（3）程序所能达到的功能：在操作系统中，当有n 件任务同时来临时，每件任务需要用时ni，输出所有任务等待的时间和最小的任务处理顺序。

（4）测试数据：输入请输入任务个数：9请输入任务用时：5 3 4 2 6 1 5 7 3输出任务执行的顺序：1 2 3 3 4 5 5 6 72．概要设计（1）抽象数据类型的定义：为实现上述程序的功能，应以整数存储用户的第一个输入。

并将随后输入的一组数据储存在整数数组中。

（2）算法的基本思想：如果将任务按完成时间从小到大排序，则在完成前一项任务时后面任务等待的时间总和最小，即得到最小的任务处理顺序。

采取对输入的任务时间进行快速排序的方法可以在相对较小的时间复杂度下得到从小到大的顺序序列。

3．详细设计（1）实现概要设计中定义的所有数据类型：第一次输入的正整数要求大于零，为了能够存储，采用int型定义变量。

接下来输入的一组整数，数据范围大于零，为了排序需要，采用线性结构存储，即int类型的数组。

（2）实现程序的具体步骤：一.程序主要采取快速排序的方法处理无序数列：1．在序列中根据随机数确定轴值，根据轴值将序列划分为比轴值小和比轴值大的两个子序列。

2．对每个子序列采取从左右两边向中间搜索的方式，不断将值与轴值比较，如果左边的值大于轴值而右边的小于轴值则将二者交换，直到左右交叉。

3．分别对处理完毕的两个子序列递归地采取1，2步的操作，直到子序列中只有一个元素。

二.程序各模块的伪代码：1、主函数int main(){int n;cout<<"请输入任务个数：";cin>>n;int a[n];cout<<"请输入任务用时：";for(int i=0;i<n;i++) cin>>a[i];qsort(a,0,n-1); //调用“快排函数”cout<<"任务执行的顺序：";for(int i=0;i<n;i++) cout<<a[i]<<" "; //输出排序结果}2、快速排序算法：void qsort(int a[],int i,int j){if(j<=i)return; //只有一个元素int pivotindex=findpivot(a,i,j); //调用“轴值寻找函数”确定轴值swap(a,pivotindex,j); //调用“交换函数”将轴值置末int k=partition(a,i-1,j,a[j]); //调用“分割函数”根据轴值分割序列swap(a,k,j);qsort(a,i,k-1); //递归调用，实现子序列的调序qsort(a,k+1,j);}3、轴值寻找算法：//为了保证轴值的“随机性”，采用时间初始化种子。

实验八排序一、实验目的1、掌握常用的排序方法，如归并排序、快速排序等。

2、深刻理解排序的定义和排序方法的特点，并能加以灵活应用。

3、能够分析各种算法的效率和适用条件。

二、实验要求1、认真阅读程序。

2、上机调试，并运行程序。

3、保存和截图程序的运行结果，并结合程序进行分析。

三、实验内容和基本原理1、实验8.1 归并排序的实现已知关键字序列为{1,8,6,4,10,5,3,2,22}，请对此序列进行归并排序，并输出结果。

见参考程序8.1。

2、实验8.2快速排序的实现快速排序是通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

见参考程序8.2。

参考程序8.1归并排序#include"stdio.h"int num=0;void print_data(int data[],int first,int last){int i=0;for(i=0;i<first;i++)printf("*");for(i=first;i<=last;i++)printf("%3d",data[i]);for(i=last;i<=8;i++)printf("*");printf("\n");}void merge(int array[],int first,int last)/*一趟归并*/{int mid,i1,i2,i3;int temp[10];int i,j;mid=(first+last)/2;i1=0;i2=first;i3=mid+1;while(i2<=mid&&i3<=last){if(array[i2]<array[i3])temp[i1++]=array[i2++];elsetemp[i1++]=array[i3++];}if(i2<=mid)while(i2<=mid)temp[i1++]=array[i2++];if(i3<=last)while(i3<=last)temp[i1++]=array[i3++];for(i=first,j=0;i<=last;i++,j++)array[i]=temp[j];print_data(array,first,last);}void mergesort(int data[],int first,int last)/*归并排序*/{int mid;if(first<last){mid=(first+last)/2;mergesort(data,first,mid);mergesort(data,mid+1,last);print_data(data,first,last);merge(data,first,last);}}void main(){int a[]={1,8,6,4,10,5,3,2,22};/*可根据实际情况初始化*/ mergesort(a,0,8);}参考程序8.2快速排序#include<iostream.h>#include"stdio.h"#define MAX 8int QuickSort(int a[],int l,int r){int pivot;//枢轴int i=l;int j=r;int tmp;pivot=a[(l+r)/2];//取数组中间的数为枢轴do{while(a[i]<pivot)i++;//i右移while(a[j]>pivot)j--;//j左移if(i<=j){tmp=a[i];a[i]=a[j];a[j]=tmp;//交换a[i]和a[j]i++;j--;}}while(i<=j);if(l<j)QuickSort(a,l,j);if (i<r)QuickSort(a,i,r);return 1; }/*********************************************/ int main(){ int array[MAX];int i;printf("请输入%d个整数:",MAX);for (i=0;i<MAX;i++)scanf("%d",&array[i]);QuickSort(array,0,MAX-1);printf("快速排序后:");for (i=0;i<MAX;i++)printf("%d ",array[i]);printf("\n");return 0;}四、实验验证与练习1、设给定的排序码序列为（72，73，71，23，94，16，05，68），请写出归并排序和快速排序过程中每趟排序的结果。

实验报告课程名称数据结构实验名称查找与排序得实现系别专业班级指导教师１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.在调试程序得过程中遇到什么问题,就是如何解决得?问题:在计算比较次数与移动次数时，计算数据明显出错。

数据结构排序实验报告数据结构排序实验报告引言：数据结构是计算机科学中的重要概念之一，它涉及到数据的组织、存储和操作方式。

排序是数据结构中的基本操作之一，它可以将一组无序的数据按照特定的规则进行排列，从而方便后续的查找和处理。

本实验旨在通过对不同排序算法的实验比较，探讨它们的性能差异和适用场景。

一、实验目的本实验的主要目的是通过实际操作，深入理解不同排序算法的原理和实现方式，并通过对比它们的性能差异，选取合适的排序算法用于不同场景中。

二、实验环境和工具实验环境：Windows 10 操作系统开发工具：Visual Studio 2019编程语言：C++三、实验过程1. 实验准备在开始实验之前，我们需要先准备一组待排序的数据。

为了保证实验的公正性，我们选择了一组包含10000个随机整数的数据集。

这些数据将被用于对比各种排序算法的性能。

2. 实验步骤我们选择了常见的五种排序算法进行实验比较，分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。

- 冒泡排序：该算法通过不断比较相邻元素的大小，将较大的元素逐渐“冒泡”到数组的末尾。

实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。

- 选择排序：该算法通过不断选择数组中的最小元素，并将其放置在已排序部分的末尾。

实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。

- 插入排序：该算法将数组分为已排序和未排序两部分，然后逐个将未排序部分的元素插入到已排序部分的合适位置。

实现时，我们使用了循环和条件判断来找到插入位置，并通过移动元素的方式进行排序。

- 快速排序：该算法通过选取一个基准元素，将数组分为两个子数组，并对子数组进行递归排序。

实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序。

- 归并排序：该算法通过将数组递归地划分为更小的子数组，并将子数组进行合并排序。

实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序，然后再将子数组合并起来。

数据结构实验报告排序一、实习目的熟悉几种典型的排序方法，并对各种算法的特点、使用范围和效率有进一步的了解。

二、实例排序是计算机科学中非常基本且使用频繁的运算，在计算机系统软件和应用软件中都有广泛的应用。

下面给出的是冒泡排序、快速排序的实现与比较。

/* 源程序的头文件sort.h */void getra ndat(Data ary[],i nt cou nt) /* 产生一批随机数，准备排序*/{ long int a=100001;int i;for(i=0;i<cou nt;i++){ a=(a*125)%2796203;ary[i].key=(i nt)a;}} /* getra ndat */void prdata(Data ary[],i nt count) I*输出数据的函数*/{ int i; char ch;printf( n“)；for(i=0;i<count;i++) printf( “ ％6c”，ary[i].key);printf( n“)；printf( "\n\n 打回车键，结束显示。

“)；ch=getch();} I* prdata *I[两种排序方法的比较源程序]I* sortcmp.c *I#in clude <stdio.h>#in clude <stdlib.h>#define MAX 1000 I*数组最大界限*Itypedef int ElemType; I* 关键字的类型*Itypedef struct{ ElemType key;int shu;}Data;Data ar[MAX],br[MAX];typedef struct{ int lo,hi;}Selem;typedef struct{ Selem elem[MAX];int top;}SqStack;SqStack s1;/* 函数声明*/void bubble(Data ary[],int n);void getrandat(Data ary[],int count) ; void qksort(Data ary[],int n);void hoare(Data ary[],int l,int h); void init_s(SqStack *s);void push(SqStack *s,Selem e); Selem pop(SqStack *s);void prdata(Data ary[],int count); int empty(SqStack s);/* 主函数*//* 其它属性域*//* 一个纪录的结构体类型*//* 栈的元素结构体类型*//* 一维数组子域*//* 栈顶指针子域*//* 栈的顺序结构体类型*//* 产生一批随机数，准备排序*//* 进栈一个元素*/ /* 输出数据的函数*/void main(){ int k,n,j; j; char ch;do { printf("\n\n\n");printf("\n\n 1. 产生一批随机数准备排序");printf("\n\n 2. 一般情况的起泡排序");printf("\n\n 3. 有序情况的起泡排序");printf("\n\n 4. 一般情况的快速排序");printf("\n\n 5. 有序情况的快速排序");printf("\n================== printf("\n 请输入您的选择 scanf("%d",&k); switch(k){ case 1:{ printf("the number ofdatas:"); /*scanf("%d",&n);getrandat(ar,n); for(j=0;j<n;j++)br[j]=ar[j]; prdata(ar,n); } break;case 2:{ for(j=0;j<n;j++) ar[j]=br[j];bubble(ar,n); prdata(ar,n); } break;case 3: { bubble( ar,n); prdata(ar,n);} break;=================="); (1,2,3，4，5，6)");输入数据个数 *//*产生 n 个随机数 *//* 保留复原始数据 *//* 恢复原始数据 */ /* 对 n 个数据起泡排序 *//* 排序后输出 *//* 有序情况的起泡排序 */ 恢复原始数据*//* 对 n 个数据快速排序 *//* 排序后输出 *//* 有序情况的快速排序 */case 4:{ for(j=0;j<n;j++) ar[j]=br[j]; /*qksort(ar,n); prdata(ar,n);} break;case 5:{ qksort(ar,n);prdata(ar,n);} break;case 6: exit(0);} /* switch */printf("\n --------------- ");}while(k>=1 && k<6);printf("\n 打回车键，返回。

本章共8道实验题目。

一、直接插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行直接插入排序（InsertSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义直接插入排序函数int a[20];int main(){int InsertSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}二、折半插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行折半插入排序（BInsertSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义折半插入排序函数int a[20];int main(){int BInsertSort ;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}三、希尔排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行希尔排序（ShellSort）6. 输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 602 11 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int ShellSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}四、冒泡排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行冒泡排序（BubbleSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int BubbleSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}五、快速排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行快速排序（QuickSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int QuickSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort (a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}六、简单选择排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行简单选择排序（SelectSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序：#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int SelectSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}七、堆排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行堆排序（HeapSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素（用空格隔开）：";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void HeapSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);HeapSort(L);ListTraverse(L);return 0;}八、归并排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行二路归并排序（MergeSort）6.输出排序后的顺序表例如：11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序：#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef structKeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素（用空格隔开）：";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void MSort(){}void Merge(){}void MergeSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);MergeSort(L);ListTraverse(L);return 0;}。

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

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

1．实验要求【实验目的】学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。

【实验内容】使用简单数组实现下面各种排序算法，并进行比较。

排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他要求：1、测试数据分成三类：正序、逆序、随机数据2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。

3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。

2. 程序分析2.1 存储结构存储结构：数组2.2 关键算法分析//插入排序void InsertSort(int r[], int n) {int count1=0,count2=0;插入到合适位置for (int i=2; i<n; i++){r[0]=r[i]; //设置哨兵for (int j=i-1; r[0]<r[j]; j--) //寻找插入位置r[j+1]=r[j]; //记录后移r[j+1]=r[0];count1++;count2++;}for(int k=1;k<n;k++)cout<<r[k]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//希尔排序void ShellSort(int r[], int n){int i;int d;int j;int count1=0,count2=0;for (d=n/2; d>=1; d=d/2) //以增量为d进行直接插入排序{for (i=d+1; i<n; i++){r[0]=r[i]; //暂存被插入记录for (j=i-d; j>0 && r[0]<r[j]; j=j-d)r[j+d]=r[j]; //记录后移d个位置r[j+d]=r[0];count1++;count2=count2+d;}count1++;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//起泡排序void BubbleSort(int r[], int n) {插入到合适位置int temp;int exchange;int bound;int count1=0,count2=0;exchange=n-1; //第一趟起泡排序的范围是r[1]到r[n]while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{bound=exchange;exchange=0;for(int j=0;j<bound;j++) //一趟起泡排序{count1++; //接下来有一次比较if(r[j]>r[j+1]){temp=r[j]; //交换r[j]和r[j+1]r[j]=r[j+1];r[j+1]=temp;exchange=j; //记录每一次发生记录交换的位置count2=count2+3; //移动了3次}}}for(int i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//快速排序一次划分int Partition(int r[], int first, int end,int &count1,int &count2){int i=first; //初始化int j=end;while (i<j){while (i<j && r[i]<= r[j]){j--; //右侧扫描count1++;}count1++;if (i<j){temp=r[i]; //将较小记录交换到前面r[i]=r[j];r[j]=temp;i++;count2=count2+3;}while (i<j && r[i]<= r[j]){i++; //左侧扫描count1++;}count1++;if (i<j){temp=r[j];r[j]=r[i];r[i]=temp; //将较大记录交换到后面j--;count2=count2+3;}}return i; //i为轴值记录的最终位置}//快速排序void QuickSort(int r[], int first, int end,int &count1,int &count2){if (first<end){ //递归结束int pivot=Partition(r, first, end,count1,count2); //一次划分QuickSort(r, first, pivot-1,count1,count2);//递归地对左侧子序列进行快速排序QuickSort(r, pivot+1, end,count1,count2); //递归地对右侧子序列进行快速排序}}//简单选择排序Array void SelectSort(int r[ ], int n){int i;int j;int index;int temp;int count1=0,count2=0;for (i=0; i<n-1; i++) //对n个记录进行n-1趟简单选择排序{index=i;for(j=i+1;j<n;j++) //在无序区中选取最小记录{count1++; //比较次数加一if(r[j]<r[index]) //如果该元素比现在第i个位置的元素小index=j;}count1++; //在判断不满足循环条件j<n时，比较了一次if(index!=i){temp=r[i]; //将无序区的最小记录与第i个位置上的记录交换r[i]=r[index];r[index]=temp;count2=count2+3; //移动次数加3 }}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//筛选法调整堆void Sift(int r[],int k,int m,int &count1,int &count2) //s，t分别为比较和移动次数{int i;int j;int temp;i=k;j=2*i+1; //置i为要筛的结点，j为i的左孩子while(j<=m) //筛选还没有进行到叶子{if(j<m && r[j]<r[j+1]) j++; //比较i的左右孩子，j为较大者count1=count1+2; //该语句之前和之后分别有一次比较if(r[i]>r[j])break; //根结点已经大于左右孩子中的较大者else{temp=r[i];r[i]=r[j];r[j]=temp; //将根结点与结点j交换i=j;j=2*i+1; //下一个被筛结点位于原来结点j的位置count2=count2+3; //移动次数加3 }}}//堆排序void HeapSort(int r[],int n){int count1=0,count2=0; //计数器，计比较和移动次数int i;int temp;for(i=n/2;i>=0;i--) //初始建堆，从最后一个非终端结点至根结点Sift(r,i,n,count1,count2) ;for(i=n-1; i>0; i--) //重复执行移走堆顶及重建堆的操作{temp=r[i]; //将堆顶元素与最后一个元素交换r[i]=r[0];r[0]=temp; //完成一趟排序，输出记录的次序状态Sift(r,0,i-1,count1,count2); //重建堆}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//一次归并void Merge(int r[], int r1[], int s, int m, int t){int i=s;int j=m+1;int k=s;while (i<=m && j<=t){if (r[i]<=r[j])r1[k++]=r[i++]; //取r[i]和r[j]中较小者放入r1[k]elser1[k++]=r[j++];}if (i<=m)while (i<=m) //若第一个子序列没处理完，则进行收尾处理r1[k++]=r[i++];elsewhile (j<=t) //若第二个子序列没处理完，则进行收尾处理r1[k++]=r[j++];}//一趟归并void MergePass(int r[ ], int r1[ ], int n, int h){int i=0;int k;while (i<=n-2*h) //待归并记录至少有两个长度为h的子序列{Merge(r, r1, i, i+h-1, i+2*h-1);i+=2*h;}if (i<n-h)Merge(r, r1, i, i+h-1, n); //待归并序列中有一个长度小于h else for (k=i; k<=n; k++) //待归并序列中只剩一个子序列r1[k]=r[k];}//归并排序void MergeSort(int r[ ], int r1[ ], int n ){int h=1;int i;while (h<n){MergePass(r, r1, n-1, h); //归并h=2*h;MergePass(r1, r, n-1, h);h=2*h;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;}void Newarray(int a[],int b[],int c[]) {cout<<"新随机数组：";c[0]=0;a[0]=0;b[0]=0;for(int s=1;s<11;s++){a[s]=s;b[s]=20-s;c[s]=rand()%50+1;cout<<c[s]<<" ";}cout<<endl;}2.3 其他3. 程序运行结果void main(){srand(time(NULL));const int num=11; //赋值int a[num];int b[num];int c[num];int c1[num];c[0]=0;a[0]=0;b[0]=0;Newarray(a,b,c);cout<<"顺序数组：";for(int j=1;j<num;j++)cout<<a[j]<<" ";cout<<endl;cout<<"逆序数组：";for(j=1;j<num;j++)cout<<b[j]<<" ";cout<<endl;cout<<endl;cout<<"插入排序结果为："<<"\n";InsertSort(a,num);InsertSort(b,num);InsertSort(c,num);cout<<endl;Newarray(a,b,c);cout<<"希尔排序结果为："<<"\n";ShellSort(a, num);ShellSort(b, num);ShellSort(c, num);cout<<endl;Newarray(a,b,c);cout<<"起泡排序结果为："<<"\n";BubbleSort(a, num);BubbleSort(b, num);BubbleSort(c, num);cout<<endl;int count1=0,count2=0;Newarray(a,b,c);cout<<"快速排序结果为："<<"\n";QuickSort(a,0,num-1,count1,count2);for(int i=1;i<num;i++)cout<<a[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(b,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<b[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(c,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<c[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;cout<<endl;cout<<endl;Newarray(a,b,c);cout << "简单选择排序结果为：" << "\n";SelectSort(a,num);SelectSort(b,num);SelectSort(c,num);cout<<endl;Newarray(a,b,c);cout << "堆排序结果为：" << "\n";HeapSort(a, num);HeapSort(b, num);HeapSort(c, num);cout<<endl;Newarray(a,b,c);cout << "归并排序结果为：" << "\n";MergeSort(a, c1,num );MergeSort(b, c1,num );MergeSort(c, c1,num );}。

数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。

二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。

三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。

三、实验步骤1. 数据的生成在实验开始前，首先生成一组随机数据作为排序的输入。

定义一个具有大数据量的数组，并随机生成一组在指定范围内的整数，用于后续排序算法的比较。

2. 冒泡排序冒泡排序是一种简单直观的排序算法。

其基本思想是从待排序的数据序列中逐个比较相邻元素的大小，并依次交换，从而将最大（或最小）的元素冒泡到序列的末尾。

重复该过程直到所有数据排序完成。

3. 快速排序快速排序是一种分治策略的排序算法，效率较高。

它将待排序的序列划分成两个子序列，其中一个子序列的所有元素都小于等于另一个子序列的所有元素。

然后对两个子序列分别递归地进行快速排序。

4. 归并排序归并排序是一种稳定的排序算法，使用分治策略将序列拆分成较小的子序列，然后递归地对子序列进行排序，最后再将子序列合并成有序的输出序列。

归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。

四、实验结果经过多次实验，我们得到了以下结果：1. 冒泡排序在数据量较小时，冒泡排序表现良好，但随着数据规模的增大，其性能明显下降。

排序时间随数据量的增长呈平方级别增加。

2. 快速排序相比冒泡排序，快速排序在大数据量下的表现更佳。

它的排序时间线性增长，且具有较低的内存占用。

3. 归并排序归并排序在各种数据规模下都有较好的表现。

它的排序时间与数据量呈对数级别增长，且对内存的使用相对较高。

五、实验分析根据实验结果，我们可以得出以下结论：1. 冒泡排序适用于数据较小的排序任务，但面对大数据量时表现较差，不推荐用于处理大规模数据。

2. 快速排序是一种高效的排序算法，适用于各种数据规模。

目录1.引言............................................................................................................................ 错误！未定义书签。

2.需求分析.................................................................................................................... 错误！未定义书签。

3.详细设计.................................................................................................................... 错误！未定义书签。

3.1 直接插入排序................................................................................................ 错误！未定义书签。

3.2折半排序......................................................................................................... 错误！未定义书签。

3.3 希尔排序........................................................................................................ 错误！未定义书签。

3.4简单选择排序................................................................................................. 错误！未定义书签。

《数据结构》实验报告排序实验题目：输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。

实验所使用的数据结构内容及编程思路：1.插入排序：直接插入排序的基本操作是，将一个记录到已排好序的有序表中，从而得到一个新的，记录增一得有序表。

一般情况下，第i趟直接插入排序的操作为：在含有i-1个记录的有序子序列r［1..i-1］中插入一个记录r［i］后，变成含有i个记录的有序子序列r［1..i］；并且，和顺序查找类似，为了在查找插入位置的过程中避免数组下标出界，在r［0］处设置哨兵。

在自i-1起往前搜索的过程中，可以同时后移记录。

整个排序过程为进行n-1趟插入，即：先将序列中的第一个记录看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减有序序列为止。

2.快速排序：基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

假设待排序的序列为{L.r[s]，L.r[s+1],…L.r[t]},首先任意选取一个记录(通常可选第一个记录L.r[s])作为枢轴（或支点）（pivot），然后按下述原则重新排列其余记录：将所有关键字较它小的记录都安置在它的位置之前，将所有关键字较大的记录都安置在它的位置之后。

由此可以该“枢轴”记录最后所罗的位置i作为界线，将序列{L.r[s]，…，L.r[t]}分割成两个子序列{L.r[i+1],L.[i+2],…,L.r[t]}。

这个过程称为一趟快速排序，或一次划分。

一趟快速排序的具体做法是：附设两个指针low和high，他们的初值分别为low和high，设枢轴记录的关键字为pivotkey，则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换，然后从low所指位置起向后搜索，找到第一个关键字大于pivotkey的记录和枢轴记录互相交换，重复这两不直至low=high为止。

北邮数据结构实验报告-排序北邮数据结构实验报告-排序一、实验目的本实验旨在掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序等，并通过实际编程实现对数字序列的排序。

二、实验内容1.冒泡排序冒泡排序是一种简单的排序算法，其基本思想是依次比较相邻的两个元素，并按照从小到大或从大到小的顺序交换。

具体步骤如下：- 从待排序序列的第一个元素开始，依次比较相邻的两个元素；- 如果前面的元素大于后面的元素，则交换这两个元素的位置；- 重复上述步骤，直到整个序列有序。

2.插入排序插入排序是一种简单且直观的排序算法，其基本思想是将待排序序列分为已排序和未排序两部分，每次从未排序部分中选择一个元素插入到已排序部分的合适位置。

具体步骤如下：- 从待排序序列中选择一个元素作为已排序部分的第一个元素；- 依次将未排序部分的元素插入到已排序部分的合适位置，使得已排序部分保持有序；- 重复上述步骤，直到整个序列有序。

3.选择排序选择排序是一种简单且直观的排序算法，其基本思想是每次选择未排序部分中的最小（或最大）元素，并将其放在已排序部分的末尾。

具体步骤如下：- 在未排序部分中选择最小（或最大）的元素；- 将选择的最小（或最大）元素与未排序部分的第一个元素交换位置；- 重复上述步骤，直到整个序列有序。

4.快速排序快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序序列分割成两部分，其中一部分的元素都比另一部分的元素小。

具体步骤如下：- 选择一个枢轴元素（一般选择第一个元素）；- 将待排序序列中小于枢轴元素的元素放在枢轴元素的左侧，大于枢轴元素的元素放在枢轴元素的右侧；- 对枢轴元素左右两侧的子序列分别进行递归快速排序；- 重复上述步骤，直到整个序列有序。

5.归并排序归并排序是一种高效的排序算法，其基本思想是将待排序序列划分成足够小的子序列，然后对这些子序列进行两两合并，最终形成有序的序列。

具体步骤如下：- 将待排序序列递归地划分成足够小的子序列；- 对每个子序列进行归并排序；- 合并相邻的子序列，直到整个序列有序。

数据结构拓扑排序实验报告数据结构拓扑排序实验报告一、引言本实验旨在通过实现拓扑排序算法，对给定的有向图进行排序操作。

拓扑排序是一种对有向图进行排序的算法，根据有向边的方向，将图中的节点排列成线性序列，并满足任意一条边的起点在序列中位于终点之前的要求。

二、实验目的1.理解拓扑排序的概念及原理；2.掌握拓扑排序的具体实现方法；3.实现拓扑排序算法，并对给定的有向图进行排序实验。

三、理论知识1.有向图：由一组顶点和一组有向边组成的图结构，每条有向边连接两个顶点，有方向性。

2.有向边：连接有向图中两个顶点的边，表明了两个顶点之间的关系，有起点和终点之分。

3.入度：指向某一顶点的有向边的数量。

4.拓扑排序：一种对有向图进行排序的算法，要求在排序结果中，任意一条边的起点在序列中位于终点之前。

四、实验步骤1.创建图的数据结构，包括顶点和有向边的表示；2.读入有向图的顶点和边的信息，并构建图的结构；3.计算每个顶点的入度，并初始化拓扑排序结果序列；4.选择一个入度为0的顶点，将其加入拓扑排序结果序列，并将其所连接的顶点的入度减1；5.重复步骤4，直到所有顶点被加入拓扑排序结果序列；6.输出最终的拓扑排序结果。

五、实验结果- 给定的有向图：- 图片附件1：有向图示意图- 通过拓扑排序算法得到的排序结果：- 顶点A →顶点B →顶点C →顶点D →顶点E六、实验分析与总结在本次实验中，我们成功实现了拓扑排序算法，并对给定的有向图进行了排序。

通过实验结果可以看出，拓扑排序可以将有向图中的节点按照依赖关系进行排序。

通过拓扑排序，我们可以找到一个满足依赖关系的节点序列，用于解决诸如任务调度、依赖关系分析等问题。

七、附件- 图片附件1：有向图示意图八、法律名词及注释1.有向图：在图论中，有向图是由一组顶点和一组有向边组成的图结构，每条边连接两个顶点，并有方向性。

2.拓扑排序：一种对有向图进行排序的算法，要求在排序结果中，任意一条边的起点在序列中位于终点之前。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验排序姓名：陆孟飞学号：12196129 需求分析：本演示程序用C++6.0编写，完成排序的实现，对输入的一组数字实现不同的排序方法，对其由小到大顺序输出。

（1）分别对直接插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序算法进行编写。

（2）、对存储的函数即输入的数字进行遍历。

（3）、初始化函数对输入的数字进行保存。

（4）、主函数实现使用者操作界面的编写，对输入、选择、保存、输出的各种实现。

这当中还包括了各个函数的调用的实现。

（5）、程序所能达到的功能：完成对输入的数字的生成，并通过对各排序的选择实现数字从小到大的输出。

（8）、初始化函数InitSqList（）。

（9）、主函数main（）。

详细设计实现各个算法的主要内容，下面是各个函数的主要信息：（1）各个排序函数的算法：希尔排序void ShellSort(SqList &L){int i, j;int dk = 1;//增量while(dk <=L.length/3)dk = 3*dk+1;//增大增量while(dk>0){dk /= 3;//减小增量for (i = dk; i <=L.length; i++){L.r[0].key = L.r[i].key;j = i;while ((j >= dk) && (L.r[j-dk].key > L.r[0].key)){L.r[j].key = L.r[j-dk].key;j -= dk;}L.r[j].key = L.r[0].key;}}}测试结果。

引言概述：数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。

通过实验，可以深入理解和掌握不同排序算法的原理、特点和性能表现。

本文将针对数据结构排序实验进行详细的阐述和总结，包括实验目的、实验内容、实验结果分析和总结。

一、实验目的1. 加深对数据结构排序算法的理解：通过实验，掌握不同排序算法的工作原理和实现方式。

2. 分析和比较不同排序算法的性能：对比不同排序算法在不同数据规模下的时间复杂度和空间复杂度，理解它们的优劣势。

3. 提高编程和算法设计能力：通过实验的编写，提升对排序算法的实现能力和代码质量。

二、实验内容1. 选择排序算法：选择排序是一种简单直观的排序算法，将序列分为有序和无序两部分，每次从无序部分选择最小（最大）元素，放到有序部分的末尾（开头）。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析2. 插入排序算法：插入排序逐步构建有序序列，对于未排序的元素，在已排序序列中从后向前扫描，找到对应位置插入。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析3. 快速排序算法：快速排序利用分治的思想，将序列分为左右两部分，选取基准元素，将小于基准的放在左边，大于基准的放在右边，递归地对左右部分进行排序。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析4. 归并排序算法：归并排序是一种稳定的排序算法，通过将序列分为若干子序列，分别进行排序，然后再将排好序的子序列合并成整体有序序列。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析5. 堆排序算法：堆是一种特殊的树状数据结构，堆排序利用堆的性质进行排序，通过构建大顶堆或小顶堆，并逐个将堆顶元素移出形成有序序列。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析三、实验结果分析1. 比较不同排序算法的执行时间：根据实验数据和分析，对比不同排序算法在不同数据规模下的执行时间，并针对其时间复杂度进行验证和分析。

《数据结构》课程设计报告专业班级姓名学号指导教师起止时间课程设计：排序综合一、任务描述利用随机函数产生n个随机整数（20000以上），对这些数进行多种方法进行排序。

（1）至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。

并把排序后的结果保存在不同的文件中。

（2）统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。

要求：根据以上任务说明，设计程序完成功能。

二、问题分析1、功能分析分析设计课题的要求，要求编程实现以下功能：（1）随机生成N个整数，存放到线性表中；（2）起泡排序并计算所需时间；（3）简单选择排序并计算时间；（4）希尔排序并计算时间；（5）直接插入排序并计算所需时间；（6）时间效率比较。

2、数据对象分析存储数据的线性表应为顺序存储。

三、数据结构设计使用顺序表实现，有关定义如下：typedef int Status;typedef int KeyType ; //设排序码为整型量typedef int InfoType;typedef struct { //定义被排序记录结构类型KeyType key ; //排序码I nfoType otherinfo; //其它数据项} RedType ;typedef struct {RedType * r; //存储带排序记录的顺序表//r[0]作哨兵或缓冲区int length ; //顺序表的长度} SqList ; //定义顺序表类型四、功能设计（一）主控菜单设计为实现通各种排序的功能，首先设计一个含有多个菜单项的主控菜单程序，然后再为这些菜单项配上相应的功能。

程序运行后，给出5个菜单项的内容和输入提示，如下：1.起泡排序2.简单选择排序3.希尔排序4. 直接插入排序0. 退出系统（二）程序模块结构由课题要求可将程序划分为以下几个模块（即实现程序功能所需的函数）：●主控菜单项选择函数menu()●创建排序表函数InitList_Sq()●起泡排序函数Bubble_sort()●简单选择排序函数SelectSort()●希尔排序函数ShellSort();●对顺序表L进行直接插入排序函数Insertsort()（三）函数调用关系程序的主要结构（函数调用关系）如下图所示。

数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序，并通过实际编程和实验分析，比较它们在不同规模数据下的性能表现，从而为实际应用中选择合适的排序算法提供依据。

二、实验环境本次实验使用的编程语言为 Python 3x，开发环境为 PyCharm。

实验中使用的操作系统为 Windows 10。

三、实验原理1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。

它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。

2、插入排序（Insertion Sort）插入排序是一种简单直观的排序算法。

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个数组有序。

3、选择排序（Selection Sort）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

以此类推，直到所有元素均排序完毕。

4、快速排序（Quick Sort）通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

5、归并排序（Merge Sort）归并排序是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

四、实验步骤1、算法实现使用 Python 语言分别实现上述五种排序算法。

为每个算法编写独立的函数，函数输入为待排序的列表，输出为排序后的列表。

2、生成测试数据生成不同规模（例如 100、500、1000、5000、10000 个元素）的随机整数列表作为测试数据。