几种排序算法的平均性能比较(实验报告)
各种排序对比实验报告
一、实验目的通过对不同排序算法的实验对比,分析各种排序算法的效率、稳定性和适用场景,为实际应用中选择合适的排序算法提供参考。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 测试数据:随机生成长度为10000的整数数组三、实验方法1. 实验数据:随机生成长度为10000的整数数组,作为排序算法的输入数据。
2. 实验算法:选择以下排序算法进行对比实验:- 冒泡排序(Bubble Sort)- 选择排序(Selection Sort)- 插入排序(Insertion Sort)- 快速排序(Quick Sort)- 归并排序(Merge Sort)- 堆排序(Heap Sort)3. 实验步骤:(1)对每种排序算法进行编写和实现;(2)将测试数据分别输入到每种排序算法中,记录排序过程的时间;(3)比较不同排序算法的排序时间,分析其效率;(4)观察排序过程中数据的变化,分析其稳定性;(5)总结各种排序算法的适用场景。
四、实验结果与分析1. 冒泡排序(Bubble Sort)- 效率:时间复杂度为O(n^2),空间复杂度为O(1);- 稳定性:稳定排序算法;- 适用场景:数据量较小、基本有序的数据。
2. 选择排序(Selection Sort)- 效率:时间复杂度为O(n^2),空间复杂度为O(1);- 稳定性:不稳定排序算法;- 适用场景:数据量较小、基本有序的数据。
3. 插入排序(Insertion Sort)- 效率:时间复杂度为O(n^2),空间复杂度为O(1);- 稳定性:稳定排序算法;- 适用场景:数据量较小、基本有序的数据。
4. 快速排序(Quick Sort)- 效率:平均时间复杂度为O(nlogn),最坏情况时间复杂度为O(n^2),空间复杂度为O(logn);- 稳定性:不稳定排序算法;- 适用场景:数据量较大、基本有序或无序的数据。
5. 归并排序(Merge Sort)- 效率:时间复杂度为O(nlogn),空间复杂度为O(n);- 稳定性:稳定排序算法;- 适用场景:数据量较大、基本有序或无序的数据。
算法实验报告结果分析
一、实验背景随着计算机科学技术的不断发展,算法作为计算机科学的核心内容之一,其重要性日益凸显。
为了验证和评估不同算法的性能,我们进行了一系列算法实验,通过对比分析实验结果,以期为后续算法研究和优化提供参考。
二、实验方法本次实验选取了三种常见的算法:快速排序、归并排序和插入排序,分别对随机生成的数据集进行排序操作。
实验数据集的大小分为10000、20000、30000、40000和50000五个级别,以验证算法在不同数据量下的性能表现。
实验过程中,我们使用Python编程语言实现三种算法,并记录每种算法的运行时间。
同时,为了确保实验结果的准确性,我们对每种算法进行了多次运行,并取平均值作为最终结果。
三、实验结果1. 快速排序快速排序是一种高效的排序算法,其平均时间复杂度为O(nlogn)。
从实验结果来看,快速排序在所有数据量级别下均表现出较好的性能。
在数据量较小的10000和20000级别,快速排序的运行时间分别为0.05秒和0.1秒;而在数据量较大的40000和50000级别,运行时间分别为0.8秒和1.2秒。
总体来看,快速排序在各个数据量级别下的运行时间均保持在较低水平。
2. 归并排序归并排序是一种稳定的排序算法,其时间复杂度也为O(nlogn)。
实验结果显示,归并排序在数据量较小的10000和20000级别下的运行时间分别为0.15秒和0.25秒,而在数据量较大的40000和50000级别,运行时间分别为1.5秒和2.5秒。
与快速排序相比,归并排序在数据量较小的情况下性能稍逊一筹,但在数据量较大时,其运行时间仍然保持在较低水平。
3. 插入排序插入排序是一种简单易实现的排序算法,但其时间复杂度为O(n^2)。
实验结果显示,插入排序在数据量较小的10000和20000级别下的运行时间分别为0.3秒和0.6秒,而在数据量较大的40000和50000级别,运行时间分别为8秒和15秒。
可以看出,随着数据量的增加,插入排序的性能明显下降。
5种排序算法性能比较总结
5种排序算法性能比较总结1、概述本文对比较常用且比较高效的排序算法进行了总结和解析,并贴出了比较精简的实现代码,包括选择排序、插入排序、归并排序、希尔排序、快速排序等。
算法性能比较如下图所示:2、选择排序选择排序的第一趟处理是从数据序列所有n个数据中选择一个最小的数据作为有序序列中的第1个元素并将它定位在第一号存储位置,第二趟处理从数据序列的n-1个数据中选择一个第二小的元素作为有序序列中的第2个元素并将它定位在第二号存储位置,依此类推,当第n-1趟处理从数据序列的剩下的2个元素中选择一个较小的元素作为有序序列中的最后第2个元素并将它定位在倒数第二号存储位置,至此,整个的排序处理过程就已完成。
代码如下:3、插入排序直接插入排序法的排序原则是:将一组无序的数字排列成一排,左端第一个数字为已经完成排序的数字,其他数字为未排序的数字。
然后从左到右依次将未排序的数字插入到已排序的数字中。
代码如下:4、归并排序算法描述:把序列分成元素尽可能相等的两半。
把两半元素分别进行排序。
把两个有序表合并成一个。
代码如下:5、希尔排序希尔排序又称“缩小增量排序”,该方法的基本思想是:先将整个待排元素序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序。
因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的,因此希尔排序在时间效率上比前两种方法有较大提高。
代码如下:6、快速排序快速排序(Quicksort)是对冒泡排序的一种改进。
由C. A. R. Hoare在1962年提出。
它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
算法实验报告
算法实验报告算法实验报告引言:算法是计算机科学的核心内容之一,它是解决问题的方法和步骤的描述。
算法的设计和分析是计算机科学与工程中的重要研究方向之一。
本实验旨在通过对算法的实际应用和实验验证,深入理解算法的性能和效果。
实验一:排序算法的比较在本实验中,我们将比较三种常见的排序算法:冒泡排序、插入排序和快速排序。
我们将通过对不同规模的随机数组进行排序,并记录每种算法所需的时间和比较次数,以评估它们的性能。
实验结果显示,快速排序是最快的排序算法,其时间复杂度为O(nlogn),比较次数也相对较少。
插入排序的时间复杂度为O(n^2),比较次数较多,但对于小规模的数组排序效果较好。
而冒泡排序的时间复杂度也为O(n^2),但比较次数更多,效率相对较低。
实验二:图的最短路径算法在图的最短路径问题中,我们将比较Dijkstra算法和Floyd-Warshall算法的效率和准确性。
我们将使用一个带权有向图,并计算从一个顶点到其他所有顶点的最短路径。
实验结果表明,Dijkstra算法适用于单源最短路径问题,其时间复杂度为O(V^2),其中V为顶点数。
而Floyd-Warshall算法适用于多源最短路径问题,其时间复杂度为O(V^3)。
两种算法在准确性上没有明显差异,但在处理大规模图时,Floyd-Warshall算法的效率较低。
实验三:动态规划算法动态规划是一种通过将问题分解成子问题并记录子问题的解来解决复杂问题的方法。
在本实验中,我们将比较两种动态规划算法:0-1背包问题和最长公共子序列问题。
实验结果显示,0-1背包问题的动态规划算法可以有效地找到最优解,其时间复杂度为O(nW),其中n为物品个数,W为背包容量。
最长公共子序列问题的动态规划算法可以找到两个序列的最长公共子序列,其时间复杂度为O(mn),其中m和n分别为两个序列的长度。
结论:通过本次实验,我们对不同算法的性能和效果有了更深入的了解。
排序算法中,快速排序是最快且效率最高的;在图的最短路径问题中,Dijkstra算法和Floyd-Warshall算法分别适用于不同的场景;动态规划算法可以解决复杂的问题,并找到最优解。
三种排序及其比较报告
三种排序及其比较实验报告(1)、实验题目通过快速排序,折半排序,希尔排序三种方法进行排序数据,并统计每一种排序在过程中对整数的比较次数和移动次数,并输出结果。
(2)实验项目组成该程序由主函数main()和子函数quicksort(),shellsort(),binSort()组成。
(3)实验项目的程序结构:(4)函数的功能描述quicksort(int a[],int l,int r,int *u1,int *v1) 快速排序算法shellsort(int a[],int n) shell排序算法binSort(int a[],int n) 2分插入排序算法(5)实验数据与实验结果测试数据:在main()函数里面可以事先给定要排序的整数,这里给的是11,3,28,52,46,32,66,88 等 8个非顺序数据.实验结果见下图:(6)算法描述:#include "stdio.h"#include "conio.h"quicksort(int a[],int l,int r,int *u1,int *v1) /*快速排序*/ {int i,j,temp,k=0,u,v;i=l; j=r;temp=a[i];if(l>=r) return;while(i!=j){while(a[j]>=temp&&i<j) j--;*u1=*u1+1;if(i<j) { a[i]=a[j]; *v1=*v1+1; i++;}while(a[i]<temp&&i<j) i++;*u1=*u1+1;if(i<j) {a[j]=a[i];*v1=*v1+1;j--;}}a[i]=temp;quicksort(a,l,i-1,u1,v1);quicksort(a,i+1,r,u1,v1);}void shellsort(int a[],int n) /*希尔排序*/ {int d,i,j,x,y , temp,v;x=0; y=0 ;for(d=n/2;d>0;d=d/2){for(i=d;i<n;i++){temp=a[i];j=i-d;while(j>=0 && temp<a[j]){a[j+d]=a[j];y++;j=j-d;}x++ ;a[j+d]=temp;}}printf("\n the number of compare x=%d ",x);printf("\n the number of move y=%d\n ",y); for(v=0;v<=7;v++){ printf("%5d",a[v]);}printf("\n");}void binSort(int a[],int n) /* 折半插入排序 */ {int i,j,low,hight,mid,m=0,k =0 ;int v;int temp;for(i=1;i<n;i++){temp=a[i];low=0; hight=i-1;while(low<=hight){mid=(low+hight)/2;if (temp<a[mid])hight=mid-1;else low=mid+1;m++;}for(j=i-1;j>=low;j--)a[j+1]=a[j]; k++;if(low!=i) k++;a[low]=temp;}printf("the number of compare m=%d\n",m);printf("the number of move k=%d\n",k);for(v=0;v<=7;v++){ printf("%8d",a[v]); }}void main(){int i,j,k,v;int *u1=2,*v1 =0;int a[8]={11,3,28,52,46,32,66,88};int b[8]={11,3,28,52,46,32,66,88};int c[8]={11,3,28,52,46,32,66,88};printf("binSort\n");printf("\n");binSort(a,8);printf("\n");printf("shellSort\n");shellsort(b,8);printf("\n");printf("quickSort\n");printf("\n");quicksort(c,0,8,u1,v1);for(v=0;v<=7;v++){ printf("%5d",a[v]);}printf("\n the number of compare u1=%d ",*u1); printf("\n the number of move v1=%d \n ",*v1);getch();}。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现,并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法:冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序,并记录其性能指标,包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前,首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组,并随机生成一组在指定范围内的整数,用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小,并依次交换,从而将最大(或最小)的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法,效率较高。
它将待排序的序列划分成两个子序列,其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法,使用分治策略将序列拆分成较小的子序列,然后递归地对子序列进行排序,最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验,我们得到了以下结果:1. 冒泡排序在数据量较小时,冒泡排序表现良好,但随着数据规模的增大,其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序,快速排序在大数据量下的表现更佳。
它的排序时间线性增长,且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长,且对内存的使用相对较高。
五、实验分析根据实验结果,我们可以得出以下结论:1. 冒泡排序适用于数据较小的排序任务,但面对大数据量时表现较差,不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法,适用于各种数据规模。
几种排序算法的平均性能比较(实验报告)
实验课程:算法分析与设计实验名称:几种排序算法的平均性能比较(验证型实验)实验目标:(1)几种排序算法在平均情况下哪一个更快。
(2)加深对时间复杂度概念的理解。
实验任务:(1)实现几种排序算法(selectionsort, insertionsort,bottomupsort,quicksort, 堆排序)。
对于快速分类,SPLIT中的划分元素采用三者A(low),A(high),A((low+high)/2)中其值居中者。
(2)随机产生20组数据(比如n=5000i,1≤i≤20)。
数据均属于范围(0,105)内的整数。
对于同一组数据,运行以上几种排序算法,并记录各自的运行时间(以毫秒为单位)。
(3)根据实验数据及其结果来比较这几种分类算法的平均时间和比较次数,并得出结论。
实验设备及环境:PC;C/C++等编程语言。
实验主要步骤:(1)明确实验目标和具体任务;(2)理解实验所涉及的几个分类算法;(3)编写程序实现上述分类算法;(4)设计实验数据并运行程序、记录运行的结果;(5)根据实验数据及其结果得出结论;(6)实验后的心得体会。
问题分析(包括问题描述、建模、算法的基本思想及程序实现的技巧等):选择排序:令A[1…n]为待排序数组,利用归纳法,假设我们知道如何对后n-1个元素排序,即对啊[A…n]排序。
对某个j,1<=j<=n,设A[j]是最小值。
首先,如果就!=1,我们交换A[1]和A[j]。
然后由假设,已知如何对A[2..n]排序,因此可对在A[2…n]中的元素递归地排序。
可把递归改为迭代。
算法程序实现如下:void SelectionSort(int *Array,int n,int &c){int i,j,k;int aa;c=0;for(i=0;i<n;i++){k=i;for(j=i+1;j<n;j++){c++;if(Array[j]<Array[k])k=j;}if(k!=i){aa=Array[i];Array[i]=Array[k];Array[k]=aa;}}}插入排序:将n个元素的数列分为已有序和无序两个部分,每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较,找出插入位置,将该元素插入到有序数列的合适位置中。
排序算法性能比较报告
排序算法性能⽐较报告排序算法性能之⽐较----19090107 李萍课程题⽬:编程实现希尔、快速、堆排序、归并排序算法。
要求随机产⽣待排数据存⼊磁盘⽂件,然后读⼊数据⽂件,实施排序后将数据写⼊另⼀个⽂件。
开发平台:算法描述:◆希尔排序:希尔排序(Shell Sort)是对直接插⼊排序的⼀种改进,其基本思想为:先将整个待排序列划分成若⼲⼦序列,在⼦序列内分别进⾏直接插⼊排序,然后重复上述的分组和排序;只是分组⽅法不同;最后对整个序列进⾏直接插⼊排序。
◆快速排序:快速排序⼏乎是最快的排序算法,被称为20世纪⼗⼤算法之⼀。
其基本思想为:从待排序记录序列中选取⼀个记录(通常选取第⼀个记录为枢轴),其关键字值设为k,将关键字值⼩于k的记录移到前⾯,⽽将关键字值⼤于k的记录移到后⾯,结果将待排序记录序列分成两个⼦表,最后将关键字值为k的记录插⼊到分界线处。
这是⼀次“划分”。
对划分后的⼦表继续按上述原则进⾏划分,直到所有⼦表的表长不超过1为⽌,此时待排序记录序列就变成了⼀个有序序列。
◆堆排序:堆排序是选择排序的⼀种改进。
堆是具有下列性质的完全⼆叉树:每个结点的值都⼩于或等于其左、右孩⼦结点的值(⼩顶堆);或者每个结点都⼤于或等于其左、右孩⼦的值(⼤顶堆)。
堆排序基本思想为(采⽤⼤顶堆):⾸先待排序的记录序列构造成⼀个堆,此时选出堆中所有记录的最⼤者,即堆顶记录,然后将它从堆中移⾛(通常将堆顶记录和堆中最后⼀个记录交换),并将剩余的记录再调整成堆,这样⼜找出了次⼤的记录,依此类推,直到堆中只有⼀个记录为⽌。
◆归并排序:归并就是将两个或两个以上的有序序列合并成⼀个有序序列。
归并排序的主要思想是:将若⼲有序序列逐步归并,最终归并为⼀个有序序列。
程序结构:①各函数之间的关系图如下:②程序运⾏结果:欢迎界⾯:运⾏界⾯:算法性能⽐较◆理论分析:排序⽅法平均情况最好情况最坏情况希尔排序O(nlog2n)~O(n2) O(n1.3) O(n2)快速排序O(nlog2n) O(nlog2n) O(n2)归并排序O(nlog2n) O(nlog2n) O(nlog2n)堆排序O(nlog2n) O(nlog2n) O(nlog2n)从时间复杂性上看:快速排序,归并排序和堆排序的平均复杂性相同,希尔排序的时间较⼤些。
数据结构试验报告——各种内排序算法的实现及性能比较
实验报告(2010 / 2011 学年第 2 学期)课程名称数据结构——使用C++语言描述实验名称各种内排序算法的实现及性能比较实验时间2011年5月27日指导单位计算机科学与技术系指导教师学生姓名班级学号学院(系)专业一.实验目的和要求内容:验证教材的各种内排序算法。
分析各种排序算法的时间复杂度。
要求:使用随机数产生器产生大数据集合,运行上述各种排序算法,使用系统时钟测量各算法所需的实际时间,并进行比较。
二.实验环境(实验设备)Visual C++三.实验原理及内容单选择排序"<<endl;接插入排序"<<endl;泡排序"<<endl;速排序"<<endl;路合并排序"<<endl;排序"<<endl;出"<<endl;cout<<"PS:测试用的数组元素为"<<SIZE<<"时间为重复运行"<<TIMES<<"次的时间(包括了产生数据与析构的时间)"<<endl;this->switcha();}template <class T>void Menu<T>::childmenu(){cout<<"--------------------------------------------------------"<<endl;cout<<"1.最好情况"<<endl;cout<<"2.最坏情况"<<endl;cout<<"3.平均情况"<<endl;cout<<"4.返回主菜单"<<endl;cin>>b;if(b==4)this->printmenu();}template<class T>void Menu<T>::childmenu2(){cout<<"--------------------------------------------------------"<<endl;cout<<"1.原始算法"<<endl;cout<<"2.改进算法"<<endl;cout<<"3.返回主菜单"<<endl;cin>>c;if(c==3)this->printmenu();}template <class T>void Menu<T>::switcha(){<<endl;return 0;}/*ok--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS:测试用的数组元素为400时间为重复运行1000次的时间(包括了产生数据与析构的时间)ok1简单选择排序直接用随机数据测试ok用时:请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS:测试用的数组元素为400时间为重复运行1000次的时间(包括了产生数据与析构的时间)ok2直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单1ok用时:0请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单2ok用时:请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单3ok用时:请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单4--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS:测试用的数组元素为400时间为重复运行1000次的时间(包括了产生数据与析构的时间)ok3冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单1ok用时:请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单2ok用时:请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单3ok用时:请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单4--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS:测试用的数组元素为400时间为重复运行1000次的时间(包括了产生数据与析构的时间)ok4--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单1原始快速排序直接用随机数据测试ok用时:请按任意键继续. . .--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单2改进的快速排序直接用随机数据测试ok用时:请按任意键继续. . .--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单3--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS:测试用的数组元素为400时间为重复运行1000次的时间(包括了产生数据与析构的时间)ok5合并排序直接用随机数据测试ok用时:请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS:测试用的数组元素为400时间为重复运行1000次的时间(包括了产生数据与析构的时间)ok6堆排序直接用随机数据测试ok用时:请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS:测试用的数组元素为400时间为重复运行1000次的时间(包括了产生数据与析构的时间)ok7Press any key to continue*/四.实验小结(包括问题解和解决方法、心得体会、意见与建议等)通过本次实验对教材上的各种内排序算法进行了逐一验证。
排序算法设计实验报告总结
排序算法设计实验报告总结1. 引言排序算法是计算机科学中最基础的算法之一,它的作用是将一组数据按照特定的顺序进行排列。
在现实生活中,我们经常需要对一些数据进行排序,比如学生成绩的排名、图书按照标题首字母进行排序等等。
因此,了解不同的排序算法的性能特点以及如何选择合适的排序算法对于解决实际问题非常重要。
本次实验旨在设计和实现几种经典的排序算法,并对其进行比较和总结。
2. 实验方法本次实验设计了四种排序算法,分别为冒泡排序、插入排序、选择排序和快速排序。
实验采用Python语言进行实现,并通过编写测试函数对算法进行验证。
测试函数会生成一定数量的随机数,并对这些随机数进行排序,统计算法的执行时间和比较次数,最后将结果进行记录和分析。
3. 测试结果及分析3.1 冒泡排序冒泡排序是一种简单且常用的排序算法,其基本思想是从待排序的数据中依次比较相邻的两个元素,如果它们的顺序不符合要求,则交换它们的位置。
经过多轮的比较和交换,最小值会逐渐冒泡到前面。
测试结果显示,冒泡排序在排序1000个随机数时,平均执行时间为0.981秒,比较次数为499500次。
从执行时间和比较次数来看,冒泡排序的性能较差,对于大规模数据的排序不适用。
3.2 插入排序插入排序是一种简单但有效的排序算法,其基本思想是将一个待排序的元素插入到已排序的子数组中的正确位置。
通过不断将元素插入到正确的位置,最终得到排序好的数组。
测试结果显示,插入排序在排序1000个随机数时,平均执行时间为0.892秒,比较次数为249500次。
插入排序的性能较好,因为其内层循环的比较次数与待排序数组的有序程度相关,对于近乎有序的数组排序效果更好。
3.3 选择排序选择排序是一种简单但低效的排序算法,其基本思想是在待排序的数组中选择最小的元素,将其放到已排序数组的末尾。
通过多次选择和交换操作,最终得到排序好的数组。
测试结果显示,选择排序在排序1000个随机数时,平均执行时间为4.512秒,比较次数为499500次。
排序算法实验报告
数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的C语言程序,要求包含直接插入排序、希尔排序、简单项选择择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。
二、实验步骤各种内部排序算法的比较:1.八种排序算法的复杂度分析〔时间与空间〕。
2.八种排序算法的C语言编程实现。
3.八种排序算法的比较,包括比较次数、移动次数。
三、稳定性,时间复杂度和空间复杂度分析比较时间复杂度函数的情况:时间复杂度函数O(n)的增长情况所以对n较大的排序记录。
一般的选择都是时间复杂度为O(nlog2n)的排序方法。
时间复杂度来说:(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序;(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序;(3)O(n1+§))排序,§是介于0和1之间的常数。
希尔排序(4)线性阶(O(n))排序基数排序,此外还有桶、箱排序。
说明:当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数,时间复杂度可降至O〔n〕;而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为O〔n2〕;原表是否有序,对简单项选择择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性:排序算法的稳定性:假设待排序的序列中,存在多个具有相同关键字的记录,经过排序,这些记录的相对次序保持不变,则称该算法是稳定的;假设经排序后,记录的相对次序发生了改变,则称该算法是不稳定的。
稳定性的好处:排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。
另外,如果排序算法稳定,可以防止多余的比较;稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。
数据结构实验报告排序
数据结构实验报告排序数据结构实验报告:排序引言:排序是计算机科学中常见的算法问题之一,它的目标是将一组无序的数据按照特定的规则进行排列,以便于后续的查找、统计和分析。
在本次实验中,我们将学习和实现几种常见的排序算法,并对它们的性能进行比较和分析。
一、冒泡排序冒泡排序是最简单的排序算法之一,它通过不断交换相邻的元素,将较大(或较小)的元素逐渐“冒泡”到数组的一端。
具体实现时,我们可以使用两层循环来比较和交换元素,直到整个数组有序。
二、插入排序插入排序的思想是将数组分为两个部分:已排序部分和未排序部分。
每次从未排序部分中取出一个元素,插入到已排序部分的适当位置,以保持已排序部分的有序性。
插入排序的实现可以使用一层循环和适当的元素交换。
三、选择排序选择排序每次从未排序部分中选择最小(或最大)的元素,与未排序部分的第一个元素进行交换。
通过不断选择最小(或最大)的元素,将其放置到已排序部分的末尾,从而逐渐形成有序序列。
四、快速排序快速排序是一种分治的排序算法,它通过选择一个基准元素,将数组划分为两个子数组,其中一个子数组的所有元素都小于等于基准元素,另一个子数组的所有元素都大于基准元素。
然后对两个子数组分别递归地进行快速排序,最终将整个数组排序。
五、归并排序归并排序也是一种分治的排序算法,它将数组划分为多个子数组,对每个子数组进行排序,然后再将排好序的子数组合并成一个有序的数组。
归并排序的实现可以使用递归或迭代的方式。
六、性能比较与分析在本次实验中,我们对以上几种排序算法进行了实现,并通过对不同规模的随机数组进行排序,比较了它们的性能。
我们使用了计算排序时间的方式,并记录了每种算法在不同规模下的运行时间。
通过对比实验结果,我们可以得出以下结论:1. 冒泡排序和插入排序在处理小规模数据时表现较好,但在处理大规模数据时性能较差,因为它们的时间复杂度为O(n^2)。
2. 选择排序的时间复杂度也为O(n^2),与冒泡排序和插入排序相似,但相对而言,选择排序的性能稍好一些。
最新实验四排序实验报告
最新实验四排序实验报告实验目的:1. 理解并掌握四种基本排序算法:冒泡排序、选择排序、插入排序和快速排序的工作原理及其性能特点。
2. 通过编程实践,加深对算法效率和适用场景的理解。
3. 培养分析问题和解决问题的能力,提高编程技巧。
实验环境:- 操作系统:Windows 10- 编程语言:Python 3.8- 开发工具:PyCharm实验内容:1. 编写冒泡排序算法实现对一组随机整数的排序。
2. 实现选择排序算法,并对同样的一组随机整数进行排序。
3. 完成插入排序算法的编码,并用相同的数据集进行测试。
4. 编写快速排序算法,并比较其与其他三种排序算法的效率。
5. 分析比较不同排序算法在最坏、平均和最好情况下的时间复杂度。
实验步骤:1. 首先,生成一组包含50个随机整数的数据集。
2. 对于冒泡排序,重复交换相邻的元素,如果前者大于后者,则进行交换。
3. 对于选择排序,遍历数组,找到最小(或最大)的元素,将其与第一个元素交换,然后从剩下的元素中继续寻找最小(或最大)的元素,依此类推。
4. 插入排序的实现是将数组分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的适当位置。
5. 快速排序通过选定一个基准值,将数组分为两部分,一部分的元素都小于基准值,另一部分的元素都大于基准值,然后递归地在两部分上重复这个过程。
6. 使用计时器分别记录四种排序算法的执行时间,并进行比较分析。
实验结果:- 冒泡排序:平均时间复杂度为O(n^2),在实验数据集上的执行时间为X秒。
- 选择排序:平均时间复杂度为O(n^2),在实验数据集上的执行时间为Y秒。
- 插入排序:平均时间复杂度为O(n^2),在实验数据集上的执行时间为Z秒。
- 快速排序:平均时间复杂度为O(n log n),在实验数据集上的执行时间为W秒。
实验结论:通过实验,我们发现快速排序在大多数情况下都比其他三种简单排序算法有更高的效率。
冒泡排序、选择排序和插入排序在最坏情况下的时间复杂度都较高,适合处理小规模数据集或者基本有序的数据。
排序实验报告的结果总结(3篇)
第1篇一、实验背景随着计算机科学和信息技术的发展,排序算法在数据处理的领域中扮演着至关重要的角色。
本实验旨在通过对比几种常见的排序算法,分析它们的性能差异,为实际应用中选择合适的排序算法提供参考。
二、实验目的1. 熟悉几种常见排序算法的基本原理和实现方法。
2. 分析不同排序算法的时间复杂度和空间复杂度。
3. 比较不同排序算法在不同数据规模下的性能差异。
4. 为实际应用提供选择排序算法的依据。
三、实验方法1. 选择实验数据:随机生成一组包含10000个整数的数组,分别用于测试不同排序算法的性能。
2. 实现排序算法:分别实现冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等常见排序算法。
3. 性能测试:分别对每组实验数据进行排序,记录每种排序算法的运行时间。
4. 数据分析:对比不同排序算法的时间复杂度和空间复杂度,分析其性能差异。
四、实验结果1. 冒泡排序冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1)。
在测试数据规模为10000时,冒泡排序的运行时间为234.5秒。
2. 选择排序选择排序的时间复杂度为O(n^2),空间复杂度为O(1)。
在测试数据规模为10000时,选择排序的运行时间为237.1秒。
3. 插入排序插入排序的时间复杂度为O(n^2),空间复杂度为O(1)。
在测试数据规模为10000时,插入排序的运行时间为239.8秒。
4. 快速排序快速排序的平均时间复杂度为O(nlogn),空间复杂度为O(logn)。
在测试数据规模为10000时,快速排序的运行时间为18.5秒。
5. 归并排序归并排序的时间复杂度为O(nlogn),空间复杂度为O(n)。
在测试数据规模为10000时,归并排序的运行时间为20.3秒。
6. 堆排序堆排序的时间复杂度为O(nlogn),空间复杂度为O(1)。
在测试数据规模为10000时,堆排序的运行时间为19.7秒。
五、结果分析1. 时间复杂度方面:快速排序、归并排序和堆排序的平均时间复杂度均为O(nlogn),优于冒泡排序、选择排序和插入排序的O(n^2)时间复杂度。
排序性能分析实验报告(3篇)
第1篇一、实验背景排序算法是计算机科学中非常基础且重要的算法之一,它广泛应用于各种数据处理和科学计算领域。
为了更好地理解和掌握各种排序算法的原理、性能特点和应用场景,我们进行了排序性能分析实验。
本实验选取了九种经典的排序算法,包括插入排序、希尔排序、折半插入排序、冒泡排序、归并排序、快速排序、基数排序、堆排序和选择排序,通过实验对比分析这些算法的性能。
二、实验目的1. 掌握九种经典排序算法的原理和实现方法;2. 分析各种排序算法的时间复杂度和空间复杂度;3. 对比分析各种排序算法在不同数据规模和输入情况下的性能表现;4. 了解排序算法在实际应用中的适用场景。
三、实验方法1. 实验数据:随机生成大量不同规模的正整数序列,包括小规模、中等规模和大规模数据;2. 实验环境:使用C++语言进行编程实现,编译环境为Visual Studio 2019;3. 实验步骤:a. 编写九种排序算法的C++实现代码;b. 分别对每种算法进行测试,记录其执行时间和关键操作次数(如比较次数、移动次数);c. 对比分析不同算法在不同数据规模和输入情况下的性能表现;d. 分析实验结果,撰写实验报告。
四、实验结果与分析1. 插入排序插入排序是一种简单直观的排序算法,基本思想是将一个记录插入到已经排好序的有序表中,从而得到一个新的、记录数增加1的有序表。
实验结果显示,插入排序在小规模数据上表现较好,但随着数据规模的增大,其性能明显下降。
2. 希尔排序希尔排序是插入排序的一种改进版本,通过将数据分为多个子序列,分别进行插入排序,从而提高排序效率。
实验结果表明,希尔排序在小规模数据上性能略优于插入排序,但在大规模数据上,其性能提升更为明显。
3. 折半插入排序折半插入排序是插入排序的一个变种,通过二分查找减少比较次数。
实验结果显示,折半插入排序在小规模数据上性能与插入排序相当,但在大规模数据上,其性能提升较为明显。
4. 冒泡排序冒泡排序是一种简单的排序算法,基本思想是通过重复地走访过要排序的数列,一次比较两个元素,若顺序错误则交换。
算法实验报告_排序
一、实验背景排序是计算机科学中常见的基本操作,对于数据结构的学习和运用具有重要意义。
本实验旨在通过实现几种常见的排序算法,比较它们的性能,并分析它们的适用场景。
二、实验目的1. 熟悉几种常见的排序算法。
2. 比较不同排序算法的执行时间和稳定性。
3. 分析不同排序算法的适用场景。
三、实验内容1. 选择排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。
2. 实现排序算法。
3. 生成随机数组和有序数组,分别对两种数组进行排序。
4. 记录每种排序算法的执行时间和稳定性。
5. 分析不同排序算法的性能。
四、实验步骤1. 实现排序算法(1)冒泡排序冒泡排序是一种简单的排序算法,它重复地遍历待排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。
```pythondef 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]```(2)选择排序选择排序是一种简单直观的排序算法。
它的工作原理是:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
```pythondef 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]```(3)插入排序插入排序是一种简单直观的排序算法。
它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
数据结构课程设计报告 各种排序算法性能比较
课程设计报告课程设计题目:各种排序算法性能比较学生姓名:学号:专业:信息管理与信息系统班级:指导教师:2012年 06 月 23 日目录CONTENTS一、课程设计目的 (2)二、课程设计题目概述 (2)三、数据定义 (2)四、各种排序的基本原理及时间复杂度分析 (3)五、程序流程图 (6)六、程序源代码 (6)七、程序运行与测试 (15)八、实验体会…………………………………………………………九、参考文献…………………………………………………………一、课程设计目的课程设计为学生提供了一个既动手又动脑,独立实践的机会,将课本上的理论知识和实际有机的结合起来,锻炼学生的分析解决实际问题的能力。
提高学生适应实际,实践编程的能力。
二、课程设计题目概述排序的方法很多,但是就其全面性能而言,很难提出一种被认为是最好的方法,每一种方法都有各自的优缺点,适合在不同的环境下使用。
如果排序中依据的不同原则对内部排序方法进行分类,则大致可分为直接插入排序、直接选择排序、起泡排序、Shell排序、快速排序、堆排序等六类排序算法。
本实验是对直接插入排序、直接选择排序、起泡排序、Shell排序、快速排序、堆排序这几种内部排序算法进行比较,用不同的测试数据做测试比较。
比较的指标为关键字的比较次数和关键字的移动次数。
最后用图表数据汇总,以便对这些内部排序算法进行性能分析。
三、数据定义输入数据:由于大多数排序算法的时间开销主要是关键字之间的比较和记录的移动,算法的执行时间不仅依赖于问题的规模,还取决于输入实例中数据的状态。
所以对于输入数据,我们采用由用户输入记录的个数(以关键字的数目分别为20,100,500为例),测试数据由随机数产生器生成。
输出数据:产生的随机数分别用直接插入排序;直接选择排序;起泡排序;Shell排序;快速排序;堆排序这些排序方法进行排序,输出关键字的比较次数和移动次数。
四、各种排序的基本原理及时间复杂度分析1、直接插入排序(InsertSort)1.1、基本原理:假设待排序的n个记录{R0,R1,…,Rn}顺序存放在数组中,直接插入法在插入记录Ri(i=1,2,…,n-1)时,记录被划分为两个区间[R0,Ri-1]和[Ri+1,Rn-1],其中,前一个子区间已经排好序,后一个子区间是当前未排序的部分,将关键码Ki与Ki-1Ki-2,…,K0依次比较,找出应该插入的位置,将记录Ri插,然后将剩下的i-1个元素按关键词大小依次插入该有序序列,没插入一个元素后依然保持该序列有序,经过i-1趟排序后即成为有序序列。
排序算法比较实验报告
temp=j;
//ST++;
}
}
return temp;
}
long selectsort(long R[],long n)
{
long j,i,t;
long y=1;
int ST=0;
for( i=1;i<n;i++)
{
j = SelectMinKey(R,i,n);//在L.r[i..L.length]中选择关键字最小的记录
2.程序的优化是一个艰辛的过程,如果只是实现一般的功能,将变得容易很多,当加上优化,不论是效率还是结构优化,都需要精心设计。这次做优化的过程中,遇到不少阻力。因而以后要多花力气学习C++编程语言,必须要加强这方面的训练,这样才能在将编程思想和数据结构转换为代码的时候能得心应手。
3.这次课设通过在网上查阅大量资料、程序以及一些学术论文,很好的对内排序算法进行了研究,特别对数据结构这门课所学到的内容付诸于实践,加深了理解。另外,还学到了一写别的方面的知识。
排序方法
平均情况
最好情况
最坏情况
辅助空间
直接插入排序
O(n2)
O(n)
O(n2)
O(1)
起泡排序
O(n2)
O(n)
O(n2)
O(1)
快速排序
O(nlog2n)
O(nlog2n)
O(n2)
O(log2n)~O(n)
简单选择排序
O(n2)
O(n2)
O(n2)
O(1)
图6
3.4.4
影响排序的因素有很多,平均时间复杂度低的算法并不一定就是最优的。相反,有时平均时间复杂度高的算法可能更适合某些特殊情况。同时,选择算法还得考虑它的可读性,以利于软件的维护。一般而言,需要考虑的因素有以下4点:
排序算法实验报告
排序算法实验报告排序算法实验报告引言:排序算法是计算机科学中非常重要的一部分,它能够将一组无序的数据按照特定的规则进行排列,使得数据更易于查找和处理。
本次实验旨在比较不同排序算法的性能和效率,并分析它们在不同数据规模下的表现。
一、实验背景排序算法是计算机科学中的经典问题之一,其应用广泛,包括数据库管理、搜索引擎、图像处理等领域。
在实际应用中,我们常常需要对大量数据进行排序,因此选择一种高效的排序算法对于提高程序的运行效率至关重要。
二、实验目的本次实验的主要目的是比较不同排序算法的性能和效率,并找出最适合不同数据规模的排序算法。
通过实验,我们可以了解不同排序算法的原理和特点,进一步理解算法的设计思想和时间复杂度。
三、实验方法1. 实验环境本次实验使用的是一台配置较高的个人计算机,操作系统为Windows 10,处理器为Intel Core i7,内存为8GB。
2. 实验数据为了比较不同排序算法的性能,我们选择了不同规模的随机整数数组作为实验数据,包括1000个元素、10000个元素和100000个元素。
3. 实验步骤我们选取了常见的几种排序算法进行实验,包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。
具体实验步骤如下:(1)生成随机整数数组;(2)使用不同的排序算法对数组进行排序;(3)记录每种排序算法的运行时间;(4)比较不同排序算法的性能和效率。
四、实验结果与分析在实验中,我们记录了每种排序算法的运行时间,并进行了对比分析。
下面是实验结果的总结:1. 数据规模为1000个元素时,各排序算法的运行时间如下:冒泡排序:2.3ms选择排序:1.9ms插入排序:1.6ms希尔排序:0.9ms归并排序:0.6ms快速排序:0.5ms2. 数据规模为10000个元素时,各排序算法的运行时间如下:冒泡排序:240ms选择排序:190ms插入排序:160ms希尔排序:90ms归并排序:60ms快速排序:50ms3. 数据规模为100000个元素时,各排序算法的运行时间如下:冒泡排序:23900ms选择排序:19000ms插入排序:16000ms希尔排序:9000ms归并排序:6000ms快速排序:5000ms通过对比分析,我们可以得出以下结论:(1)在不同数据规模下,归并排序和快速排序的性能表现最好,运行时间最短;(2)冒泡排序和选择排序的性能最差,运行时间最长;(3)随着数据规模的增大,各排序算法的运行时间呈指数级增长。
排序实验报告
排序实验报告排序实验报告引言排序是计算机科学中的一个重要概念,它指的是将一组元素按照特定的规则进行重新排列的过程。
排序算法的选择和性能对于提高计算机程序的效率至关重要。
为了深入了解不同排序算法的优劣,我们进行了一系列的排序实验。
实验设计本次实验选择了五种常见的排序算法进行比较,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
在实验中,我们使用了Python编程语言来实现这些排序算法,并通过随机生成的整数数组作为排序的输入。
实验过程在实验过程中,我们首先使用了冒泡排序算法。
冒泡排序算法的基本思想是从数组的第一个元素开始,依次比较相邻的两个元素,如果前一个元素大于后一个元素,则交换它们的位置。
通过多次遍历数组,将最大的元素逐渐“冒泡”到数组的末尾。
冒泡排序算法的时间复杂度为O(n^2)。
接下来,我们实现了插入排序算法。
插入排序算法的核心思想是将数组分为已排序和未排序两部分,每次从未排序部分中取出一个元素,并将其插入到已排序部分的适当位置。
插入排序算法的时间复杂度也是O(n^2)。
然后,我们使用了选择排序算法。
选择排序算法的基本思想是每次从未排序的部分中选择最小的元素,然后将其与未排序部分的第一个元素交换位置。
通过多次遍历数组,将最小的元素逐渐选择到数组的开头。
选择排序算法的时间复杂度同样为O(n^2)。
接下来,我们实现了快速排序算法。
快速排序算法是一种分治法的排序算法,其基本思想是选择一个基准元素,将数组分为两个子数组,一个子数组中的元素都小于基准元素,另一个子数组中的元素都大于基准元素。
然后,对这两个子数组分别进行快速排序。
快速排序算法的时间复杂度为O(nlogn)。
最后,我们使用了归并排序算法。
归并排序算法也是一种分治法的排序算法,其基本思想是将数组递归地分成两个子数组,然后将这两个子数组合并成一个有序数组。
归并排序算法的时间复杂度同样为O(nlogn)。
实验结果通过对不同大小的随机数组进行排序实验,我们得到了如下的实验结果:冒泡排序算法的性能最差,其运行时间随着数组大小的增加呈平方级增长;插入排序和选择排序算法的性能相对较好,但仍然随着数组大小的增加呈平方级增长;快速排序和归并排序算法的性能最佳,其运行时间随着数组大小的增加呈线性对数级增长。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验课程:算法分析与设计实验名称:几种排序算法的平均性能比较(验证型实验)实验目标:(1)几种排序算法在平均情况下哪一个更快。
(2)加深对时间复杂度概念的理解。
实验任务:(1)实现几种排序算法(selectionsort, insertionsort,bottomupsort,quicksort, 堆排序)。
对于快速分类,SPLIT中的划分元素采用三者A(low),A(high),A((low+high)/2)中其值居中者。
(2)随机产生20组数据(比如n=5000i,1≤i≤20)。
数据均属于范围(0,105)内的整数。
对于同一组数据,运行以上几种排序算法,并记录各自的运行时间(以毫秒为单位)。
(3)根据实验数据及其结果来比较这几种分类算法的平均时间和比较次数,并得出结论。
实验设备及环境:PC;C/C++等编程语言。
实验主要步骤:(1)明确实验目标和具体任务;(2)理解实验所涉及的几个分类算法;(3)编写程序实现上述分类算法;(4)设计实验数据并运行程序、记录运行的结果;(5)根据实验数据及其结果得出结论;(6)实验后的心得体会。
问题分析(包括问题描述、建模、算法的基本思想及程序实现的技巧等):选择排序:令A[1…n]为待排序数组,利用归纳法,假设我们知道如何对后n-1个元素排序,即对啊[A…n]排序。
对某个j,1<=j<=n,设A[j]是最小值。
首先,如果就!=1,我们交换A[1]和A[j]。
然后由假设,已知如何对A[2..n]排序,因此可对在A[2…n]中的元素递归地排序。
可把递归改为迭代。
算法程序实现如下:void SelectionSort(int *Array,int n,int &c){int i,j,k;int aa;c=0;for(i=0;i<n;i++){k=i;for(j=i+1;j<n;j++){c++;if(Array[j]<Array[k])k=j;}if(k!=i){aa=Array[i];Array[i]=Array[k];Array[k]=aa;}}}插入排序:将n个元素的数列分为已有序和无序两个部分,每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较,找出插入位置,将该元素插入到有序数列的合适位置中。
算法程序实现如下:void InsertionSort(int *Array,int n,int &c){int i,j;int aa;c=0;for(i=0;i<n;i++){aa=Array[i];j=i-1;while(j>=0 && Array[j]>aa){c++;Array[j+1]=Array[j];j=j-1;}Array[j+1]=aa;}}自底向上合并排序:利用分治法思想,将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。
然后再把有序子序列合并为整体有序序列。
将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。
算法程序实现如下:void Merge(int *A,int p,int q,int r,int &c){int *B=new int[r-p+1]; int s=p;int t=q+1;int k=0;while(s<=q && t<=r) {c++;if(A[s]<=A[t]){B[k]=A[s];s=s+1;}else{B[k]=A[t];t=t+1;}k=k+1;}if(s==q+1){while(t<=r){B[k]=A[t];k=k+1;t=t+1;}}else{while(s<=q){B[k]=A[s];k=k+1;s=s+1;}}k=0;while(p<=r){A[p]=B[k];k++;p++;}delete B;}void BottomupSort(int *Array,int n,int &c){int s,i, t=1;c=0;while(t<n){s=t;t=2*s;i=0;while(i+t<n){Merge(Array,i,i+s-1,i+t-1,c);i=i+t;}if(i+s<n)Merge(Array,i,i+s-1,n-1,c);}}快速排序:设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。
快速排序就是递归调用此过程。
算法程序实现如下:void Split(int *A,int low,int high,int &w,int &c){int aa,x;int j,i=low;int mid=(low+high)/2;if(A[low]<A[high]){if(A[mid]<A[low])w=low;else if(A[mid]<A[high])w=mid;else w=high;}else{if(A[mid]<A[high])w=high;else if(A[mid]<A[low])w=mid;else w=low;}c++;x=A[w];aa=A[low];A[low]=A[w];A[w]=aa;for(j=low+1;j<=high;j++){c++;if(A[j]<=x){i=i+1;if(i!=j){aa=A[i];A[i]=A[j];A[j]=aa;}}}aa=A[low];A[low]=A[i];A[i]=aa;w=i;}void Quick(int *A,int low,int high,int &c){int w;if(low<high){Split(A,low,high,w,c);Quick(A,low,w-1,c);Quick(A,w+1,high,c);}}void QuickSort(int *Array,int n,int &c){c=0;Quick(Array,0,n-1,c);}堆排序:堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征,使得在当前无序区中选取最大(或最小)关键字的记录变得简单。
先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区,再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].keys≤R[n].ke y,由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。
然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换,由此得到新的无序区R[1..n-2]和有序区R[n- 1..n],且仍满足关系R[1..n-2].keys≤R[n-1..n].keys,同样要将R[1..n-2]调整为堆。
…… 直到无序区只有一个元素为止。
void Siftdown(int *H,int n,int i,int &c){bool done=false;int j,a;if(2*i+1>n)return;while(2*i+1<=n && !done){j=i;i=2*i+1;c=c+2;if(i+1<=n && H[i+1]>H[i])i=i+1;if(H[j]<H[i]){a=H[i];H[i]=H[j];H[j]=a;}else done=true;}}void MakeHeap(int *A,int n,int &c){int i;for(i=(n-2)/2;i>=0;i--)Siftdown(A,n-1,i,c);}void HeapSort(int *A,int n,int &c){c=0;MakeHeap(A,n,c);int j;int x;for(j=n-1;j>=1;j--){x=A[0];A[0]=A[j];A[j]=x;Siftdown(A,j-1,0,c);}}实验数据及其结果(可用图表形式给出):实验结果分析及结论:选择排序算法最稳定,算法的效率只跟输入规模有关,与元素序列无关,但也是效率最差。
插入排序的效率跟元素的序列有关,最好情况(已排序)时间复杂度为0,最坏情况(逆序)时间复杂度为Θ(n2).自底向上合并排序、快速排序、堆排序的效率差不多,最坏情况和最好情况时间复杂度都为o(n㏒n),对于绝大部分元素有序的数组,这三种排序算法的效率不如插入排序。
实验自我评价及心得体会:通过这次实验,我对这五种排序的原理和执行过程有了更清楚地了解,由于本次实验是在VC++2008平台下利用MFC实现,在学习算法的过程中同时也让我更加熟悉了windows 的界面编程方法。
主要参考文献:《算法设计技巧与分析》[沙特]M.H.Alsuwaiyel 著。