内部排序算法的实现与比较
内部排序实验报告总结
内部排序实验报告总结内部排序实验报告总结一、引言内部排序是指对一个存储在计算机内存中的数据集合进行排序的过程。
在本次实验中，我们对常见的内部排序算法进行了实验比较，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。
通过比较这些算法的执行时间和空间复杂度，我们可以评估它们在不同数据集上的性能。
二、实验目的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. 插入排序：插入排序是一种简单直观且稳定的内部排序算法，它将待排序的数据分为已排序和未排序两部分，每次从未排序部分取出一个元素，插入到已排序部分的适当位置。
数据结构-第十章-内部排序
0
1
2
3
4
5
6
7
8
i=5
MAXINT 49 2 3
MAXINT 49 6 3 MAXINT 49 6 3 MAXINT 49 6 8
38 1
38 1 38 1 38 1
65 97 5 0
65 5 65 5 65 5 97 0 97 0 97 0
76 4
76 4 76 4 76 4
13
27
49
i=6
最坏情况下,待排记录按关键字非递增有序 排列（逆序）时，第 i 趟时第 i＋1 个对象 必须与前面 i 个对象都做排序码比较, 并且 每做1次比较就要做1次数据移动。总比较 次 数 为 (n+2)(n-1)/2 次 ， 总 移 动 次 数 为 (n+4)(n-1)/2。 在平均情况下的排序码比较次数和对象移 动次数约为 n2/4。因此，直接插入排序的 时间复杂度为 O(n2)。 直接插入排序是一种稳定的排序方法。
折半插入排序 (Binary Insertsort)
基本思想 既然每个要插入记录之前的纪录 已经按关键字有序排列，在查找插入位 臵时就没有必要逐个关键字比较，可以 使用折半查找来实现。由此进行的插入 排序称之为折半插入排序。
折半插入排序的算法
void BInsertSort (SqList &L){ for (i=2;i<=L.length;++i){ L.r[0]=L.r[i]; low=1;high=i-1; //查找范围由1到i-1 while(low<=high){ m=(low+high)/2; if LT(L.r[0].key,L.r[m].key) high=m-1; else low=m+1; }//while 折半查找 for (j=i-1;j>=high+1;--j) L.r[j+1]=L.r[j]; //折半查找结束后high+1位臵即为插入位臵 L.r[high+1]=L.r[0]; }//for }//BInsertSort
数据结构课程设计—内部排序算法比较
数据结构课程设计—内部排序算法比较在计算机科学领域中，数据的排序是一项非常基础且重要的操作。
内部排序算法作为其中的关键部分，对于提高程序的运行效率和数据处理能力起着至关重要的作用。
本次课程设计将对几种常见的内部排序算法进行比较和分析，包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
冒泡排序是一种简单直观的排序算法。
它通过重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
这种算法的优点是易于理解和实现，但其效率较低，在处理大规模数据时性能不佳。
因为它在最坏情况下的时间复杂度为 O(n²)，平均时间复杂度也为O(n²)。
插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个序列有序。
插入排序在数据量较小时表现较好，其平均时间复杂度和最坏情况时间复杂度也都是 O(n²)，但在某些情况下，它的性能可能会优于冒泡排序。
选择排序则是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。
以此类推，直到全部待排序的数据元素排完。
选择排序的时间复杂度同样为O(n²)，但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。
快速排序是一种分治的排序算法。
它首先选择一个基准元素，将数列分成两部分，一部分的元素都比基准小，另一部分的元素都比基准大，然后对这两部分分别进行快速排序。
快速排序在平均情况下的时间复杂度为 O(nlogn)，最坏情况下的时间复杂度为 O(n²)。
然而，在实际应用中，快速排序通常表现出色，是一种非常高效的排序算法。
归并排序也是一种分治算法，它将待排序序列分成若干个子序列，每个子序列有序，然后将子序列合并成一个有序序列。
第10章-内部排序PPT课件
-
算法效率
时间复杂度
待排序记录按关键字从小到大排列(正序)
n
比较次数: 1 n 1 i2
移动次数: 0
待排序记录按关键字从大到小排列(逆序)
比较次数:
n i (n2)(n1)
i2
2
移动次数:
n
(n4)(n1)
(i1)
i2
2
待排序记录随机，取平均值
比较次数: n 2
4
移动次数: n 2
4
总的时间复杂度:T(n)=O(n2)
空间复杂度：S(n)=O(1)
-
3. 折半插入排序
排序过程：用折半查找方法确定插入位置。 举例：
i=1: (38) (49) 38 65 97 76 13 27 49
5 R’={5}
R={10,2}
2 R’={2,5}
R={2}
10 R’={2,5,10}
R={ }
2 R’={2,2,5,10}
-
2. 直接插入排序
排序过程：整个排序过程为n-1趟插入
将序列中第1个记录看成是一个有序子序列 从第2个记录开始，逐个进行插入，直至整个序列有序
R1 R2 …… Rn
内部排序适用于记录个数不很多的小文件； 外部排序则适用于记录个数太多，不能一次 将其全部放入内存的大文件
排序依据策略
插入排序：直接插入排序, 折半插入排序, 希尔排序 交换排序：冒泡排序, 快速排序 选择排序：简单选择排序, 堆排序 归并排序：2-路归并排序 基数排序
各种内排序算法的实验心得
各种内排序算法的实验心得
1. 冒泡排序
冒泡排序是一种简单的排序算法，但它的时间复杂度为O(n^2)，在处理大量数据时效率很低。
在实验过程中，我发现当数据量较小时，冒泡排序的效率其实还是不错的，但一旦数据量增加，它的效率就明显下降了。
2. 插入排序
插入排序的时间复杂度也是O(n^2)，类似于冒泡排序。
但是插入排序比冒泡排序更快，因为它每次只需要比较一个元素。
在实验中，我发现当数据量比较小且有序时，插入排序的效率非常高，但如果数据量较大且随机分布，效率就会明显下降。
3. 选择排序
选择排序同样是时间复杂度为O(n^2)的算法，但是它比冒泡排序和插入排序都要快。
在实验中，我发现当数据量很大时，选择排序的效率比较稳定，但是当数据量比较小时，它的效率反而不如插入排序。
4. 快速排序
快速排序是一种常用的排序算法，它的时间复杂度为O(nlogn)，比冒泡、插入和选择排序都要快。
在实验中，我发现当数据量比较大时，快速排序的效率非常高，但是当数据量比较小时，它的效率反而不如插入排序和选择排序。
5. 归并排序
归并排序与快速排序的时间复杂度相同，都是O(nlogn)。
但是归并排序比快速排序更稳定，因为它的最坏时间复杂度是O(nlogn)。
在实验中，我发现当数据量比较大时，归并排序的效率非常高，而且在处理大量数据时表现优异。
6. 基数排序
基数排序是一种特殊的排序算法，它适用于数据量较大且每个元素长度相同的情况。
在实验中，我发现基数排序的效率非常高，尤其是对于大量数据的排序。
但需要注意的是，基数排序无法处理字符串等非数字类型的数据。
内部排序实验报告
内部排序实验报告内部排序实验报告一、引言内部排序是计算机科学中的重要概念，它指的是对一个数据集合进行排序的过程。
在计算机科学中，排序算法是一种基本的算法，它对于提高数据处理效率和优化算法性能有着重要的作用。
本实验旨在通过实际操作和对比分析，探究不同内部排序算法的性能差异。
二、实验目的1. 了解内部排序的基本概念和常用算法；2. 掌握不同内部排序算法的实现方法；3. 比较不同内部排序算法的时间复杂度和空间复杂度；4. 分析实验结果，总结不同算法的优缺点。
三、实验过程1. 实验环境搭建在进行实验之前，我们需要搭建适当的实验环境。
选择一种编程语言，并准备好相应的开发环境。
2. 实验数据准备为了进行排序算法的测试，我们需要准备一组测试数据。
可以选择不同规模的数据集，包括有序、无序和部分有序等情况。
3. 实验算法实现选择几种常用的内部排序算法，如冒泡排序、插入排序、选择排序、快速排序和归并排序等。
分别实现这些算法，并确保其正确性。
4. 实验性能测试使用不同规模的测试数据对算法进行性能测试。
记录每个算法的运行时间和所占用的内存空间。
5. 实验结果分析根据实验数据和测试结果，对比分析不同算法的性能差异。
针对时间复杂度和空间复杂度，给出相应的分析和解释。
四、实验结果与分析经过实验测试，我们得到了不同内部排序算法的运行时间和内存占用情况。
下面对实验结果进行分析和解释。
1. 时间复杂度分析通过实验数据，我们可以观察到不同算法的运行时间随着数据规模的增加而增加。
快速排序和归并排序在大规模数据集上表现出色，时间复杂度为O(nlogn)。
而冒泡排序和选择排序的时间复杂度为O(n^2)，在大规模数据集上性能较差。
2. 空间复杂度分析在内部排序中，空间复杂度是指算法执行过程中所需的额外内存空间。
插入排序和冒泡排序是原地排序算法，它们的空间复杂度为O(1)。
而归并排序和快速排序需要额外的空间来存储中间结果，空间复杂度为O(n)。
用Java实现常见的8种内部排序算法
⽤Java实现常见的8种内部排序算法⼀、插⼊类排序插⼊类排序就是在⼀个有序的序列中，插⼊⼀个新的关键字。
从⽽达到新的有序序列。
插⼊排序⼀般有直接插⼊排序、折半插⼊排序和希尔排序。
1. 插⼊排序1.1 直接插⼊排序/*** 直接⽐较，将⼤元素向后移来移动数组*/public static void InsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i]; //temp ⽤于存储元素，防⽌后⾯移动数组被前⼀个元素覆盖int j;for(j = i; j > 0 && temp < A[j-1]; j--) { //如果 temp ⽐前⼀个元素⼩，则移动数组A[j] = A[j-1];}A[j] = temp; //如果 temp ⽐前⼀个元素⼤，遍历下⼀个元素}}/*** 这⾥是通过类似于冒泡交换的⽅式来找到插⼊元素的最佳位置。
⽽传统的是直接⽐较，移动数组元素并最后找到合适的位置*/public static void InsertSort2(int[] A) { //A[] 是给定的待排数组for(int i = 0; i < A.length - 1; i++) { //遍历数组for(int j = i + 1; j > 0; j--) { //在有序的序列中插⼊新的关键字if(A[j] < A[j-1]) { //这⾥直接使⽤交换来移动元素int temp = A[j];A[j] = A[j-1];A[j-1] = temp;}}}}/*** 时间复杂度：两个 for 循环 O(n^2)* 空间复杂度：占⽤⼀个数组⼤⼩，属于常量，所以是 O(1)*/1.2 折半插⼊排序/** 从直接插⼊排序的主要流程是：1.遍历数组确定新关键字 2.在有序序列中寻找插⼊关键字的位置* 考虑到数组线性表的特性，采⽤⼆分法可以快速寻找到插⼊关键字的位置，提⾼整体排序时间*/public static void BInsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i];//⼆分法查找int low = 0;int high = i - 1;int mid;while(low <= high) {mid = (high + low)/2;if (A[mid] > temp) {high = mid - 1;} else {low = mid + 1;}}//向后移动插⼊关键字位置后的元素for(int j = i - 1; j >= high + 1; j--) {A[j + 1] = A[j];}//将元素插⼊到寻找到的位置A[high + 1] = temp;}}2. 希尔排序希尔排序⼜称缩⼩增量排序，其本质还是插⼊排序，只不过是将待排序列按某种规则分成⼏个⼦序列，然后如同前⾯的插⼊排序⼀般对这些⼦序列进⾏排序。
算法21--内部排序--归并排序
实现这种递归调用的关键是为过程建立递归调用工作栈。通 常，在一个过程中调用另一过程时，系统需在运行被调用过 程之前先完成3件事:
（1）将所有实参指针，返回地址等信息传递给被调用过程； （2）为被调用过程的局部变量分配存储区； （3）将控制转移到被调用过程的入口。 在从被调用过程返回调用过程时，系统也相应地要完成3件事： （1）保存被调用过程的计算结果； （2）释放分配给被调用过程的数据区； （3）依照被凋用过程保存的返回地址将控制转移到调用过程.
实际的意义：可以把一个长度为n 的无序序列看成 是 n 个长度为 1 的有序子序列 ，首先做两两归 并，得到 n/2 个长度为 2 的子序列；再做两两 归并，…，如此重复，直到最后得到一个长度为 n
的有序序列。
归并排序
初始序列
[49] [38] [65] [97 [76] [13] [27]
第一步 第二步
T(1)=1 T(n)=kT(n/m)+f(n)
2019/10/20
归并排序时间复杂性分析
• 合并趟数： log2n • 每趟进行比较的代价 n • 总的代价为 T(n) = O ( nlog2n ) • 在一般情况下：
c
n=1
T(n) =
T( n/2 ) + T( n/2 ) + cn n>1
优缺点：Ω的这个定义的优点是与O的定义对称，缺点 是当 f(N) 对自然数的不同无穷子集有不同的表达式， 且有不同的阶时，未能很好地刻画出 f(N)的下界。
2019/10/20
f(n) cg(n)
n0
n
2019/10/20
代入法解递归方程
方法的关键步骤在于预先对解答作出推测，然后用 数学归纳法证明推测的正确性。
数据结构(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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四：内部排序算法的实现与比较
一、问题描述
1．实验题目：在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大致执行时间。
试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
2．基本要求：（1）对常用的内部排序算法进行比较：直接插入排序、简单选择排序、冒泡排序、快速排序、希尔排序、归并排序。
（2利用随机函数产生N（N=30000）个随机整数，作为输入数据作比较；比较的指标为关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）。
（3)对结果作出简要分析。
3．测试数据：随机函数产生。
二、需求分析
1．程序所能达到的基本可能：通过随机数据产生N个随机数，作为输入数据作比较；对常用的内部排序算法：直接插入排序、简单选择排序、冒泡排序、快速排序、希尔排序、归并排序进行比较：比较的指标为关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）。
最后结果输出各种排序算法的关键字参加的比较次数和关键字的移动次数，并按从小到大排列。
2．输入的形式及输入值范围：随机函数产生的N（N=30000）个随机整数。
3．输出的形式：输出各种排序算法的关键字参加的比较次数和关键字的移动次数。
并按从小到大排列。
4．测试数据要求：随机函数产生的N（N=30000）个随机整数。
三、概要设计
1. 所用到得数据结构及其ADT
为了实现上述功能，应以一维数组表示集合数据类型。
int s[N];
int compare[6]={0},move[6]={0},D[N]={0},RS[N]={0};
基本操作：
数组赋值：
for(i=1;i<N;i++)
{
s[i]=rand()%100;
printf("%d\t",s[i]);
}
void copys(int S[],int RS[],int n)
N
实现每个操作的伪码，重点语句加注释
1）void copys(int S[],int RS[],int n)择法,2.冒泡法,3.插入法,4.快速法, 5.希尔排序法,6.归并排序法，7.输出比较信息，8.退出\n");
scanf(" %d",&j);
switch(j)
{
case 1:
SelectSort(RS,N-1);
break;
case 2:
BubbleSort(RS,N-1);
break;
case 3:
InsertSort(RS,N-1);
break;
case 4:
QuickSortprint(RS,N-1);
break;
case 5:
Shellsort(RS,N-1);
break;
case 6:
MSort(RS,1,N-1);
printf("归并排序后的结果：");
for(i=1;i<N;i++)
printf("%d\t",D[i]);
printf("\n");
printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[5],move[5]);
printf("\n");
break;
case 7:
SelectSort(compare,5);
SelectSort(move,5);
printf("关键字参加的比较次数:\n");
for(i=1;i<=5;i++)
printf("%d\t",compare[i]);
printf("\n");
printf("关键字的移动次数：\n");
for(i=1;i<=5;i++)
printf("%d\t",move[i]);
printf("\n");
break;
case 8:
printf("Current local time and date:%s",asctime(timeinfo));
exit(0);
break;
}
}while(1);
}
五、调试分析
1. 设计与调试过程中遇到的问题分析、体会
调试过程：由于本次程序设计的数据和模块比较多，所以采用分块调试的方法，在编写完一个内部排序算法后，为了验证是否排序成功以及所输出的关键字比较次数和移动次数是否正确，采用先定义一个需要排序9个数字的数组，S[10]={0，1，2，3，4，5，6，7，8，9}和S[10]={0，9，8，7，6，5，4，3，2，1},用这两个数组检验程序的正确性与否。
调试步骤，程序及相关结果如下：
1）直接选择排序：
#include <>
#include <>
#include <>
void SelectSort(int RS[],int n)
择法 ,2.冒泡法 ,3.插入法 ,4.快速法 , 5.希尔排序法 ,6.归并排序法，7.输出比较信息，8.退出\n");
scanf(" %d",&j);
switch(j)
{
case 1:
SelectSort(RS,N-1);
break;
case 2:
BubbleSort(RS,N-1);
break;
case 3:
InsertSort(RS,N-1);
break;
case 4:
QuickSortprint(RS,N-1);
break;
case 5:
Shellsort(RS,N-1);
break;
case 6:
MSort(RS,1,N-1);
printf("归并排序后的结果：");
for(i=1;i<N;i++)
printf("%d\t",D[i]);
printf("\n");
printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[5],move[5]);
printf("\n");
break;
case 7:
SelectSort(compare,5);
SelectSort(move,5);
printf("关键字参加的比较次数:\n");
for(i=1;i<=5;i++)
printf("%d\t",compare[i]);
printf("\n");
printf("关键字的移动次数：\n");
for(i=1;i<=5;i++)
printf("%d\t",move[i]);
printf("\n");
break;
case 8:
printf("Current local time and date:%s",asctime(timeinfo));
exit(0);
break; }
}while(1);
]
九、实验收获和感想。