各种排序算法性能比较(DOC)

合集下载

算法性能实验报告

算法性能实验报告

一、实验目的本次实验旨在通过对比分析几种常用排序算法的性能,深入了解各种算法在不同数据规模和不同数据分布情况下的时间复杂度和空间复杂度,为实际应用中算法的选择提供参考。

二、实验环境- 操作系统:Windows 10- 编程语言:C++- 编译器:Visual Studio 2019- 测试数据:随机生成的正整数序列三、实验内容本次实验主要对比分析了以下几种排序算法:1. 冒泡排序(Bubble Sort)2. 选择排序(Selection Sort)3. 插入排序(Insertion Sort)4. 快速排序(Quick Sort)5. 归并排序(Merge Sort)6. 希尔排序(Shell Sort)四、实验方法1. 对每种排序算法,编写相应的C++代码实现。

2. 生成不同规模(1000、5000、10000、50000、100000)的随机正整数序列作为测试数据。

3. 对每种排序算法,分别测试其时间复杂度和空间复杂度。

4. 对比分析不同算法在不同数据规模和不同数据分布情况下的性能。

五、实验结果与分析1. 时间复杂度(1)冒泡排序、选择排序和插入排序的平均时间复杂度均为O(n^2),在数据规模较大时性能较差。

(2)快速排序和归并排序的平均时间复杂度均为O(nlogn),在数据规模较大时性能较好。

(3)希尔排序的平均时间复杂度为O(n^(3/2)),在数据规模较大时性能优于冒泡排序、选择排序和插入排序,但不如快速排序和归并排序。

2. 空间复杂度(1)冒泡排序、选择排序和插入排序的空间复杂度均为O(1),属于原地排序算法。

(2)快速排序和归并排序的空间复杂度均为O(n),需要额外的空间来存储临时数组。

(3)希尔排序的空间复杂度也为O(1),属于原地排序算法。

3. 不同数据分布情况下的性能(1)对于基本有序的数据,快速排序和归并排序的性能会受到影响,此时希尔排序的性能较好。

(2)对于含有大量重复元素的数据,快速排序的性能会受到影响,此时插入排序的性能较好。

算法实验报告

算法实验报告

算法实验报告算法实验报告引言:算法是计算机科学的核心内容之一,它是解决问题的方法和步骤的描述。

算法的设计和分析是计算机科学与工程中的重要研究方向之一。

本实验旨在通过对算法的实际应用和实验验证,深入理解算法的性能和效果。

实验一:排序算法的比较在本实验中,我们将比较三种常见的排序算法:冒泡排序、插入排序和快速排序。

我们将通过对不同规模的随机数组进行排序,并记录每种算法所需的时间和比较次数,以评估它们的性能。

实验结果显示,快速排序是最快的排序算法,其时间复杂度为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.冒泡排序冒泡排序是一种简单的排序算法,它的主要思想是依次比较相邻的两个元素,如果它们的顺序不对就交换它们的位置,可以保证每次循环后最后一个元素是已经排序好的。

冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1)。

2.插入排序插入排序是一种稳定的排序算法,它的基本思想是将待排序的数据分为两个区间,已排序区间和未排序区间,在未排序区间内遍历,将每个元素插入到已排序区间的合适位置。

插入排序的时间复杂度为O(n^2),空间复杂度为O(1)。

3.选择排序选择排序是一种比较简单的排序算法,它的主要思想是通过不断选择未排序区间内的最小值,然后和未排序区间的第一个元素交换位置,以此类推,直到排序完毕。

选择排序的时间复杂度为O(n^2),空间复杂度为O(1)。

4.快速排序快速排序是一种经典的排序算法,它的思想是采用分治的思想,将序列分为左右两个子序列,通过递归的方式对左右两个子序列进行快速排序,最后合并两个排好序的子序列。

快速排序的时间复杂度为O(nlogn),空间复杂度为O(logn)。

5.归并排序归并排序是一种稳定的排序算法,它的基本思想是采用分治的思想,将序列分为左右两个子序列,通过递归的方式对左右两个子序列进行排序,最后将两个排好序的子序列合并成一个有序序列。

