数据结构实验八内部排序
数据结构实验报告八-快速排序

实验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、轴值寻找算法://为了保证轴值的“随机性”,采用时间初始化种子。
内部排序实验报告

数据结构实验报告内部排序班级:13 软工一班学号:13131113 姓名:吕蒙学号:13131116 姓名:钱剑滨学号:13131142 姓名:孔亚亚学号:13131144 姓名:邱佃雨13软工转本1 钱剑滨实验报告内部排序实验报告信息工程系 13软工转本1 日期 2016年06月07日一、实验内容编写程序实现各种内部排序(包括:冒泡排序、插入排序、选择排序、希尔排序、快速排序、堆排序、归并排序、基数排序),并运用这些排序对一组随机生成的数组进行排序。
二、时间复杂度1.冒泡排序(O(n^2))若文件的初始状态是正序的,一趟扫描即可完成排序。
所需的关键字比较次数和记录移动次数均达到最小值:,。
所以,冒泡排序最好的时间复杂度为。
若初始文件是反序的,需要进行趟排序。
每趟排序要进行次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置。
在这种情况下,比较和移动次数均达到最大值:冒泡排序的最坏时间复杂度为。
综上,因此冒泡排序总的平均时间复杂度为。
2.插入排序(O(n^2))如果目标是把n个元素的序列升序排列,那么采用插入排序存在最好情况和最坏情况。
最好情况就是,序列已经是升序排列了,在这种情况下,需要进行的比较操作需(n-1)次即可。
最坏情况就是,序列是降序排列,那么此时需要进行的比较共有n(n-1)/2次。
插入排序的赋值操作是比较操作的次数加上(n-1)次。
平均来说插入排序算法的时间复杂度为O(n^2)。
因而,插入排序不适合对于数据量比较大的排序应用。
但是,如果需要排序的数据量很小,例如,量级小于千,那么插入排序还是一个不错的选择。
3.选择排序(O(n^2))选择排序的交换操作介于0 和(n - 1)次之间。
选择排序的比较操作为n (n - 1)/ 2 次之间。
选择排序的赋值操作介于0 和3 (n - 1)次之间。
比较次数O(n^2),比较次数与关键字的初始状态无关,总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2。
内部排序实验报告总结

内部排序实验报告总结内部排序实验报告总结一、引言内部排序是指对一个存储在计算机内存中的数据集合进行排序的过程。
在本次实验中,我们对常见的内部排序算法进行了实验比较,包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。
通过比较这些算法的执行时间和空间复杂度,我们可以评估它们在不同数据集上的性能。
二、实验目的1. 比较不同内部排序算法在不同数据集上的性能差异;2. 了解各种内部排序算法的实现原理;3. 掌握如何分析和评估算法的时间复杂度和空间复杂度。
三、实验方法1. 实验环境:使用具有相同硬件配置和操作系统版本的计算机进行测试。
2. 实验数据:选择多个不同大小和特征的数据集进行测试,包括随机数列、有序数列和逆序数列。
3. 实验步骤:3.1 实现各个内部排序算法;3.2 对每个数据集分别运行各个算法,并记录执行时间;3.3 分析结果并比较各个算法之间的性能差异。
四、实验结果与分析1. 冒泡排序:冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,并按照大小交换它们的位置。
经过多次遍历,最大(或最小)的元素会逐渐移动到数列的末尾。
冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1)。
在本次实验中,冒泡排序在随机数列上表现良好,但在有序数列和逆序数列上性能较差。
这是因为冒泡排序需要进行多次交换操作,而有序数列和逆序数列中元素已经接近或完全有序,交换操作并不频繁。
2. 选择排序:选择排序是一种简单直观的排序算法,它每次从待排序的数据中选择最小(或最大)的元素,并将其放到已排好序的部分末尾。
选择排序的时间复杂度为O(n^2),空间复杂度为O(1)。
实验结果显示,选择排序在各种数据集上都表现稳定。
这是因为选择排序每次只需进行一次交换操作,相对于冒泡排序来说更加高效。
3. 插入排序:插入排序是一种简单直观且稳定的内部排序算法,它将待排序的数据分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的适当位置。
数据结构第八章_排序

