C语言综合实现所有排序方法及效率比较

合集下载

c语言中排序的各种方法解析

c语言中排序的各种方法解析

c语言中排序的各种方法解析一、引言在计算机编程中,排序是一个重要的操作,它按照一定的顺序排列数据元素,使得数据元素按照从小到大的顺序排列。

在C语言中,有多种方法可以实现排序,包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。

这些排序算法都有各自的优缺点,适合不同的应用场景。

二、冒泡排序冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。

遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

算法步骤:1. 比较相邻的元素。

如果第一个比第二个大(升序),就交换它们两个。

2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。

这步做完后,最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤,除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

三、选择排序选择排序是一种简单直观的排序算法。

它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。

算法步骤:1. 在未排序序列中找到最小元素,存放到排序序列的起始位置。

2. 再从剩余未排序元素中继续寻找最小元素,然后放到已排序序列的末尾。

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

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

插入排序在实现上通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

五、快速排序快速排序使用了分治的原则,它在每一层划分都比前面方法有所改进和精进,当切分到两边的子序列长度都大于某个值时,或者一个大于一个小于这个值时再进行交换的操作来结束此层的递归过程。

这层的结果又成为下一层的两个子数组来处理,最后就得到递归式的最终结果。

数组排序c语言数组排序方法

数组排序c语言数组排序方法

数组排序c语言数组排序方法在C语言中,可以使用多种排序算法对数组进行排序。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。

下面将详细介绍这些排序算法的原理、实现以及时间复杂度。

1. 冒泡排序(Bubble Sort):冒泡排序是一种简单的排序算法,其基本思想是重复地在相邻的元素之间进行比较和交换,将最大的元素逐渐“浮”到数组的尾部。

具体实现过程如下:cvoid bubbleSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-1-i; j++) {if (arr[j] > arr[j+1]) {交换相邻元素int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}冒泡排序的时间复杂度为O(n^2),其中n为数组长度。

2. 选择排序(Selection Sort):选择排序也是一种简单的排序算法,其基本思想是每次从未排序的部分中选取最小(或最大)的元素,放到已排序部分的末尾。

具体实现过程如下:cvoid selectionSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {int minIndex = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}将最小元素交换到已排序部分的末尾int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}选择排序的时间复杂度为O(n^2)。

3. 插入排序(Insertion Sort):插入排序的基本思想是将数组分为已排序和未排序两部分,每次从未排序部分选择一个元素,插入到已排序部分的正确位置。

使用C语言实现12种排序方法

使用C语言实现12种排序方法

使⽤C语⾔实现12种排序⽅法⽬录1.冒泡排序2.插⼊排序3.折半插⼊排序4.希尔排序5.选择排序6.鸡尾酒排序7.堆排序8.快速排序9.归并排序10.计数排序11.桶排序12.基数排序1.冒泡排序思路:⽐较相邻的两个数字,如果前⼀个数字⼤,那么就交换两个数字,直到有序。

时间复杂度O(n^2),稳定性:这是⼀种稳定的算法。