归并排序的时间复杂度为O(nlogn),空间复杂度为O(n)。

通过比较以上五种排序算法,可以发现每种算法都有自己的特点和适用场景,对于元素数量较少的情况下,可以选择冒泡排序、插入排序或选择排序,这些算法思路简单易懂,实现也比较容易;对于大规模数据排序,可以选择归并排序或快速排序,因为它们的时间复杂度比较优秀。

数字大小排序

数字大小排序

数字大小排序在日常生活中,我们经常需要对一组数字进行排序,从而使它们按照从小到大或从大到小的顺序排列。

数字大小排序是一个基本而重要的技能,无论是在学习、工作还是日常生活中,我们都会遇到排序数字的情况。

本文将介绍几种常见的数字大小排序算法,帮助读者掌握这一技巧。

一、冒泡排序法冒泡排序法是最简单直观的排序方法之一。

它的基本思想是通过相邻元素的比较和交换,不断地将最大(或最小)的元素移动到最后(或最前),从而实现排序的目的。

具体的排序过程如下:1. 从第一个数字开始,依次比较相邻的两个数字的大小。

2. 如果前一个数字比后一个数字大,则交换它们的位置。

3. 继续进行该操作,直到最后一个数字。

4. 重复以上步骤,直到所有数字都按照从小到大(或从大到小)的顺序排列。

冒泡排序法虽然简单,但它的效率相对较低,尤其是对于大规模的数据排序。

因此,在实际应用中,通常不推荐使用冒泡排序法。

二、插入排序法插入排序法是另一种常见的数字大小排序算法。

它的思想是将一组无序的数字分为已排序和未排序两部分,然后逐个将未排序的数字插入到已排序的部分中。

具体的排序过程如下:1. 假设第一个数字为已排序的部分,其余为未排序的部分。

2. 从未排序的部分依次取出一个数字,插入到已排序的部分中的适当位置,使得已排序的部分仍然保持有序。

3. 重复以上步骤,直到所有数字都插入到已排序的部分中。

插入排序法相对于冒泡排序法来说,其效率更高。

但是对于大量数据的排序仍然存在较大的时间开销。

三、快速排序法快速排序法是一种高效的排序算法,广泛应用于实际生活和工作中。

它的基本思想是通过选择一个基准值,将数据划分为两部分,一部分比基准值小,另一部分比基准值大,然后对这两部分数据分别进行快速排序。

具体的排序过程如下:1. 选择一个基准值,可以是任意一个数字。

2. 将数据分为两部分,一部分比基准值小,另一部分比基准值大。

3. 对这两部分数据分别进行递归排序,即重复以上步骤,直到每个部分只有一个元素。

各种排序算法的总结和比较

各种排序算法的总结和比较

各种排序算法的总结和比较1 快速排序(QuickSort )快速排序是一个就地排序,分而治之,大规模递归的算法。

从本质上来说,它是归并排序的就地版本。

快速排序可以由下面四步组成。

(1 )如果不多于1 个数据,直接返回。

(2 )一般选择序列最左边的值作为支点数据。

(3 )将序列分成2 部分,一部分都大于支点数据,另外一部分都小于支点数据。

(4 )对两边利用递归排序数列。

快速排序比大部分排序算法都要快。

尽管我们可以在某些特殊的情况下写出比快速排序快的算法,但是就通常情况而言,没有比它更快的了。

快速排序是递归的,对于内存非常有限的机器来说,它不是一个好的选择。

2 归并排序(MergeSort )归并排序先分解要排序的序列,从1 分成2 ,2 分成4 ,依次分解,当分解到只有1 个一组的时候,就可以排序这些分组,然后依次合并回原来的序列中,这样就可以排序所有数据。

合并排序比堆排序稍微快一点,但是需要比堆排序多一倍的内存空间,因为它需要一个额外的数组。

3 堆排序( HeapSort )堆排序适合于数据量非常大的场合(百万数据)。

堆排序不需要大量的递归或者多维的暂存数组。

这对于数据量非常巨大的序列是合适的。