49 38 65 97 76
三趟排序:4 13 27 38 48 49 55 65 76 97
算法描述
#define T 3 int d[]={5,3,1};
例 13 48 97 55 76 4 13 49 27 38 65 49 27 38 65 48 97 55 76 4 j j j
j
j
i
例 初始: 49 38 65 97 76 13 27 48 55 4 取d1=5 49 38 65 97 76 13 27 48 55 4 一趟分组:
一趟排序:13 27 48 55 4 取d2=3 13 27 48 55 4 二趟分组:
49 38 65 97 76 49 38 65 97 76
二趟排序:13 4 48 38 27 49 55 65 97 76 取d3=1 13 27 48 55 4 三趟分组:
初始时令i=s,j=t
首先从j所指位置向前搜索第一个关键字小于x的记录,并和rp
交换 再从i所指位置起向后搜索,找到第一个关键字大于x的记录, 和rp交换 重复上述两步,直至i==j为止 再分别对两个子序列进行快速排序,直到每个子序列只含有 一个记录为止
快速排序演示
算法描述
算法评价
例
38 49 49 38 65 76 97 13 97 76 97 27 13 30 97 27 97 30 初 始 关 键 字
38 49 65 13 76 27 76 13 30 76 27 76 30 97 第 一 趟
38 49 13 65 27 65 13 30 65 27 65 30
38 13 49
时间复杂度
最好情况(每次总是选到中间值作枢轴)T(n)=O(nlog2n) 最坏情况(每次总是选到最小或最大元素作枢轴)
数据结构课程设计—内部排序算法比较

数据结构课程设计—内部排序算法比较在计算机科学领域中,数据的排序是一项非常基础且重要的操作。
内部排序算法作为其中的关键部分,对于提高程序的运行效率和数据处理能力起着至关重要的作用。
本次课程设计将对几种常见的内部排序算法进行比较和分析,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
冒泡排序是一种简单直观的排序算法。
它通过重复地走访要排序的数列,一次比较两个数据元素,如果顺序不对则进行交换,并一直重复这样的走访操作,直到没有要交换的数据元素为止。
这种算法的优点是易于理解和实现,但其效率较低,在处理大规模数据时性能不佳。
因为它在最坏情况下的时间复杂度为 O(n²),平均时间复杂度也为O(n²)。
插入排序的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入,直到整个序列有序。
插入排序在数据量较小时表现较好,其平均时间复杂度和最坏情况时间复杂度也都是 O(n²),但在某些情况下,它的性能可能会优于冒泡排序。
选择排序则是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(或最大)元素,然后放到已排序序列的末尾。
以此类推,直到全部待排序的数据元素排完。
选择排序的时间复杂度同样为O(n²),但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。
快速排序是一种分治的排序算法。
它首先选择一个基准元素,将数列分成两部分,一部分的元素都比基准小,另一部分的元素都比基准大,然后对这两部分分别进行快速排序。
快速排序在平均情况下的时间复杂度为 O(nlogn),最坏情况下的时间复杂度为 O(n²)。
然而,在实际应用中,快速排序通常表现出色,是一种非常高效的排序算法。
归并排序也是一种分治算法,它将待排序序列分成若干个子序列,每个子序列有序,然后将子序列合并成一个有序序列。
内部排序实验报告