代码实现:void bubble_sort(int arr[],size_t len){size_t i,j;for(i=0;i<len;i++){bool hasSwap = false; //优化,判断数组是否已经有序,如果有序可以提前退出循环for(j=1;j<len-i;j++){ //这⾥j<len-i是因为最后⾯的肯定都是最⼤的,不需要多进⾏⽐较if(arr[j-1]>arr[j]){ //如果前⼀个⽐后⼀个⼤swap(&arr[j-1],&arr[j]); //交换两个数据hasSwap = true;}}if(!hasSwap){break;}}}2.插⼊排序思路:把⼀个数字插⼊⼀个有序的序列中,使之仍然保持有序,如对于需要我们进⾏排序的数组,我们可以使它的前i个数字有序,然后再插⼊i+1个数字,插⼊到合适的位置使之仍然保持有序,直到所有的数字有序。

时间复杂度:O(n^2) 稳定性:稳定的算法代码实现:void insert_sort(int arr[],int len){int i,j;for(i=1;i<len;i++){int key = arr[i]; //记录当前需要插⼊的数据for(j= i-1;i>=0&&arr[j]>key;j--){ //找到插⼊的位置arr[j+1] = arr[j]; //把需要插⼊的元素后⾯的元素往后移}arr[j+1] = key; //插⼊该元素}}3.折半插⼊排序思路:本质上是插⼊排序,但是通过半分查找法找到插⼊的位置,让效率稍微快⼀点。

C语言八大排序算法

C语言八大排序算法

C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法,附动图和详细代码解释!来源:C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式,那么数据结构和算法就相当于程序员的内功。

想写出精炼、优秀的代码,不通过不断的锤炼,是很难做到的。

⼆⼋⼤排序算法排序算法作为数据结构的重要部分,系统地学习⼀下是很有必要的。

1、排序的概念排序是计算机内经常进⾏的⼀种操作,其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。

排序分为内部排序和外部排序。

若整个排序过程不需要访问外存便能完成,则称此类排序问题为内部排序。

反之,若参加排序的记录数量很⼤,整个序列的排序过程不可能在内存中完成,则称此类排序问题为外部排序。

2、排序分类⼋⼤排序算法均属于内部排序。

如果按照策略来分类,⼤致可分为:交换排序、插⼊排序、选择排序、归并排序和基数排序。

如下图所⽰:3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序:简单选择排序,快速排序,希尔排序,堆排序稳定排序:冒泡排序,直接插⼊排序,归并排序,奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序,然后将第3个元素插⼊到已经排好序的元素中,依次类推(插⼊排序最好的情况就是数组已经有序了)因为插⼊排序每次只能操作⼀个元素,效率低。

元素个数N,取奇数k=N/2,将下标差值为k的数分为⼀组(⼀组元素个数看总元素个数决定),在组内构成有序序列,再取k=k/2,将下标差值为k的数分为⼀组,构成有序序列,直到k=1,然后再进⾏直接插⼊排序。

3、简单选择排序选出最⼩的数和第⼀个数交换,再在剩余的数中⼜选择最⼩的和第⼆个数交换,依次类推4、堆排序以升序排序为例,利⽤⼩根堆的性质(堆顶元素最⼩)不断输出最⼩元素,直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶,再重新构造成⼩根堆,再输出堆顶元素,以此类推5、冒泡排序改进1:如果某次冒泡不存在数据交换,则说明已经排序好了,可以直接退出排序改进2:头尾进⾏冒泡,每次把最⼤的沉底,最⼩的浮上去,两边往中间靠16、快速排序选择⼀个基准元素,⽐基准元素⼩的放基准元素的前⾯,⽐基准元素⼤的放基准元素的后⾯,这种动作叫分区,每次分区都把⼀个数列分成了两部分,每次分区都使得⼀个数字有序,然后将基准元素前⾯部分和后⾯部分继续分区,⼀直分区直到分区的区间中只有⼀个元素的时候,⼀个元素的序列肯定是有序的嘛,所以最后⼀个升序的序列就完成啦。

c语言数组数据比较算法

c语言数组数据比较算法

c语言数组数据比较算法概述在C语言中,数组是一种常见的数据结构,用于存储一系列相同数据类型的元素。

在实际编程中,经常需要对数组进行比较操作,以找到数组中的最大值、最小值、排序等。

本文将详细介绍C语言中常用的数组数据比较算法。

一、数组元素比较1.1 逐个元素比较法逐个元素比较法是最简单的数组比较方法,其基本思想是将两个数组中的对应元素逐个进行比较,找出差异或相同之处。

具体步骤如下:1.声明两个数组a和b;2.逐个比较数组a和数组b的对应元素;3.如果找到不同的元素,输出差异;4.如果所有对应元素都相同,则输出相同。

1.2 利用循环遍历比较法逐个元素比较法虽然简单,但需要逐个比较所有元素,效率较低。

利用循环遍历比较法可以通过循环结构实现更高效的数组比较。

具体步骤如下: 1. 声明两个数组a和b; 2. 使用循环结构遍历数组a和数组b的对应元素; 3. 逐个比较数组a 和数组b的对应元素; 4. 如果找到不同的元素,输出差异; 5. 如果所有对应元素都相同,则输出相同。

二、数组排序算法2.1 冒泡排序法冒泡排序是一种简单的排序算法,其基本思想是多次遍历数组,每次遍历都将相邻的两个元素进行比较并交换位置,从而实现将最大(或最小)元素逐渐移到数组的末尾(或开头)。

具体步骤如下: 1. 声明一个数组a; 2. 外层循环遍历数组元素,从第一个元素到倒数第二个元素; 3. 内层循环遍历数组元素,从第一个元素到当前外层循环变量所指示的位置; 4. 逐个比较相邻的两个元素,如果前一个元素大于后一个元素,则交换它们的位置; 5. 继续下一轮的遍历,直到所有元素排序完成。

2.2 插入排序法插入排序是一种简单直观的排序算法,其基本思想是将数组分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的适当位置。

具体步骤如下: 1. 声明一个数组a; 2. 外层循环遍历数组元素,从第二个元素到最后一个元素; 3. 内层循环从外层循环变量所指示的位置开始,向前逐个比较并移动已排序部分的元素; 4. 当找到合适位置时,插入当前未排序元素; 5. 继续下一轮的遍历,直到所有元素排序完成。

C语言中的算法实现

C语言中的算法实现

C语言中的算法实现算法是计算机科学中非常重要的概念,它是解决问题的一系列步骤或指令集。

在C语言中,我们可以使用不同的方法来实现算法。

本文将介绍一些常见的C语言算法实现方式。

一、排序算法1. 冒泡排序冒泡排序是一种简单但效率较低的排序算法。

它通过不断比较相邻的元素,并按照规则交换它们的位置,直到整个序列排序完成。

2. 选择排序选择排序是一种简单而直观的排序算法。

它每次从未排序的序列中选择最小(或最大)的元素,并将其放置在已排序序列的末尾。

3. 插入排序插入排序是一种简单且高效的排序算法。

它通过构建有序序列,对未排序的元素逐个插入到已排序的序列中,直到所有元素都被插入完成。

二、查找算法1. 顺序查找顺序查找是一种简单的查找算法。

它从列表的开头开始逐个比较元素,直到找到目标元素或查找完整个列表。

2. 二分查找二分查找是一种高效的查找算法,但要求列表必须是有序的。

它通过将待查找区域分成两部分,判断目标元素落在哪一部分,从而缩小查找范围,直到找到目标元素或确定不存在。

三、递归算法递归是一种常用的算法设计技巧。

它通过在函数内调用自身来解决相同问题的不同实例。

在C语言中,递归函数需要定义出口条件,以避免无限递归。

四、动态规划算法动态规划是一种用于解决具有重叠子问题和最优子结构性质的问题的方法。

它将问题分解为一系列子问题,并以自底向上的方式求解子问题,最终得到整体问题的解。

在C语言中,可以使用循环、数组和指针等特性来实现动态规划算法,从而有效地解决问题。

五、图算法图是一种用于描述对象之间关系的数据结构,图算法是解决图相关问题的一类算法。

常见的图算法包括深度优先搜索(DFS)和广度优先搜索(BFS)。

六、字符串算法字符串算法用于处理字符串相关的问题,如字符串匹配、编辑距离等。

C语言提供了一系列字符串处理函数,如strlen、strcpy等,可以方便地实现字符串算法。

七、数学算法C语言在数学算法方面提供了丰富的库函数支持,如求平方根、对数、指数等。

c语言实现简单排序(8种方法)

c语言实现简单排序(8种方法)

#include<stdio.h>#include<stdlib.h>//冒泡排序voidbubleSort(int data[], int n);//快速排序voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high);//插入排序voidbInsertSort(int data[], int n);//希尔排序voidshellSort(int data[], int n);//选择排序voidselectSort(int data[], int n);//堆排序voidheapSort(int data[], int n);void swap(int data[], inti, int j);voidheapAdjust(int data[], inti, int n);//归并排序voidmergeSort(int data[], int first, int last);void merge(int data[], int low, int mid, int high); //基数排序voidradixSort(int data[], int n);intgetNumPos(intnum, intpos);int main() {int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");/*printf("冒泡排序:");bubleSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("快速排序:");quickSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("插入排序:");bInsertSort(data,10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("希尔排序:");shellSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("选择排序:");selectSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf(" 堆排序:");heapSort(data, 10);for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf("归并排序:");mergeSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");*/printf("基数排序:");radixSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");return 0;}/*--------------------冒泡排序---------------------*/ voidbubleSort(int data[], int n) {inti,j,temp;//两个for循环,每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。

数据结构(C语言版)实验报告 (内部排序算法比较)

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

#include<iostream.h>#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 50000typedef char elemtype; typedef struct{int key;elemtype otheritem;}recdtype,*Recdtype;recdtype R[N];//直接插入排序void InsertSort(Recdtype R,int n) {int i,j;for(i=2;i<=n;i++){R[0]=R[i];j=i-1;while(R[0].key<R[j].key){R[j+1]=R[i];j--;}R[j+1]=R[0];}}/*InsertSort*///折半查找void BinSort(recdtype R[],int n) {int i,j,low,high,m;for(i=2;i<=n;i++){R[0]=R[i];low=1;high=i-1;while(low<=high){m=(low+high)/2;if(R[0].key<R[m].key)high=m-1;elselow=m+1;}for(j=i-1;j>=high+1;j--)R[j+1]=R[j];R[high+1]=R[0];}}/*BinSort*///希尔排序void ShellSort(recdtype R[],int n){int i,j;for(int d=N/2;d>=1;d=d/2){for(i=1+d;i<=n;i++){R[0]=R[i];j=i-d;while(j>0&&R[0].key<R[j].key){R[j+d]=R[j];j=j-d;}R[j+d]=R[0];}}}/*ShellSort*///冒泡排序void BubbleSort(recdtype R[],int n){int lastExchange;recdtype temp;for(int i=0;i<n-2;i++){lastExchange=1;for(int j=n-1;j>=i;j--){if(R[j+1].key<R[i].key){temp=R[i+1];R[i+1]=R[i];R[i]=temp;lastExchange=0;}if(lastExchange)break;}}}/*BubbleSort*///快速排序int Partition(recdtype R[],int l,int h)//一次划分算法{int i=l;int j=h;R[0]=R[i];int x=R[i].key ;while(i<j){while(i<j&&R[j].key >=x)j--;R[i]=R[j];while(i<j&&R[i].key <=x)i++;R[j]=R[i];}R[i]=R[0];return i;}void QuickSort(recdtype R[],int s,int t)//快速排序{int k;if(s<t){k=Partition(R,s,t);QuickSort(R,s,k-1);QuickSort(R,k+1,t);}}//直接选择排序void SelectSort(recdtype R[],int n){int i,j,k;for(i=1;i<n;i++){k=i;for(j=i+1;j<=n;j++)if(R[j].key<R[k].key)k=j;if(i!=k){R[0]=R[i];R[i]=R[k];R[k]=R[0];}}}/*SlectSort*///堆排序void Shift(recdtype R[],int i,int m){int j;R[0]=R[i];for(j=2*i;j<=m;j*=2){if(j<m&&R[j].key<R[j+1].key)j++;if(R[0].key<R[j].key){R[i]=R[j];i=j;}elsebreak;}R[i]=R[0];}/*Shift*/void HeapSort(recdtype R[],int n){recdtype temp;int i;for(i=n/2;i>0;i--)Shift(R,i,n);for(i=n;i>1;i--){temp=R[1];R[1]=R[i];R[i]=temp;Shift(R,1,i-1);}}/*HeapSort*///二路归并算法void Merge(recdtype R[],int low,int middle,int high) {int h,i,j,k;recdtype R1[N+1];h=low;i=low;j=middle+1;while(h<=middle&&j<=high){if(R[h].key <=R[j].key ){R1[i]=R[h];h++;}else{R1[i]=R[j];j++;}i++;}if(h>middle)for(k=j;k<=high;k++){R1[i]=R[k];i++;}else{for(k=h;k<=middle;k++){R1[i]=R[k];i++;}}for(k=low;k<=high;k++){R[k]=R1[k];}}void MergeSort(recdtype R[],int low,int high)//归并排序{int middle;if(low<high){middle=(low+high)/2;MergeSort(R,low,middle);MergeSort(R,middle+1,high);Merge(R,low,middle,high);}}//计算时间差void DifferTime(double finish,double start){double difftime=(finish-start)/CLOCKS_PER_SEC;cout<<"the cost of times:"<<difftime<<endl; }/*Differ*/void main(){int i,kind;char flag='y';time_t start,finish;start=time(NULL);finish=time(NULL);recdtype R[N];srand((unsigned)time(NULL));cout<<"测试数组元素的个数为:"<<N<<endl;while(flag=='y'){cout<<"请输入排序种类(1~8):"<<endl;cin>>kind;switch(kind){case 1:cout<<"冒泡排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();BubbleSort(R,N);finish= clock();DifferTime(finish,start);break;case 2:cout<<"希尔排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();ShellSort(R,N);finish= clock();DifferTime(finish,start);break;case 3:cout<<"折半插入排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();BinSort(R,N);finish= clock();DifferTime(finish,start);break;case 4:cout<<"直接插入排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();InsertSort(R,N);finish= clock();DifferTime(finish,start);break;case 5:cout<<"快速排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();QuickSort(R,1,N);finish= clock();DifferTime(finish,start);break;case 6:cout<<"直接选择排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();SelectSort(R,N);finish= clock();DifferTime(finish,start);break;case 7:cout<<"堆排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();HeapSort(R,N);finish= clock();DifferTime(finish,start);break;case 8:cout<<"二路归并排序:"<<endl;for( i=1;i<=N;i++)R[i].key=rand();start= clock();MergeSort(R,1,N);finish= clock();DifferTime(finish,start);break;default:cout<<"输入错误,程序结束!"<<endl;return;}cout<<"是否继续?(输入n结束,输入y有效!)"<<endl;cin>>flag;}cout<<"测试结束,再见!"<<endl; }。

相关文档
最新文档