比如超过数百万条记录,因为快速排序,归并排序都使用递归来设计算法,在数据量非常大的时候,可能会发生堆栈溢出错误。

堆排序会将所有的数据建成一个堆,最大的数据在堆顶,然后将堆顶数据和序列的最后一个数据交换。

接下来再次重建堆,交换数据,依次下去,就可以排序所有的数据。

4 Shell 排序( ShellSort )Shell 排序通过将数据分成不同的组,先对每一组进行排序,然后再对所有的元素进行一次插入排序,以减少数据交换和移动的次数。

平均效率是O(nlogn) 。

其中分组的合理性会对算法产生重要的影响。

现在多用D.E.Knuth 的分组方法。

Shell 排序比冒泡排序快5 倍,比插入排序大致快2 倍。

Shell 排序比起QuickSort ,MergeSort ,HeapSort 慢很多。

数据结构课程设计—内部排序算法比较

数据结构课程设计—内部排序算法比较

数据结构课程设计—内部排序算法比较在计算机科学领域中,数据的排序是一项非常基础且重要的操作。

内部排序算法作为其中的关键部分,对于提高程序的运行效率和数据处理能力起着至关重要的作用。

本次课程设计将对几种常见的内部排序算法进行比较和分析,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。

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

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

这种算法的优点是易于理解和实现,但其效率较低,在处理大规模数据时性能不佳。

因为它在最坏情况下的时间复杂度为 O(n²),平均时间复杂度也为O(n²)。

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

插入排序在数据量较小时表现较好,其平均时间复杂度和最坏情况时间复杂度也都是 O(n²),但在某些情况下,它的性能可能会优于冒泡排序。

选择排序则是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(或最大)元素,然后放到已排序序列的末尾。

以此类推,直到全部待排序的数据元素排完。

选择排序的时间复杂度同样为O(n²),但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。

快速排序是一种分治的排序算法。

它首先选择一个基准元素,将数列分成两部分,一部分的元素都比基准小,另一部分的元素都比基准大,然后对这两部分分别进行快速排序。

快速排序在平均情况下的时间复杂度为 O(nlogn),最坏情况下的时间复杂度为 O(n²)。

然而,在实际应用中,快速排序通常表现出色,是一种非常高效的排序算法。

归并排序也是一种分治算法,它将待排序序列分成若干个子序列,每个子序列有序,然后将子序列合并成一个有序序列。

数据结构课程设报告—各种排序算法的比较

数据结构课程设报告—各种排序算法的比较

数据结构课程设计报告几种排序算法的演示1、需求分析:运行环境:Microsoft Visual Studio 20052、程序实现功能:3、通过用户键入的数据, 经过程序进行排序, 最后给予数据由小到大的输出。

排序的方式包含教材中所介绍的几种常用的排序方式:直接插入排序、折半插入排序、冒泡排序、快速排序、选择排序、堆排序、归并排序。

每种排序过程中均显示每一趟排序的细节。

程序的输入:输入所需排序方式的序号。

输入排序的数据的个数。

输入具体的数据元素。

程序的输出:输出排序每一趟的结果, 及最后排序结果1、设计说明:算法设计思想:a交换排序(冒泡排序、快速排序)交换排序的基本思想是: 对排序表中的数据元素按关键字进行两两比较, 如果发生逆序(即排列顺序与排序后的次序正好相反), 则两者交换位置, 直到所有数据元素都排好序为止。

b插入排序(直接插入排序、折半插入排序)插入排序的基本思想是: 每一次设法把一个数据元素插入到已经排序的部分序列的合适位置, 使得插入后的序列仍然是有序的。

开始时建立一个初始的有序序列, 它只包含一个数据元素。

然后, 从这个初始序列出发不断插入数据元素, 直到最后一个数据元素插到有序序列后, 整个排序工作就完成了。