KeyType pivotkey; L.r[0]=L.r[low]; pivotkey=L.r[low].key;
//用子表的第一个记录作枢轴记录 //枢轴记录关键字
while(low< high) {
//从表的两端交替地向中间扫描
h.r[i+1]=d[i]; h.length=N; printf("\n 堆排序前:\n"); print_H(h); HeapSort(h); printf("堆排序后:\n"); print_H(h); goto s123;
case 4: for(i=0;i<N;i++) LL.r[i+1]=d[i]; LL.length=N; printf("归并排序前:\n"); print(LL); MergeSort(LL); printf("归并排序后:\n"); print(LL); goto s123;
RedType d[N]={{20,6},{52,1},{65,3},{88,9},{47,8},{22,4},{39,5},{74,7}}; int i; SqList LL; int dt[T]={5,3,1}; // 增量序列数组 int choice;
s123: cout<<"请选择要使用的排序算法:\n0..............退出\n"; cout<<"1..............插入排序\n2..............交换排序\n"; cout<<"3..............选择排序\n4..............归并排序\n"; cin>>choice; switch(choice) { case 0: break;
内部排序实验报告
内部排序实验报告内部排序实验报告一、引言内部排序是计算机科学中的重要概念,它指的是对一个数据集合进行排序的过程。
在计算机科学中,排序算法是一种基本的算法,它对于提高数据处理效率和优化算法性能有着重要的作用。
本实验旨在通过实际操作和对比分析,探究不同内部排序算法的性能差异。
二、实验目的1. 了解内部排序的基本概念和常用算法;2. 掌握不同内部排序算法的实现方法;3. 比较不同内部排序算法的时间复杂度和空间复杂度;4. 分析实验结果,总结不同算法的优缺点。
三、实验过程1. 实验环境搭建在进行实验之前,我们需要搭建适当的实验环境。
选择一种编程语言,并准备好相应的开发环境。
2. 实验数据准备为了进行排序算法的测试,我们需要准备一组测试数据。
可以选择不同规模的数据集,包括有序、无序和部分有序等情况。
3. 实验算法实现选择几种常用的内部排序算法,如冒泡排序、插入排序、选择排序、快速排序和归并排序等。
分别实现这些算法,并确保其正确性。
4. 实验性能测试使用不同规模的测试数据对算法进行性能测试。
记录每个算法的运行时间和所占用的内存空间。
5. 实验结果分析根据实验数据和测试结果,对比分析不同算法的性能差异。
针对时间复杂度和空间复杂度,给出相应的分析和解释。
四、实验结果与分析经过实验测试,我们得到了不同内部排序算法的运行时间和内存占用情况。
下面对实验结果进行分析和解释。
1. 时间复杂度分析通过实验数据,我们可以观察到不同算法的运行时间随着数据规模的增加而增加。
快速排序和归并排序在大规模数据集上表现出色,时间复杂度为O(nlogn)。
而冒泡排序和选择排序的时间复杂度为O(n^2),在大规模数据集上性能较差。
2. 空间复杂度分析在内部排序中,空间复杂度是指算法执行过程中所需的额外内存空间。
插入排序和冒泡排序是原地排序算法,它们的空间复杂度为O(1)。
而归并排序和快速排序需要额外的空间来存储中间结果,空间复杂度为O(n)。
数据结构实验八快速排序实验报告
数据结构实验八快速排序实验报告一、实验目的1.掌握快速排序算法的原理。
2. 掌握在不同情况下快速排序的时间复杂度。
二、实验原理快速排序是一种基于交换的排序方式。
它是由图灵奖得主 Tony Hoare 发明的。
快速排序的原理是:对一个未排序的数组,先找一个轴点,将比轴点小的数放到它的左边,比轴点大的数放到它的右边,再对左右两部分递归地进行快速排序,完成整个数组的排序。
优缺点:快速排序是一种分治思想的算法,因此,在分治思想比较适合的场景中,它具有较高的效率。
它是一个“不稳定”的排序算法,它的工作原理是在大数组中选取一个基准值,然后将数组分成两部分。
具体过程如下:首先,选择一个基准值(pivot),一般是选取数组的中间位置。
然后把数组的所有值,按照大小关系,分成两部分,小于基准值的放左边,大于等于基准值的放右边。
继续对左右两个数组递归进行上述步骤,直到数组只剩一个元素为止。
三、实验步骤1.编写快速排序代码:void quicksort(int *a,int left,int right) {int i,j,t,temp;if(left>right)return;temp=a[left];i=left;j=right;while(i!=j) {// 顺序要先从右往左移while(a[j]>=temp&&i<j)j--;while(a[i]<=temp&&i<j)i++;if(i<j) {t=a[i];a[i]=a[j];a[j]=t;}}a[left]=a[i];a[i]=temp;quicksort(a,left,i-1);quicksort(a,i+1,right);}2.使用 rand() 函数产生整型随机数并量化生成的随机数序列,运用快速排序算法对序列进行排序。
四、实验结果实验结果显示,快速排序能够有效地快速地排序整型序列。
在随机产生的数值序列中,快速排序迅速地将数值排序,明显快于冒泡排序等其他排序算法。
数据结构(C语言版)实验报告 (内部排序算法比较)
《数据结构与算法》实验报告一、需求分析问题描述:在教科书中,各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。
试通过随机数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受。
基本要求:(l)对以下6种常用的内部排序算法进行比较:起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。
(2)待排序表的表长不小于100000;其中的数据要用伪随机数程序产生;至少要用5组不同的输入数据作比较;比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为3次移动)。
(3)最后要对结果作简单分析,包括对各组数据得出结果波动大小的解释。
数据测试:二.概要设计1.程序所需的抽象数据类型的定义:typedef int BOOL; //说明BOOL是int的别名typedef struct StudentData { int num; //存放关键字}Data; typedef struct LinkList { int Length; //数组长度Data Record[MAXSIZE]; //用数组存放所有的随机数} LinkList int RandArray[MAXSIZE]; //定义长度为MAXSIZE的随机数组void RandomNum() //随机生成函数void InitLinkList(LinkList* L) //初始化链表BOOL LT(int i, int j,int* CmpNum) //比较i和j 的大小void Display(LinkList* L) //显示输出函数void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum) //希尔排序void QuickSort (LinkList* L, int* CmpNum, int* ChgNum) //快速排序void HeapSort (LinkList* L, int* CmpNum, int* ChgNum) //堆排序void BubbleSort(LinkList* L, int* CmpNum, int* ChgNum) //冒泡排序void SelSort(LinkList* L, int* CmpNum, int* ChgNum) //选择排序void Compare(LinkList* L,int* CmpNum, int* ChgNum) //比较所有排序2 .各程序模块之间的层次(调用)关系:二、详细设计typedef int BOOL; //定义标识符关键字BOOL别名为int typedef struct StudentData //记录数据类型{int num; //定义关键字类型}Data; //排序的记录数据类型定义typedef struct LinkList //记录线性表{int Length; //定义表长Data Record[MAXSIZE]; //表长记录最大值}LinkList; //排序的记录线性表类型定义int RandArray[MAXSIZE]; //定义随机数组类型及最大值/******************随机生成函数********************/void RandomNum(){int i; srand((int)time(NULL)); //用伪随机数程序产生伪随机数for(i=0; i小于MAXSIZE; i++) RandArray[i]<=(int)rand(); 返回;}/*****************初始化链表**********************/void InitLinkList(LinkList* L) //初始化链表{int i;memset(L,0,sizeof(LinkList));RandomNum();for(i=0; i小于<MAXSIZE; i++)L->Record[i].num<=RandArray[i]; L->Length<=i;}BOOL LT(int i, int j,int* CmpNum){(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;}void Display(LinkList* L){FILE* f; //定义一个文件指针f int i;若打开文件的指令不为空则//通过文件指针f打开文件为条件判断{ //是否应该打开文件输出“can't open file”;exit(0); }for (i=0; i小于L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);通过文件指针f关闭文件;三、调试分析1.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中,我曾多次修改代码,并根据调试显示的界面一次次调整代码。
数据结构内排序实验报告
一、实验目的1、了解内排序都是在内存中进行的。
2、为了提高数据的查找速度,需要对数据进行排序。
3、掌握内排序的方法。
二、实验内容1、设计一个程序e xp10—1.cpp实现直接插入排序算法,并输出{9,8,7,6,5,4,3,2,1,0}的排序过程。
(1)源程序如下所示://文件名:exp10-1.cpp#include <stdio.h>#define MAXE 20//线性表中最多元素个数typedef int KeyType;typedef char InfoType[10];typedef struct //记录类型{KeyType key; //关键字项InfoType data; //其他数据项,类型为InfoType} RecType;void InsertSort(RecType R[],int n) //对R[0..n-1]按递增有序进行直接插入排序{int i,j,k;RecType temp;for (i=1;i<n;i++){temp=R[i];j=i-1; //从右向左在有序区R[0..i-1]中找R[i]的插入位置while (j>=0 && temp.key<R[j].key){R[j+1]=R[j];//将关键字大于R[i].key的记录后移j--;}R[j+1]=temp;//在j+1处插入R[i]printf("i=%d,",i);//输出每一趟的排序结果printf("插入%d,结果为: ",temp);for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");}}void main(){int i,k,n=10;KeyType a[]={9,8,7,6,5,4,3,2,1,0};RecType R[MAXE];for (i=0;i<n;i++)R[i].key=a[i];printf("初始关键字: ");//输出初始关键字序列for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");InsertSort(R,n);printf("最后结果: ");//输出初始关键字序列for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");}(2)运行的结果如下图所示:2、设计一个程序exp10—2.cpp实现希尔插入排序算法,并输出{9,8,7,6,5,4,3,2,1,0}的排序过程。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验八内部排序
一、实验目的
1、掌握内部排序的基本算法;
2、分析比较内部排序算法的效率。
二、实验内容和要求
1. 运行下面程序:
#include <stdlib.h>
#include <stdio.h>
#define MAX 50
int slist[MAX]; /*待排序序列*/
void insertSort(int list[], int n);
void createList(int list[], int *n);
void printList(int list[], int n);
void heapAdjust(int list[], int u, int v);
void heapSort(int list[], int n);
/*直接插入排序*/
void insertSort(int list[], int n)
{
int i = 0, j = 0, node = 0, count = 1;
printf("对序列进行直接插入排序:\n");
printf("初始序列为:\n");
printList(list, n);
for(i = 1; i < n; i++)
{
node = list[i];
j = i - 1;
while(j >= 0 && node < list[j])
{
list[j+1] = list[j];
--j;
}
list[j+1] = node;
printf("第%d次排序结果:\n", count++);
printList(list, n);
}
}
/*堆排序*/
void heapAdjust(int list[], int u, int v)
{
int i = u, j = 0, temp = list[i];
if(u == 0) /*判断数组下标,确定list[u]的左孩子的下标*/ {
j = 1;
}
else
{
j = 2 * i;
}
while (j <= v)
{
if(j < v && list[j] < list[j+1])
{
j++; /*若右孩子较大,则把j修改为右孩子的下标*/ }
if(temp < list[j])
{
list[i] = list[j]; /*将list[j]调到父亲的位置上*/
i = j;
j = 2 * i; /*修改i和j的值,以便继续向下筛选*/ }
else
break; /*筛选完成,终止循环*/
}
list[i] = temp; /*被筛结点的值放入最终位置*/
}
void heapSort(int list[], int n)
{
int i = 0, temp = 0, count = 1;
printf("对序列进行堆排序:\n");
printf("初始序列为:\n");
printList(list, n);
for (i = (n - 1) / 2; i >= 0; i--)
{
heapAdjust(list, i, n-1); /*建立初始堆*/
}
printf("建立的初始堆为:\n");
printList(list, n);
for(i = n - 1; i >= 1; i--)
{
/*循环,完成堆排序*/
temp = list[0];
list[0] = list[i];
list[i] = temp; /*将第一个元素同当前区间内最后一个元素对换*/
heapAdjust(list, 0 , i-1); /*筛选出list[1]结点*/
printf("第%d次排序结果:\n", count++);
printList(list, n);
}
}
/*生成待排序序列*/
void createList(int list[], int *n)
{
int i = 0,a;
printf("请输入待排序序列(长度小于50,以输入一个字符结束):\n"); while(scanf("%d",&a)==1)
{
list[i] = a;
i++;
}
*n=i;
getchar();
}
/*输出排序结果*/
void printList(int list[], int n)
{
int i = 0;
for(; i < n; i++)
{
printf(" %d ", list[i]);
if(i % 10 ==0 && i != 0)
{
printf("\n");
}
}
printf("\n");
}
int main()
{
int choice=1,length;
while(choice!=0)
{
printf("\n");
printf("***** 内部排序算法演示程序 *****\n");
printf("\n1. 直接插入排序 \n");
printf("\n2. 堆排序 \n");
printf("\n0. 退出\n");
printf("\n请选择:");
scanf("%d", &choice);
getchar();
switch(choice)
{
case 1:
{
createList(slist, &length);
insertSort(slist, length);
break;
}
case 2:
{
createList(slist, &length);
selectSort(slist, length);
break;
}
default:choice=0;
}
printf("\n");
}
return 0;
}
输入待排序序列:49 38 65 97 13 27 49(以输入一个字符作为结束)(1)直接插入排序运行结果:
(2)堆排序运行结果:
2、在1题中补充希尔排序算法。
算法代码:
运行结果:
3、在1题中补充快速排序算法。
算法代码;
运行结果:
三、实验小结
请比较各个排序算法的性能。
四、教师评语。