快速排序算法设计
数据结构实验报告八-快速排序
实验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、轴值寻找算法：//为了保证轴值的“随机性”，采用时间初始化种子。
快速排序算法c语言实验报告
快速排序算法c语言实验报告冒泡法和选择法排序C程序实验报告实验六：冒泡法排序物理学416班赵增月F12 2011412194日期：2013年10月31日一·实验目的 1.熟练掌握程序编写步骤；2.学习使用冒泡法和选择法排序；3.熟练掌握数组的定义和输入输出方法。
二·实验器材1.电子计算机；2.VC6.0三·实验内容与流程1.流程图（1）冒泡法(2)选择法 2.输入程序如下：（1）冒泡法#includestdio.h void main() { int a[10]; int i,j,t; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]); printf(\n); for(j=0;j9;j++)for(i=0;i9-j;i++) if(a[i]a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } printf(排序后如下：\n); for(i=0;i10;i++) printf(%d,a[i]); printf(\n); }（2）选择法#includestdio.h void main() { int a[10]; int i,j,t,k; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]);printf(\n); for(i=0;i9;i++) {k=i;for(j=i+1;j10;j++) if (a[k]a[j])k=j;t=a[i];a[i]=a[k];a[k]=t; }printf(排序后如下：\n); for(i=0;i10;i++)printf(%d,a[i]); printf(\n); }四．输出结果（1冒泡法）请输入10个数字：135****2468排序后如下：12345678910 （2）选择法输出结果请输入10个数字：135****6810排序后如下：12345678910五．实验反思与总结1.冒泡法和选择法是一种数组排序的方法，包含两层循环，写循环时，要注意循环变量的变化范围。
5. 5排序算法--快速与归并 课件-2021-2022学年浙教版（2019）高中信息技术选修1
快速排序算法
·快速排序算法(用栈实现)
代码：
def quick_sort(array, l, r): if l >= r: return stack = [] stack.append(l) stack.append(r) while stack: low = stack.pop(0) hight = stack.pop(0) if hight - low <= 0: continue k = array[hight] i = low - 1 for j in range(low, hight):
选修1《数据与数据结构》
第五章 数据结构与算法
5.5 排序算法 --快速与归并
学习目标
快速排序算法 归并排序算法
排序算法
快速排序算法
排序算法
·快速排序的基本思路
快速排序使用分治法策略来把一个串行（list）分为两个子串行（sub-lists）。
算法步骤：
1、 在数组中选一个基准数（通常为数组第一个）。 2、将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边。 3、对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只 有一个元素，即为全部有序。
排序算法
k = l #归并子数组的索引 while i < n1 and j < n2:
if L[i] <= R[ j]: arr[k] = L[i] i += 1
else: arr[k] = R[ j] j += 1
k += 1 while i < n1:
arr[k] = L[i] i += 1 k += 1 while j < n2: arr[k] = R[ j] j += 1 k += 1
算法分析与设计实验报告合并排序快速排序
算法分析与设计实验报告：合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分，它涉及到解决问题的方法和步骤。
合并排序和快速排序是两种经典而常用的排序算法。
本文将对这两种排序算法进行分析和设计实验，通过对比它们的性能和效率，以期得出最优算法。
二、合并排序合并排序是一种分治算法，它将原始数组不断分解为更小的数组，直到最后细分为单个元素。
然后，再将这些单个元素两两合并，形成一个有序数组。
合并排序的核心操作是合并两个有序的数组。
1. 算法步骤（1）将原始数组分解为更小的子数组，直到每个子数组只有一个元素；（2）两两合并相邻的子数组，同时进行排序，生成新的有序数组；（3）重复步骤（2），直到生成最终的有序数组。
2. 算法性能合并排序的最优时间复杂度为O(nlogn)，其中n为待排序数组的长度。
无论最好情况还是最坏情况，合并排序的复杂度都相同。
合并排序需要额外的存储空间来存储临时数组，所以空间复杂度为O(n)。
三、快速排序快速排序也是一种分治算法，它将原始数组根据一个主元（pivot）分成两个子数组，一个子数组的元素都小于主元，另一个子数组的元素都大于主元。
然后，递归地对这两个子数组进行排序，最后得到有序数组。
快速排序的核心操作是划分。
1. 算法步骤（1）选择一个主元（pivot），可以是随机选择或者固定选择第一个元素；（2）将原始数组根据主元划分为两个子数组，一个子数组的元素都小于主元，另一个子数组的元素都大于主元；（3）递归地对这两个子数组进行快速排序；（4）重复步骤（2）和（3），直到每个子数组只有一个元素，即得到最终的有序数组。
2. 算法性能快速排序的平均时间复杂度为O(nlogn)，其中n为待排序数组的长度。
最坏情况下，当每次选择的主元都是最小或最大元素时，时间复杂度为O(n^2)。
快速排序是原地排序，不需要额外的存储空间，所以空间复杂度为O(1)。
四、实验设计为了验证合并排序和快速排序的性能和效率，我们设计以下实验：1. 实验目的：比较合并排序和快速排序的时间复杂度和空间复杂度。
快速排序算法实验报告
快速排序算法实验报告快速排序算法实验报告引言快速排序算法是一种高效的排序算法，它的时间复杂度为O(nlogn)，在实际应用中被广泛使用。
本实验旨在通过实际的实验数据，验证快速排序算法的效果和性能，并对其进行分析和总结。
实验设计本实验采用C++语言编写快速排序算法，并通过随机生成的数据进行排序实验。
实验中使用了不同规模的数据集，并记录了排序所需的时间和比较次数。
实验步骤1. 实现快速排序算法快速排序算法的核心思想是通过选取一个基准元素，将待排序的序列分为两部分，一部分比基准元素小，一部分比基准元素大，然后对这两部分继续进行快速排序。
具体实现时，可以选择序列的第一个元素作为基准元素，然后使用分治法递归地对子序列进行排序。
2. 生成测试数据为了验证快速排序算法的性能，我们生成了不同规模的随机数序列作为测试数据。
测试数据的规模分别为1000、10000、100000和1000000。
3. 进行排序实验使用生成的测试数据，对快速排序算法进行实验。
记录每次排序所需的时间和比较次数，并将结果进行统计和分析。
实验结果通过对不同规模的数据集进行排序实验，我们得到了以下结果：数据规模排序时间（ms）比较次数1000 2 872810000 12 114846100000 124 13564771000000 1483 15737267分析与讨论从实验结果可以看出，随着数据规模的增大，排序所需的时间和比较次数也呈指数级增长。
这符合快速排序算法的时间复杂度为O(nlogn)的特性。
另外，通过观察实验结果，我们可以发现快速排序算法的性能受到多个因素的影响。
首先，基准元素的选择对算法的效率有很大的影响。
如果选择的基准元素恰好是序列的中位数，那么排序的效率会更高。
其次，数据的初始顺序也会影响排序的效果。
如果数据已经是有序的，那么快速排序算法的效率将大大降低。
此外，快速排序算法还存在一些优化的空间。
例如，可以通过随机选择基准元素来避免最坏情况的发生。
CC++实现快速排序算法的思路及原理解析
CC++实现快速排序算法的思路及原理解析⽬录快速排序2. 实现原理3. 动态演⽰4. 完整代码5. 结果展⽰6. 算法分析快速排序1. 算法思想快速排序的基本思想：通过⼀趟排序将待排记录分隔成独⽴的两部分，其中⼀部分记录的关键字均⽐另⼀部分的关键字⼩，则可分别对这两部分记录继续进⾏排序，以达到整个序列有序。
2. 实现原理2.1、设置两个变量 low、high，排序开始时：low=0，high=size-1。
2.2、整个数组找基准正确位置，所有元素⽐基准值⼩的摆放在基准前⾯，所有元素⽐基准值⼤的摆在基准的后⾯默认数组的第⼀个数为基准数据，赋值给key，即key=array[low]。
因为默认数组的第⼀个数为基准，所以从后⾯开始向前搜索（high–），找到第⼀个⼩于key的array[high]，就将 array[high] 赋给 array[low]，即 array[low] = array[high]。
（循环条件是 array[high] >= key；结束时 array[high] < key）此时从前⾯开始向后搜索（low++），找到第⼀个⼤于key的array[low]，就将 array[low] 赋给 array[high]，即 array[high] = array[low]。
（循环条件是 array[low] <= key；结束时 array[low] > key）循环 2-3 步骤，直到 low=high，该位置就是基准位置。
把基准数据赋给当前位置。
2.3、第⼀趟找到的基准位置，作为下⼀趟的分界点。
2.4、递归调⽤（recursive）分界点前和分界点后的⼦数组排序，重复2.2、2.3、2.4的步骤。
2.5、最终就会得到排序好的数组。
3. 动态演⽰4. 完整代码三个函数基准插⼊函数：int getStandard(int array[],int low,int high)（返回基准位置下标）递归排序函数：void quickSort(int array[],int low,int high)主函数：int main()#include <stdio.h>#include <stdlib.h>void display(int* array, int size) {for (int i = 0; i < size; i++) {printf("%d ", array[i]);}printf("\n");}int getStandard(int array[], int i, int j) {// 基准数据int key = array[i];while (i < j) {// 因为默认基准是从左边开始，所以从右边开始⽐较// 当队尾的元素⼤于等于基准数据时,就⼀直向前挪动 j 指针while (i < j && array[j] >= key) {j--;}// 当找到⽐ array[i] ⼩的时，就把后⾯的值 array[j] 赋给它if (i < j) {array[i] = array[j];}// 当队⾸元素⼩于等于基准数据时,就⼀直向后挪动 i 指针while (i < j && array[i] <= key) {i++;}// 当找到⽐ array[j] ⼤的时，就把前⾯的值 array[i] 赋给它if (i < j) {array[j] = array[i];}}// 跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置// 把基准数据赋给正确位置array[i] = key;return i;}void QuickSort(int array[], int low, int high) {// 开始默认基准为 lowif (low < high) {// 分段位置下标int standard = getStandard(array, low, high);// 递归调⽤排序// 左边排序QuickSort(array, low, standard - 1);// 右边排序QuickSort(array, standard + 1, high);}}// 合并到⼀起快速排序// void QuickSort(int array[], int low, int high) {// if (low < high) {// int i = low;// int j = high;// int key = array[i];// while (i < j) {// while (i < j && array[j] >= key) {// j--;// }// if (i < j) {// array[i] = array[j];// }// while (i < j && array[i] <= key) {// i++;// }// if (i < j) {// array[j] = array[i];// }// }// array[i] = key;// QuickSort(array, low, i - 1);// QuickSort(array, i + 1, high);// }// }int main() {int array[] = {49, 38, 65, 97, 76, 13, 27, 49, 10};int size = sizeof(array) / sizeof(int);// 打印数据printf("%d \n", size);QuickSort(array, 0, size - 1);display(array, size);// int size = 20;// int array[20] = {0}; // 数组初始化// for (int i = 0; i < 10; i++) { // 数组个数// for (int j = 0; j < size; j++) { // 数组⼤⼩// array[j] = rand() % 1000; // 随机⽣成数⼤⼩ 0~999// }// printf("原来的数组：");// display(array, size);// QuickSort(array, 0, size - 1);// printf("排序后数组：");// display(array, size);// printf("\n");// }return 0;}5. 结果展⽰（递归调⽤，不好展⽰每次排序结果）6. 算法分析时间复杂度：最好： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)最坏： O ( n 2 ) O(n^2) O(n2)平均： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)空间复杂度： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)稳定性：不稳定到此这篇关于C/C++实现快速排序算法的思路及原理解析的⽂章就介绍到这了,更多相关C++实现快速排序算法内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
快速排序算法实验报告
快速排序算法实验报告快速排序一、问题描述在操作系统中，我们总是希望以最短的时间处理完所有的任务。
但事情总是要一件件地做，任务也要操作系统一件件地处理。
当操作系统处理一件任务时，其他待处理的任务就需要等待。
虽然所有任务的处理时间不能降低，但我们可以安排它们的处理顺序，将耗时少的任务先处理，耗时多的任务后处理，这样就可以使所有任务等待的时间和最小。
只需要将n 件任务按用时去从小到大排序，就可以得到任务依次的处理顺序。
当有 n 件任务同时来临时，每件任务需要用时ni，求让所有任务等待的时间和最小的任务处理顺序。
二、需求分析1. 输入事件件数n，分别随机产生做完n件事所需要的时间；2. 对n件事所需的时间使用快速排序法，进行排序输出。
排序时，要求轴值随机产生。
3. 输入输出格式：输入：第一行是一个整数n，代表任务的件数。
接下来一行，有n个正整数，代表每件任务所用的时间。
输出：输出有n行，每行一个正整数，从第一行到最后一行依次代表着操作系统要处理的任务所用的时间。
按此顺序进行，则使得所有任务等待时间最小。
4. 测试数据：输入 95 3 4 26 1 57 3 输出1 2 3 3 4 5 5 6 7三、概要设计抽象数据类型因为此题不需要存储复杂的信息，故只需一个整型数组就可以了。
算法的基本思想对一个给定的进行快速排序，首先需要选择一个轴值，假设输入的数组中有k个小于轴值的数，于是这些数被放在数组最左边的k个位置上，而大于周知的结点被放在数组右边的n-k个位置上。
k也是轴值的下标。
这样k把数组分成了两个子数组。
分别对两个子数组，进行类似的操作，便能得到正确的排序结果。
程序的流程输入事件件数n-->随机产生做完没个事件所需时间-->对n个时间进行排序-->输出结果快速排序方法：初始状态 72 6 57 88 85 42 l r第一趟循环 72 6 57 88 85 42 l r 第一次交换 6 72 57 88 85 42 l r 第二趟循环 6 72 57 88 85 42 r l 第二次交换 72 6 57 88 85 42 r l反转交换 6 72 57 88 85 42 r l这就是依靠轴值，将数组分成两部分的实例。
【转】三种快速排序算法以及快速排序的优化
【转】三种快速排序算法以及快速排序的优化⼀. 快速排序的基本思想快速排序使⽤分治的思想，通过⼀趟排序将待排序列分割成两部分，其中⼀部分记录的关键字均⽐另⼀部分记录的关键字⼩。
之后分别对这两部分记录继续进⾏排序，以达到整个序列有序的⽬的。
⼆. 快速排序的三个步骤1) 选择基准：在待排序列中，按照某种⽅式挑出⼀个元素，作为 “基准”（pivot）；2) 分割操作：以该基准在序列中的实际位置，把序列分成两个⼦序列。
此时，在基准左边的元素都⽐该基准⼩，在基准右边的元素都⽐基准⼤；3) 递归地对两个序列进⾏快速排序，直到序列为空或者只有⼀个元素；三. 选择基准元的⽅式对于分治算法，当每次划分时，算法若都能分成两个等长的⼦序列时，那么分治算法效率会达到最⼤。
也就是说，基准的选择是很重要的。
选择基准的⽅式决定了两个分割后两个⼦序列的长度，进⽽对整个算法的效率产⽣决定性影响。
最理想的⽅法是，选择的基准恰好能把待排序序列分成两个等长的⼦序列。
⽅法⼀：固定基准元（基本的快速排序）思想：取序列的第⼀个或最后⼀个元素作为基准元。
/// <summary>/// 1.0 固定基准元（基本的快速排序）/// </summary>public static void QsortCommon(int[] arr, int low, int high){if (low >= high) return; //递归出⼝int partition = Partition(arr, low, high); //将 >= x 的元素交换到右边区域，将 <= x 的元素交换到左边区域QsortCommon(arr, low, partition - 1);QsortCommon(arr, partition + 1, high);}/// <summary>/// 固定基准元，默认数组第⼀个数为基准元，左右分组，返回基准元的下标/// </summary>public static int Partition(int[] arr, int low, int high){int first = low;int last = high;int key = arr[low]; //取第⼀个元素作为基准元while (first < last){while (first < last && arr[last] >= key)last--;arr[first] = arr[last];while (first < last && arr[first] <= key)first++;arr[last] = arr[first];}arr[first] = key; //基准元居中return first;}注意：基本的快速排序选取第⼀个或最后⼀个元素作为基准。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
快速排序算法设计(10003809386j) 一实验目的使学生掌握常用内部排序的基本概念和基本方法使学生掌握常用内部排序方法的性能评价；使学生掌握排序方法在实际问题中的应用；二实验环境所需硬件环境为微机；所需软件环境为Microsoft Visual C++ 6.0；三实验内容此部分仅用写出要求的实验代码,并加上必要的注释#include <stdio.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OVERFLOW -2#define OK 1#define FAILURE 0#define TRUE 1#define FALSE 0#define ERROR -1typedef int ElemType;typedef int Status;void PrintElem(ElemType *e){printf("%5d",*e);}#include <stdlib.h>#include "ElemType.c"int p[6];//记录比较次数int q[6];//记录移动次数void InsertSort(int *L,int n)// 直接插入排序{ int i,j;for(i=2;i<=n;i++){if(L[i]<L[i-1]){L[0]=L[i];L[i]=L[i-1];for(j=i-2;L[0]<L[j];j--){ L[j+1]=L[j];p[0]++;q[0]++;}L[j+1]=L[0];q[0]+=3;}p[0]++;}}void ShellInsert(int *L,int n,int dk)// 希尔排序{ int i,j;for(i=dk+1;i<=n;i++){if(L[i]<L[i-dk]){L[0]=L[i];for(j=i-dk;j>0&&L[0]<L[j];j-=dk){L[j+dk]=L[j];p[1]++;q[1]++;}L[j+dk]=L[0];q[1]+=2;}p[1]++; }}void ShellSort(int *L,int n) // 希尔排序{ int dalt[6]={13,11,7,5,3,1};int i;for(i=0;i<6;i++)ShellInsert(L,n,dalt[i]);}void buddlesort(int *L,int n)// 冒泡排序{ int i,j,k,m;for(i=n,k=1;i>1&&k;i--){ k=0;for(j=1;j<i;j++){if(L[j]>L[j+1]){ m=L[j];L[j]=L[j+1];L[j+1]=m;k=1;q[2]+=3;}p[2]++; }}}int Partition(int *L,int low,int high){ int k;L[0]=L[low];k=L[low];while(low<high){ while(low<high&&L[high]>=k) {high--;p[3]++;}L[low]=L[high];while(low<high&&L[low]<=k) {low++;p[3]++;} L[high]=L[low];p[3]+=2;q[3]+=2; }L[low]=L[0];q[3]+=3;return low;}void QSort(int *L,int low,int high){ int k;if(low<high){ k=Partition(L,low,high);QSort(L,low,k-1);QSort(L,k+1,high); } }void QuikSort(int *L,int n)// 快速排序{ QSort(L,1,n); }void HeapAdjust(int *L,int s,int m)// 堆排序{ int j,t;t=L[s];for(j=2*s;j<=m;j*=2){if(j<m&&L[j]<L[j+1]){j++;p[4]++;}if(t>=L[j]) break;p[4]+=2;q[4]++;L[s]=L[j];s=j;}L[s]=t;q[4]+=2;}void HeapSort(int *L,int n) // 堆排序{ int i,t;for(i=n/2;i>0;i--)HeapAdjust(L,i,n);for(i=n;i>1;i--){t=L[1];L[1]=L[i];L[i]=t;q[4]+=3;HeapAdjust(L,1,i-1); }}void Merge(int *SR,int *TR,int i,int m,int n) { int j,k,t;for(j=m+1,k=i;i<=m&&j<=n;++k){ if(SR[i]<SR[j]){TR[k]=SR[i];i++;}else{TR[k]=SR[j];j++;}q[5]++;p[5]++;}if(i<=m)for(t=i;t<=m;t++){ TR[k]=SR[t];q[5]++;k++;}if(j<=n)for(t=j;t<=n;t++){ TR[k]=SR[t];q[5]++;k++;}}void MSort(int *SR,int *TR1,int s,int t){ int *TR2=(int *)malloc(sizeof(int)*t);int m;if(s==t){TR1[s]=SR[s];q[5]++;}else{ m=(s+t)/2;MSort(SR,TR2,s,m);MSort(SR,TR2,m+1,t);Merge(TR2,TR1,s,m,t);}}void MergeSort(int *L,int n)// .归并排序{MSort(L,L,1,n); }int main(){ //主函数1int k,i,a[10]={5,8,1,11,23,41,16,44,14,9};int L[101];printf("原数字排列为：");for(i=0;i<10;i++)L[i+1]=a[i];for(i=0;i<10;i++)printf("%d,",L[i+1]);printf("\n-------------主菜单-------------\n"); printf("1.直接插入排序\n");printf("2.希尔排序\n");printf("3.冒泡排序\n");printf("4.快速排序\n");printf("5.堆排序\n");printf("6.归并排序\n");printf("7.退出\n");printf("--------------------------------\n");while(1){ printf("请选择选项：");scanf("%d",&k);switch(k){ case 1:printf("使用直接排序方法得到的结果是：\n");InsertSort(L,10);for(i=0;i<10;i++) printf("%d,",L[i+1]); printf("\n");break;case 2:for(i=0;i<10;i++) L[i+1]=a[i];printf("使用希尔排序方法得到的结果是：\n");ShellSort(L,10);for(i=0;i<10;i++) printf("%d,",L[i+1]); printf("\n");break;case 3:for(i=0;i<10;i++) L[i+1]=a[i];printf("使用冒泡排序方法得到的结果是：\n");buddlesort(L,10);for(i=0;i<10;i++) printf("%d,",L[i+1]); printf("\n");break;case 4:for(i=0;i<10;i++) L[i+1]=a[i];printf("使用快速排序方法得到的结果是：\n");QuikSort(L,10);for(i=0;i<10;i++) printf("%d,",L[i+1]); printf("\n");break;case 5:for(i=0;i<10;i++) L[i+1]=a[i];printf("使用堆排序方法得到的结果是：\n");HeapSort(L,10);for(i=0;i<10;i++)printf("%d,",L[i+1]);printf("\n");break;case 6:for(i=0;i<10;i++) L[i+1]=a[i];printf("使用归并排序方法得到的结果是：\n");MergeSort(L,10);for(i=0;i<10;i++)printf("%d,",L[i+1]);printf("\n");break;case 7:printf("已退出！");exit(0);break;default:printf("\nInput error!"); }}return 0; }#include<stdio.h>//主函数2#include<stdlib.h>#include "Sort.c"int main(){int L[101],i,k;for(i=0;i<100;i++)L[i+1]=100 + rand() % (1000 - 100) ;printf("\n-------------主菜单-------------\n");printf("1.直接插入排序\n");printf("2.希尔排序\n");printf("3.冒泡排序\n");printf("4.快速排序\n");printf("5.堆排序\n");printf("6.归并排序\n");printf("7.退出\n");printf("--------------------------------\n");while(1){ printf("请选择选项：");scanf("%d",&k);switch(k){case 1:InsertSort(L,100);printf("1.直接插入排序的比较次数和移动次数分别为：%d,%d\n",p[0],q[0]);break;case 2:for(i=0;i<100;i++)L[i+1]=100 + rand() % (1000 - 100) ;ShellSort(L,100);printf("2.希尔排序的比较次数和移动次数分别为：%d,%d\n",p[1],q[1]);break;case 3:for(i=0;i<100;i++)L[i+1]=100 + rand() % (1000 - 100) ;buddlesort(L,100);printf("3.冒泡排序的比较次数和移动次数分别为：%d,%d\n",p[2],q[2]);break;case 4:for(i=0;i<100;i++)L[i+1]=100 + rand() % (1000 - 100) ;QuikSort(L,100);printf("4.快速排序的比较次数和移动次数分别为：%d,%d\n",p[3],q[3]);break;case 5:for(i=0;i<100;i++)L[i+1]=100 + rand() % (1000 - 100) ;HeapSort(L,100);printf("5.堆排序的比较次数和移动次数分别为：%d,%d\n",p[4],q[4]);break;case 6:for(i=0;i<100;i++)L[i+1]=100 + rand() % (1000 - 100) ;MergeSort(L,100);printf("6.归并排序的比较次数和移动次数分别为：%d,%d\n",p[5],q[5]);break;case 7:printf("已退出！");exit(0);break;default:printf("\nInput error!"); }}return 0; }四实验分析及问题思考1.分析和总结各种内部排序方法的优缺点；直接插入排序优点:移动元素次数少，只需要一个辅助空间缺点：效率不高冒泡排序优点：比较简单，空间复杂度较低，是稳定的缺点：时间复杂度太高，效率不好简单选择排序优点：所需移动记录的次数比较少，最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录缺点：简单选择排序是不稳定排序快速排序优点：极快，数据移动少缺点：不稳定希尔排序优点：快，数据移动少缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取归并排序优点：归并排序是稳定的排序方法缺点：需要一个与原始序列同样大小的辅助序列堆排序优点：在最坏情况下时间复杂度也为O(nlogn)，并且它仅需一个记录大小供交换用的辅助存储空间缺点：记录数较少时不提倡使用基数排序优点：基数排序法的效率高于其它的比较性排序法，稳定的排序快速排序算法设计(10003809386j) 实验自评检查表实验内容自评结果（在对应格内打√）不熟练一般比较熟练熟练简单排序方法直接插入排序√起泡排序√简单选择排序√先进排序方法快速排序√希尔排序√归并排序√实验的心得体会通过这次实验，我更加清楚地了解了各个算法的实现过程，学会应用随机数表，而且自己体会到了各个算法的时间复杂度。