c选择排序(简单选择排序、堆排序)选择排序的基本思想是: 第一趟在有n个数据元素的排序表中选出关键字最小的数据元素, 然后在剩下的n-1个数据元素中再选出关键字最小(整个数据表中次小)的数据元素, 依次重复, 每一趟(例如第i趟, i=1, …, n-1)总是在当前剩下的n-i+1个待排序数据元素中选出关键字最小的数据元素, 作为有序数据元素序列的第i个数据元素。

等到第n-1趟选择结束, 待排序数据元素仅剩下一个时就不用再选了, 按选出的先后次序所得到的数据元素序列即为有序序列, 排序即告完成。

d归并排序(两路归并排序)1、两路归并排序的基本思想是: 假设初始排序表有n个数据元素, 首先把它看成是长度为1的首尾相接的n个有序子表(以后称它们为归并项), 先做两两归并, 得n/2上取整个长度为2的归并项(如果n为奇数, 则最后一个归并项的长度为1);再做两两归并, ……, 如此重复, 最后得到一个长度为n的有序序列。

排序有哪几种方法

排序有哪几种方法

排序有哪几种方法排序是计算机科学中非常重要的概念之一,它指的是将一组元素按照某种规则进行重新排列的过程。

排序算法可以分为多种类型,包括插入排序、交换排序、选择排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等。

下面我将详细介绍每种排序方法的原理、特点和应用场景。

1. 插入排序(Insertion Sort)插入排序是一种简单且直观的排序算法。

它的原理是将一个未排序的元素逐个地插入到已排序的部分中,最终形成一个完全有序的序列。

具体操作是从第二个元素开始,将其与前面已排序的元素逐个比较并插入到正确的位置。

插入排序的时间复杂度为O(n^2),适用于小规模或部分有序的序列。

2. 交换排序(Exchange Sort)交换排序包括冒泡排序和快速排序。

冒泡排序(Bubble Sort)的原理是从头到尾依次比较相邻的两个元素,如果顺序不对则交换位置,一轮下来可以将最大的元素移动到末尾。

快速排序(Quick Sort)使用了分治的思想,通过选择一个基准元素将序列分成左右两部分,左边的元素都小于该基准值,右边的元素都大于该基准值,然后递归地对左右两部分进行快速排序。

交换排序的平均时间复杂度为O(nlogn),适合用于排序大规模随机数据。

3. 选择排序(Selection Sort)选择排序的原理很简单:每一次从未排序的部分中选择最小(或最大)的元素,放到已排序部分的末尾。

具体操作是通过不断找到最小元素的索引,然后将其与第一个未排序元素交换,如此循环直到所有元素都被排序。

选择排序的时间复杂度为O(n^2),适用于简单的排序需求。

4. 归并排序(Merge Sort)归并排序采用了分治的思想,将一个序列递归地分成两个子序列,直到每个子序列只有一个元素,然后将两个有序的子序列合并成一个有序的序列。

具体操作是比较两个子序列的第一个元素,将较小的元素放入结果序列,然后再比较较小元素所在子序列的下一个元素与另一个子序列的第一个元素,直到所有元素都被放入结果序列。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

课程设计报告课程名称:《数据结构》课程设计课程设计题目:各种排序算法性能比较姓名:学习院(系):计算机学院专业:计算机科学与技术年级:11级学号:学习指导教师:王爱平数据结构课程设计报告目录1 课程设计的目的 (2)2 需求分析 (2)3 课程设计报告内容 (2)3.1概要设计 (2)3.2详细设计 (2)3.3调试分析 (6)4 总结 (7)5 程序清单 (8)6 参考文献 (8)7 程序运行结果 (8)附录 (10)1 课程设计的目的(1) 熟练使用C 语言编写程序,解决实际问题;(2) 了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(3) 初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(4) 提高综合运用所学的理论知识和方法独立分析和解决问题的能力;2 需求分析(1)使用数组来存放产生的40000个随机数(2)编写统计程序运行时间的函数(3)编写快速排序、冒泡排序、插入排序、梳排序四种排序算法的函数(4 ) 编写主函数,控制程序运行3 课程设计报告内容3.1 概要设计(1)使用四种排序算法:插入排序、冒泡排序、快速排序、梳排序(2)使用clock()函数来统计时间3.2 详细设计(1)主函数:int main(){int number[MAX] = {0};int number1[MAX] = {0};int number2[MAX] = {0};int number3[MAX] = {0};int number4[MAX] = {0};int i;srand((unsigned) time(NULL)); /*播种子*/for(i = 0; i < MAX; i++){number[i] = rand() % 20000; /*产生101以内的随机整数*/number1[i]=number2[i]=number3[i]=number4[i]=number[i];while(number[i]==0){number[i] = rand() % 20000;number1[i]=number2[i]=number3[i]=number4[i]=number[i];}}//快速排序并计算时间clock_t begin1, end1;double cost1;begin1 = clock();quicksort(number1,MAX);end1 = clock();cost1 = (double)(end1 - begin1) / CLOCKS_PER_SEC;//冒泡排序并计算时间clock_t begin2, end2;double cost2;begin2 = clock();Bubble(number2,MAX);end2 = clock();cost2 = (double)(end2 - begin2) / CLOCKS_PER_SEC;//插入排序并计算时间clock_t begin3, end3;double cost3;begin3 = clock();insertSort(number3,MAX);end3 = clock();cost3 = (double)(end3 - begin3) / CLOCKS_PER_SEC;//梳排序并计算时间clock_t begin4, end4;double cost4;begin4 = clock();combsort(number4,MAX);end4 = clock();cost4 = (double)(end4 - begin4) / CLOCKS_PER_SEC;for(int j=0;j<MAX;j++){printf("%d ", number1[j]);}printf("\n");printf("排序完成!\n");printf("快速排序耗时:%lf seconds\n", cost1);printf("冒泡排序耗时:%lf seconds\n", cost2);printf("插入排序耗时:%lf seconds\n", cost3);printf("梳排序耗时:%lf seconds\n", cost4);return 0;}(2)插入排序函数:void insertSort(int a[], int len){int i, j, temp;for(i = 1; i < len; i ++){temp = a[i];for(j = i - 1; j >= 0; j --){if(a[j] > temp){a[j + 1] = a[j];}else{break;}}a[j + 1] = temp;}}(3)冒泡排序函数:void Bubble(int a[],int len){int length=len;int i=0;int j=0;for(;i<len;i++){for(;j<length;j++){if(a[j]>a[j+1]){int temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}length--;j=0;}}(4)快速排序函数:int partions(int l[],int low,int high){int prvotkey=l[low];l[0]=l[low];while (low<high){while (low<high&&l[high]>=prvotkey)--high;l[low]=l[high];while (low<high&&l[low]<=prvotkey)++low;l[high]=l[low];}l[low]=l[0];return low;}void qsort(int l[],int low,int high){int prvotloc;if(low<high){prvotloc=partions(l,low,high); //将第一次排序的结果作为枢轴qsort(l,low,prvotloc-1); //递归调用排序由low 到prvotloc-1qsort(l,prvotloc+1,high); //递归调用排序由prvotloc+1到high }}void quicksort(int l[],int n){qsort(l,1,n); //第一个作为枢轴,从第一个排到第n个}(5)梳排序函数:void combsort(int a[], int n){float shrink_factor = 1.3;int gap = n, swapped = 1, swap, i;while ((gap > 1) || swapped){if (gap > 1) gap = gap / shrink_factor;swapped = 0;i = 0;while ((gap + i) < n){if (a[i] - a[i + gap] > 0){swap = a[i];a[i] = a[i + gap];a[i + gap] = swap;swapped = 1;}++i;}}}3.3 调试分析(1)使用随机数产生函数,产生40000个随机数,再使用四种算法进行排序,并统计各种算法统计时间。

(2)运行截图如下:(3)由多次试验结果可得,梳排序和快速排序的排序速度相对较快。

4 总结通过这次课程设计我主要熟悉了快速排序、冒泡排序、插入排序、梳排序四种排序算法的具体实现方法。

我认识到了排序功能在解决实际问题中的作用,使我对数据结构的学习有了更进一步的理解。

在完成本次课程设计中,我发现很多理论性知识在实际使用时与单纯的理论还是有所差别的,今后我会更加注重培养自己的实践动手能力。

5 程序清单见附录6 参考文献[1]严蔚敏,吴伟民编著. 数据结构(C 语言版)--北京: 清华大学出版社,2007.[2]严蔚敏,吴伟民米宁编著. 数据结构题集(C 语言版)--北京: 清华大学出版社,2007.[3] /wiki/%E6%A2%B3%E6%8E%92%E5%BA%8F7 程序运行结果附录程序清单:#include "stdafx.h"#include <stdio.h>#include <stdlib.h>#include <time.h> /*用到了time函数,所以要有这个头文件*/ #define MAX 40000//插入排序void insertSort(int a[], int len){int i, j, temp;for(i = 1; i < len; i ++){temp = a[i];for(j = i - 1; j >= 0; j --){if(a[j] > temp){a[j + 1] = a[j];}else{break;}}a[j + 1] = temp;}}//冒泡排序void Bubble(int a[],int len){int length=len;int i=0;int j=0;for(;i<len;i++){for(;j<length;j++){if(a[j]>a[j+1]){int temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}length--;j=0;}}//快速排序int partions(int l[],int low,int high){int prvotkey=l[low];l[0]=l[low];while (low<high){while (low<high&&l[high]>=prvotkey)--high;l[low]=l[high];while (low<high&&l[low]<=prvotkey)++low;l[high]=l[low];}l[low]=l[0];return low;}void qsort(int l[],int low,int high){int prvotloc;if(low<high){prvotloc=partions(l,low,high); //将第一次排序的结果作为枢轴qsort(l,low,prvotloc-1); //递归调用排序由low 到prvotloc-1qsort(l,prvotloc+1,high); //递归调用排序由prvotloc+1到high }}void quicksort(int l[],int n){qsort(l,1,n); //第一个作为枢轴,从第一个排到第n个}//梳排序void combsort(int a[], int n){float shrink_factor = 1.3;int gap = n, swapped = 1, swap, i;while ((gap > 1) || swapped){if (gap > 1) gap = gap / shrink_factor;swapped = 0;i = 0;while ((gap + i) < n){if (a[i] - a[i + gap] > 0){swap = a[i];a[i] = a[i + gap];a[i + gap] = swap;swapped = 1;}++i;}}}int main(){int number[MAX] = {0};int number1[MAX] = {0};int number2[MAX] = {0};int number3[MAX] = {0};int number4[MAX] = {0};int i;srand((unsigned) time(NULL)); /*播种子*/for(i = 0; i < MAX; i++){number[i] = rand() % 20000; /*产生101以内的随机整数*/number1[i]=number2[i]=number3[i]=number4[i]=number[i];while(number[i]==0){number[i] = rand() % 20000;number1[i]=number2[i]=number3[i]=number4[i]=number[i];}}//快速排序并计算时间clock_t begin1, end1;double cost1;begin1 = clock();quicksort(number1,MAX);end1 = clock();cost1 = (double)(end1 - begin1) / CLOCKS_PER_SEC;//冒泡排序并计算时间clock_t begin2, end2;double cost2;begin2 = clock();Bubble(number2,MAX);end2 = clock();cost2 = (double)(end2 - begin2) / CLOCKS_PER_SEC;//插入排序并计算时间clock_t begin3, end3;double cost3;begin3 = clock();insertSort(number3,MAX);end3 = clock();cost3 = (double)(end3 - begin3) / CLOCKS_PER_SEC;//梳排序并计算时间clock_t begin4, end4;double cost4;begin4 = clock();combsort(number4,MAX);end4 = clock();cost4 = (double)(end4 - begin4) / CLOCKS_PER_SEC;for(int j=0;j<MAX;j++){printf("%d ", number1[j]);}printf("\n");printf("排序完成!\n");printf("快速排序耗时:%lf seconds\n", cost1);printf("冒泡排序耗时:%lf seconds\n", cost2);printf("插入排序耗时:%lf seconds\n", cost3);printf("梳排序耗时:%lf seconds\n", cost4);return 0;}。

相关文档
最新文档