《数据结构》课程设计报告-排序综合模板
数据结构课程设计快速排序和归并排序
XX学院信息科学与工程系课程设计说明书课程名称:数据结构课程代码:题目: 快速排序与归并排序年级/专业/班:学生姓名: 奉XX学号: 1440000000指导教师: 易开题时间: 2015 年 12 月 30 日完成时间: 2016 年 1 月 10 日目录摘要 (1)一、引言 (3)二、设计目的与任务 (3)1、课程设计目的 (3)2、课程设计的任务 (3)三、设计方案 (3)1、需求分析 (3)2、概要设计 (4)3、详细设计 (5)4、程序清单 (13)四、调试分析与体会 (19)五、运行结果 (20)六、结论 (24)七、致谢 (24)八、参考文献 (25)摘要数据结构课程设计，列举了数据结构课程设计实例，通过综合训练，能够培养学生实际分析问题、解决问题、编程和动手操作等多方面的能力，最终目的是帮助学生系统地掌握数据结构的基本内容，并运用所学的数据结构知识去解决实际问题。
其中内容包括数组、链接表、栈和队列、递归、树与森林、图、堆与优先级队列、集合与搜索结构、排序、索引与散列结构等关键字：数据结构；分析；掌握AbstractData structure course design, lists the data structure course design as an example, through the comprehensive training, to cultivate students' practical analysis and solve problems in many aspects, programming, and hands-on ability, the ultimate goal is to help students to systematically master the basic content of data structure, and using the data structure of knowledge to solve practical problems. Content including array, linked list, stack and queue, recursion, tree and forest, graph, heap and priority queue, the structure of the collection and search, sorting, indexing and hashing structure, etcKeywords:data structure；Analysis；master《数据结构》课程设计----快速排序与归并排序一、引言二、将一组数据运用快速排序与归并排序进行排序，要求使用递归与非递归方法三、本次课程设运用到了数组、链接表、栈、递归、排序等结构。
排序综合课程设计
.大连科技学院数据结构课程设计题目排序综合学生专业班级指导教师职称副教授所在单位信息科学系软件教研室教学部主任完成日期2013 年1月11 日.课程设计报告单学号专业班级网络工程11-1考核项目评分备注平时工作态度及遵守纪律情况1（10 分）掌握基本理论、关键知识、基本技能的程度和2阅读参考资料的水平（10 分）独立工作能力、综合运用所学知识分析和解决3问题能力及实际工作能力提高的程度（20 分）完成课程设计说明书及软件的情况与水平（小组分工情况、规性、整洁清楚、叙述完整性、4思路清晰程度、工作量及实际运行情况和创新性）（60 分）总评成绩综合评定：（优、良、中、及格、不及格）指导教师签字：2013年1月11日数据结构课程设计任务书一、任务及要求：1.设计（研究）任务和要求研究容：排序综合任务和要求：（1）学习数据结构基础知识，掌握数据结构典型的算法的使用。
（2）对指导教师下达的题目进行系统分析。
（3）根据分析结果完成系统设计。
（4）编程：在计算机上实现题目的代码实现。
（5）完成对该系统的测试和调试。
（6）提交课程设计报告。
要求完成课程设计报告3000 字以上 (约二十页 )。
完成若干综合性程序设计题目，综合设计题目的语句行数的和在100 行语句以上。
2.原始依据结合数据结构课程中的基本理论和基本算法，正确分析出数据的逻辑结构，合理地选择相应的存储结构，并能设计出解决问题的有效算法。
提高程序设计和调试能力。
学生通过上机实习，验证自己设计的算法的正确性。
学会有效利用基本调试方法，迅速找出程序代码中的错误并且修改。
3.参考题目：二、工作量2 周（ 10 个工作日）时间三、计划安排第 1 个工作日：查找相关资料、书籍，阅读示例文档，选择题目。
第 2 个工作日－第 3 个工作日：设计程序结构、模块图。
第 4 个工作日－第 9 个工作日：完成程序的编码，并且自己调试、测试。
穿插进行课程设计报告的撰写。
第 10 个工作日：上交课程设计报告，由教师检查软件测试效果、检查课程设计报告，给出学生成绩。
数据结构课程设报告—各种排序算法的比较
数据结构课程设计报告几种排序算法的演示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.引言............................................................................................................................ 错误！未定义书签。
2.需求分析.................................................................................................................... 错误！未定义书签。
3.详细设计.................................................................................................................... 错误！未定义书签。
3.1 直接插入排序................................................................................................ 错误！未定义书签。
3.2折半排序......................................................................................................... 错误！未定义书签。
3.3 希尔排序........................................................................................................ 错误！未定义书签。
3.4简单选择排序................................................................................................. 错误！未定义书签。
《数据结构》课程设计报告
《数据结构》课程设计报告一、课程目标《数据结构》课程旨在帮助学生掌握计算机科学中数据结构的基本概念、原理及实现方法，培养其运用数据结构解决实际问题的能力。
本课程目标如下：1. 知识目标：（1）理解数据结构的基本概念，包括线性表、栈、队列、串、数组、树、图等；（2）掌握各类数据结构的存储表示和实现方法；（3）了解常见算法的时间复杂度和空间复杂度分析；（4）掌握排序和查找算法的基本原理和实现。
2. 技能目标：（1）能够运用所学数据结构解决实际问题，如实现字符串匹配、图的遍历等；（2）具备分析算法性能的能力，能够根据实际问题选择合适的算法和数据结构；（3）具备一定的编程能力，能够用编程语言实现各类数据结构和算法。
3. 情感态度价值观目标：（1）培养学生对计算机科学的兴趣，激发其探索精神；（2）培养学生团队合作意识，提高沟通与协作能力；（3）培养学生面对问题勇于挑战、善于分析、解决问题的能力；（4）引导学生认识到数据结构在计算机科学中的重要地位，激发其学习后续课程的兴趣。
本课程针对高年级学生，课程性质为专业核心课。
结合学生特点，课程目标注重理论与实践相结合，强调培养学生的实际操作能力和解决问题的能力。
在教学过程中，教师需关注学生的个体差异，因材施教，确保课程目标的达成。
通过本课程的学习，学生将具备扎实的数据结构基础，为后续相关课程学习和职业发展奠定基础。
二、教学内容根据课程目标，教学内容主要包括以下几部分：1. 数据结构基本概念：线性表、栈、队列、串、数组、树、图等；教学大纲：第1章 数据结构概述，第2章 线性表，第3章 栈和队列，第4章 串。
2. 数据结构的存储表示和实现方法：教学大纲：第5章 数组和广义表，第6章 树和二叉树，第7章 图。
3. 常见算法的时间复杂度和空间复杂度分析：教学大纲：第8章 算法分析基础。
4. 排序和查找算法：教学大纲：第9章 排序，第10章 查找。
教学内容安排和进度如下：1. 第1-4章，共计12课时，了解基本概念，学会使用线性表、栈、队列等解决简单问题；2. 第5-7章，共计18课时，学习数据结构的存储表示和实现方法，掌握树、图等复杂结构；3. 第8章，共计6课时，学习算法分析基础，能对常见算法进行时间复杂度和空间复杂度分析；4. 第9-10章，共计12课时，学习排序和查找算法，掌握各类算法的实现和应用。
数据结构排序算法实验报告
移动次数 735219 247071 2997 7296 22836 4233
乱序 2 比较次数 496238 255211 499500 12927 14868 3788
移动次数 762636 256210 2997 7449 22 242989 499500 12951 14845 3818
希尔排序：void ShellSort(Element *list,int n) 记录移动和比较次数的变量：int countlm=0,countlc=0 希尔排序是将文件分组，然后进行插入排序，因此 countlm,countlc 的增量方式与直 接插入排序相同。
堆排序：void HeapSort(Element *list,const int n) 记录移动和比较次数的变量：int countrm=0,countrc=0 首先进行初始建堆 void Restore(Element *tree,const int root,const int n)，将待排序文 件保存在完全二叉树中，从最后一个非叶节点开始，将其孩子结点与其进行比较， 每比较一次 countrc 加 1，若孩子结点比其大，二者交换 countrm 加 3，直到任意结 点的关键词大于等于它的两个孩子结点。在进行堆排序，将根节点与最后一个叶节 点交换，countrm 加 3，再进行初始建堆，直至完全排好序。
数据结构实验报告(C语言)顺序表__排序
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }
数据结构课程设报告—各种排序算法的比较
数据结构课程设计报告几种排序算法的演示一、需求分析：1、运行环境：Microsoft Visual Studio 20052、程序实现功能：通过用户键入的数据，经过程序进行排序，最后给予数据由小到大的输出。
排序的方式包含教材中所介绍的几种常用的排序方式：直接插入排序、折半插入排序、冒泡排序、快速排序、选择排序、堆排序、归并排序。
每种排序过程中均显示每一趟排序的细节。
3、程序的输入：输入所需排序方式的序号。
输入排序的数据的个数。
输入具体的数据元素。
4、程序的输出：输出排序每一趟的结果，及最后排序结果二、设计说明：1、算法设计思想：a交换排序（冒泡排序、快速排序）交换排序的基本思想是：对排序表中的数据元素按关键字进行两两比较，如果发生逆序（即排列顺序与排序后的次序正好相反），则两者交换位置，直到所有数据元素都排好序为止。
b插入排序（直接插入排序、折半插入排序）插入排序的基本思想是：每一次设法把一个数据元素插入到已经排序的部分序列的合适位置，使得插入后的序列仍然是有序的。
开始时建立一个初始的有序序列，它只包含一个数据元素。
然后，从这个初始序列出发不断插入数据元素，直到最后一个数据元素插到有序序列后，整个排序工作就完成了。
c选择排序（简单选择排序、堆排序）选择排序的基本思想是：第一趟在有n个数据元素的排序表中选出关键字最小的数据元素，然后在剩下的n-1个数据元素中再选出关键字最小（整个数据表中次小）的数据元素，依次重复，每一趟（例如第i趟，i=1，…，n-1）总是在当前剩下的n-i+1个待排序数据元素中选出关键字最小的数据元素，作为有序数据元素序列的第i个数据元素。
等到第n-1趟选择结束，待排序数据元素仅剩下一个时就不用再选了，按选出的先后次序所得到的数据元素序列即为有序序列，排序即告完成。
d归并排序（两路归并排序）两路归并排序的基本思想是：假设初始排序表有n个数据元素，首先把它看成是长度为1的首尾相接的n个有序子表（以后称它们为归并项），先做两两归并，得n/2上取整个长度为2的归并项（如果n为奇数，则最后一个归并项的长度为1）；再做两两归并，……，如此重复，最后得到一个长度为n的有序序列。
排序(数据结构课程设计)
《数据结构》课程设计实验报告题目：排序（必做题）姓名：学号：指导老师：时间：2015.09.03目录一、设计内容和要求 (3)二、算法思想描述 (3)1. 希尔排序 (3)2. 快速排序 (3)3. 堆排序 (4)4. 归并排序 (7)5. 性能分析 (8)三、程序结构 (10)四、结果与分析 (10)五、收获与体会 (12)一、设计内容和要求设计内容：排序算法的实现与比较要求：编程希望实现希尔、快速、堆排序、归并排序算法。
要求随机产生10000个数据存入数据文件，然后读数据文件，分别采用不同的排序方法进行排序，将结果存入文件中。
二、算法思想描述1.希尔排序先将整个待排序记录序列分割成若干个子序列，在在序列内分别进行直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。
图解：2.快速排序首先选一个枢轴k（即比较的基准），通过一趟排序将待排序记录分割成独立的两部分，前一部分记录的关键码均小于或等于枢轴k，后一部分记录的关键码均大于或等于枢轴k，然后分别对这两部分重复上述方法，直到整个序列有序。
经过一次划分后枢轴k再对1、2区分别再进行快速排序3.堆排序筛选：假设当前要筛选结点的编号为k，堆中最后一个结点的编号为m，并且结点k的左右子树均是堆（即r[k+1] ~ r[m]满足堆的条件），则筛选算法用伪代码可描述为：图解：堆排序：堆排序的基本思想是：首先将待排序的记录序列构造成一个堆，此时，选出了堆中所有记录的最大者即堆顶记录，然后将它从堆中移走（通常将堆顶记录和堆中最后一个记录交换），并将剩余的记录再调整成堆，这样又找出了次大的记录，以此类推，直到堆中只有一个记录为止。
（1）用大根堆排序的基本思想①先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区②再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys ≤R[n].key③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。
数据结构课程设计排序实验报告
《数据结构》课程设计报告专业班级姓名学号指导教师起止时间课程设计：排序综合一、任务描述利用随机函数产生n个随机整数（20000以上），对这些数进行多种方法进行排序。
（1）至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。
并把排序后的结果保存在不同的文件中。
（2）统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。
要求：根据以上任务说明，设计程序完成功能。
二、问题分析1、功能分析分析设计课题的要求，要求编程实现以下功能：（1）随机生成N个整数，存放到线性表中；（2）起泡排序并计算所需时间；（3）简单选择排序并计算时间；（4）希尔排序并计算时间；（5）直接插入排序并计算所需时间；（6）时间效率比较。
2、数据对象分析存储数据的线性表应为顺序存储。
三、数据结构设计使用顺序表实现，有关定义如下：typedef int Status;typedef int KeyType ; 直接插入排序0. 退出系统（二）程序模块结构由课题要求可将程序划分为以下几个模块（即实现程序功能所需的函数）：主控菜单项选择函数menu()创建排序表函数InitList_Sq()起泡排序函数Bubble_sort()简单选择排序函数SelectSort()希尔排序函数ShellSort();对顺序表L进行直接插入排序函数Insertsort()（三）函数调用关系程序的主要结构（函数调用关系）如下图所示。
其中main()是主函数，它负责调用各函数。
进行调用菜单函数menu()，根据选择项0~4调用相应的函数。
main()函数使for循环实现重复选择。
其循环结构如下：for (;;){long start,end;switch(menu()){case 1:printf("* 起泡排序*\n");start=clock();Bubble_sort(L);end=clock();printf("%d ms\n",end-start);fp=fopen("D: 起泡排序.txt","w");if(fp==NULL)xt","w");if(fp==NULL)xt","w");if(fp==NULL)Ney,[j].key)){flag=1; 共通过n－1趟,得到一个按排序码从小到大排列的有序序列流程图：NN代码描述：void SelectSort(SqList &L){ ] 中选择key最小的记录int k=i;for(int j=i+1;j<= ; j++)if ( LT[j].key,[k].key)) k=j;if(k!=i){x=[i];[i]=[j];[j]=x;}}} ey , [i-dk].key )){[0]= [i];int j;for(j=i-dk;(j>0)&&(LT [0].key , [j].key ));j-=dk)[j+dk]= [j];[j+dk]= [0];}}}void ShellSort(SqList &L,int dlta[],int t)NNey,[i-1].key)) ey,[j].key);j--){[j+1]=[j];ey的元素[j+1]=[0]; //将暂存在r[0]中的记录插入到正确位置}// printf("%d ",[i]);}算法的时间复杂度分析：O（n2）五、测试数据和结果1、测试数据随机产生30000个数2、测试结果本程序在VC++环境下实现，下面是对以上测试数据的运行结果。
数据结构课程设计(排序)
数据结构课程设计[排序综合]学生姓名：学生学号：院（系）：计算机科学与信息技术学院年级专业：指导教师：付丹丹二〇一一年十二月2- 3 - 3摘要数据结构是由数据元素依据某种逻辑联系组织起来的。
对数据元素间逻辑关系的描述称为数据的逻辑结构；数据必须在计算机内存储，数据的存储结构是数据结构的实现形式，是其在计算机内的表示；此外讨论一个数据结构必须同时讨论在该类数据上执行的运算才有意义。
在许多类型的程序的设计中，数据结构的选择是一个基本的设计考虑因素。
许多大型系统的构造经验表明，系统实现的困难程度和系统构造的质量都严重的依赖于是否选择了最优的数据结构。
许多时候，确定了数据结构后，算法就容易得到了。
有些时候事情也会反过来，我们根据特定算法来选择数据结构与之适应。
不论哪种情况，选择合适的数据结构都是非常重要的。
排序算法是数据结构学科经典的内容，其中内部排序现有的算法有很多种，其中包含冒泡排序，直接插入排序，简单选择排序，希尔排序，快速排序，堆排序等，各有其特点。
对排序算法比较的分析可以遵循若干种不同的准则，通常以排序过程所需要的算法步数作为度量，有时也以排序过程中所作的键比较次数作为度量。
特别是当作一次键比较需要较长时间，例如，当键是较长的字符串时，常以键比较次数作为排序算法计算时间复杂性的度量。
当排序时需要移动记录，且记录都很大时，还应该考虑记录的移动次数。
究竟采用哪种度量方法比较合适要根据具体情况而定。
在下面的讨论中我们主要考虑用比较的次数作为复杂性的度量。
41概要1.1设计目的数据结构与算法课程主要是研究非数值计算的程序设计问题中所出现的计算机操作对象以及它们之间的关系和操作的学科。
数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。
学习数据结构与算法是为了将实际问题中涉及的对象在计算机中表示出来并对它们进行处理。
综合排序-数据结构课程设计
《数据结构》课程设计排序目录1.课程设计的目的 (3)2.需求分析 (3)3.概要设计 (3)4.详细设计 (4)5.调试分析 (8)6.用户手册 (9)7.测试结果 (10)8.程序清单 (10)9.小结 (14)10.参考文献 (14)1.课程设计的目的1)、对数据结构基本理论和存储结构及算法设计有更加深入的理解；2)、掌握多种排序算法，尤其是奇偶排序算法（课堂上未学到的）3)、了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力;4)、初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;2.需求分析利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。
要求：至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、2-路插入排序、希尔排序、起泡排序、改进的冒泡排序、快速排序、选择排序、堆排序、归并排序、三部排序、计数排序、鸽巢排序、鸡尾酒排序、地精排序、奇偶排序、梳排序、耐心排序——标红的至少选择一种）。
并把排序后的结果保存在不同的文件中。
采用不同的函数来实现不同的排序算法，并需要一个菜单选择函数来实现排序功能的选择，并按照不同的排序算法将排好的数按不同的排序文件名存储在桌面上。
3.概要设计流程图如下所示:用srand((int)time(NULL))来提供随机数种子void menu（）菜单选择函数void maopao（int []）冒泡排序void xuanze(int []) 选择排序void charu(int []) 插入排序void jiou(int []) 奇偶排序void display(int []) //打印排序号的数组4.详细设计（1）、void menu() //菜单选择{printf("***************** 欢迎使用排序系统******************\n\n");printf("** 1.冒泡排序***\n");printf("** 2.选择排序***\n");printf("** 3.插入排序***\n");printf("** 4.奇偶排序***\n ");printf("***************** 0.退出系统***********************\n\n");printf("请输入菜单选项\n");}（2）、void maopao(int a[N]) //冒泡排序{int i,j,temp;for (i=0;i<N-1;i++){for (j=N-1;j>i;j--) //比较,找出本趟最小关键字的记录if (a[j]<a[j-1]){temp=a[j]; //进行交换,将最小关键字记录前移a[j]=a[j-1];a[j-1]=temp;}}FILE *fp;if((fp=fopen("冒泡排序结果.txt","w"))==NULL){printf("文件打开失败\n");return;}for(i=0;i<N;i++)fprintf(fp,"%d ",a[i]);fclose(fp);}（3）、void xuanze(int a[N]) //选择排序{int i,j,k;for(i=0;i<N-1;i++){k=i;for(j=i+1;j<N;j++)if(a[j]<a[k])k=j;if(k!=i){int temp;temp=a[k];a[k]=a[i];a[i]=temp;}}FILE *fp;if((fp=fopen("选择排序结果.txt","w"))==NULL) {printf("文件打开失败\n");exit(0);}for(i=0;i<N;i++)fprintf(fp,"%d ",a[i]);fclose(fp);}（4）、void charu(int a[N]) //插入排序{int i,j,temp;for(i=1;i<N;i++){temp=a[i];for(j=i;j>0&&a[j-1]>temp;j--)a[j]=a[j-1];a[j]=temp;}FILE *fp;if((fp=fopen("插入排序结果.txt","wb"))==NULL){printf("文件打开失败\n");return;}for(i=0;i<N;i++)fprintf(fp,"%d ",a[i]);fclose(fp);}（5）、void jiou(int a[N]) //奇偶排序{int i,temp;int flag;while(1){flag=0;for(i=0;i<N;i+=2)if(a[i]>a[i+1]){temp=a[i+1];a[i+1]=a[i];a[i]=temp;flag=1;}for(i=1;i<N;i+=2)if(a[i]>a[i+1]){temp=a[i+1];a[i+1]=a[i];a[i]=temp;flag=1;}if(flag==0){FILE *fp;if((fp=fopen("奇偶排序结果.txt","wb"))==NULL){printf("文件打开失败\n");return;}for(i=0;i<N;i++)fprintf(fp,"%d ",a[i]);fclose(fp);return;}}}（6）、void display(int a[N]) //打印排序号的数组{int i,j;for(i=0;i<N;i++){for(j=0;j<10;j++)printf("%d\t",a[i]);printf("\n");}}(7)主函数void main(){int i,j,m,a[N];srand((int)time(NULL));for(i=0;i<N;i++){a[i]=rand()%30000+1;}while(1){menu();scanf("%d",&m);switch(m){case 1: maopao(a);break;case 2: xuanze(a);break;case 3: charu(a);break;case 4: jiou(a);break;case 0: printf("谢谢使用!再见!\n");return;}display(a);}}5.调试分析（1）、冒泡排序（冒泡排序结果.txt保存在源程序的同一文件夹中）（2）、选择排序（选择排序结果.txt保存在源程序的同一文件夹中）（3）插入排序（插入排序结果.txt保存在源程序的同一文件夹中）（4）、奇偶排序（奇偶排序结果.txt保存在源程序的同一文件夹中）6.用户手册本程序在vc6.0上编译运行，用户可根据程序界面提示进行操作，如上面分析调试截图所示。
数据结构课程设计排序
---《数据结构》课程设计报告内部排序算法研究指导老师：姓名：学号：班级：专业：日期：一、问题描述（1）设n个关键字均为整数(1≤n≤100000)（2）设计K个内部排序算法(K≥5)，每个算法须记录执行所需的时间（3）自动生成多组数据，每组数据含n个整数 (正序、逆序、随机分布) （4）执行每个排序算法，统计各算法执行时间。
（5）用图、表格数据分析说明在什么情况下采用什么算法较好二、系统总体设计(模块结构图)（1）各函数功能说明Sortest类的成员函数功能说明void Qsort(int lw,int hi);快速排序函数void BubbleSort();;冒泡排序函数void ShellSort();希尔排序函数void HeapSort();堆排序函数void InsertSort();插入排序函数int partition(int lw,int hi);交换数组中[low]到a[high]的值，使枢轴记录到位，并返回其值，此时在之前的记录都不大于它，在它之后的记录都不小于它void Reload();对数据重新载入void Rand_Sort(int total);纪录cpu的运行周期数进而计算程序用时（2）模块结构图三、算法和数据结构设计程序主要部分为5种排序算法，数据用数组储存，程序运行时由用户输入数据个数，存入变量n，然后创建（n+1）个单位数据储存区储存数据，再由主函数分别调用顺序模块，逆序模块和随机模块，各个模块又分别调用对应的数据产生函数并分别调用5个排序函数，5个排序函数分别调用TheCycleCount()函数计算排序时间并打印输出，以上为程序的主体设计，各个排序算法的设计思想和伪代码见课本，不再赘述。
TheCycleCount()函数采用了嵌入汇编指令”RDTSC”的方法读取CPU自加电以来到调用该命令时所经过的时钟脉冲数。
这样，在排序前和排序后分别调用一次这个指令，将两者的差除以CPU的主频即可得到精确到纳秒级的时间了，精确度高。
数据结构课程设计实验报告(各种排序的实现与效率分析)
数据结构课程设计实验报告1、需求分析(1)对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较；(2)待排序表的表长不小于100，表中数据随机产生，至少用5组不同数据作比较，比较指标有：关键字参加比较次数和关键字的移动次数（关键字进行一次交换操作记为3次移动）；(3)输出比较结果。
2、主要函数及数据类型typedef int KeyType; //定义关键字类型为整数类型typedef int InfoType; //定义关键字类型为整数类型typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */typedef struct{KeyType key; //关键字项InfoType otherinfo; //其它数据项}RedType; //记录类型typedef struct {RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList; //顺序表类型3、源代码/*头文件和宏定义部分*/#include"string.h"#include"ctype.h"#include"time.h"#include"malloc.h" /* malloc()等*/#include"limits.h" /* INT_MAX等*/#include"stdio.h" /* EOF(=^Z或F6),NULL */#include"stdlib.h" /* atoi() */#include"io.h" /* eof() */#include"math.h" /* floor(),ceil(),abs() */#include"process.h" /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define MAXSIZE 100 //示例数据类型的最大长度typedef int KeyType; //定义关键字类型为整数类型typedef int InfoType; //定义关键字类型为整数类型typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */typedef struct{KeyType key; //关键字项InfoType otherinfo; //其它数据项}RedType; //记录类型typedef struct {RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList; //顺序表类型void InitData(SqList *L,int dataCopy[]){int i;L->length=MAXSIZE;srand((unsigned)time(NULL));for(i=0;i<=MAXSIZE;i++){L->r[i].otherinfo=0;dataCopy[i]=L->r[i].key=rand();}}void PrintData(SqList L){int i;for(i=1;i<=L.length;i++){printf("%d\t",L.r[i].key);}}void ResumeData(SqList *L,int dataCopy[]){int i;for(i=0;i<=MAXSIZE;i++){L->r[i].key=dataCopy[i];}}void PrintStatistic(int *compareCounts,int *moveCounts){printf("\n\t\t各种排序方法比较结果:\n\n");printf("\t\t起泡排序: 比较次数%d,移动次数%d\n",compareCounts[0],moveCounts[0]);printf("\t\t直接插入排序:比较次数%d,移动次数%d\n",compareCounts[1],moveCounts[1]);printf("\t\t简单选择排序:比较次数%d,移动次数%d\n",compareCounts[2],moveCounts[2]);printf("\t\t快速排序: 比较次数%d,移动次数%d\n",compareCounts[3],moveCounts[3]);printf("\t\t希尔排序: 比较次数%d,移动次数%d\n",compareCounts[4],moveCounts[4]);printf("\t\t堆排序: 比较次数%d,移动次数%d\n",compareCounts[5],moveCounts[5]);}/*******************************直接插入排序*******************************/void InsertSort(SqList *L,int *compareCounts,int *moveCounts ) //直接插入排序{int i,j; //for(i=2;i<=L->length;i++) //从顺序表的第二个元素开始进行比较{if(L->r[i].key<L->r[i-1].key) //将每个元素与它的前一个元素关键字进行比较{L->r[0]=L->r[i]; //如果关键字比前一个元素关键字小，就将元素复制作为哨兵L->r[i]=L->r[i-1];(*moveCounts)+=2; //关键字移动了2次j=i-2; //从要比较的关键字的前第二个记录开始进行比较,然后后移while(L->r[0].key<L->r[j].key){L->r[j+1]=L->r[j]; //记录后移(*moveCounts)++; //每作一次后移,移动次数加1j--;(*compareCounts)++; //每作一次比较，比较次数加1}L->r[j+1]=L->r[0]; //插入到正确位置}(*compareCounts)++;}}/*******************************希尔排序*******************************/void ShellInsert(SqList *L,int increment,int *compareCounts,int *moveCounts){ //对顺序表作一趟希尔插入排序int j,n;for(j=1+increment;j<=L->length;j++){if(L->r[j].key<L->r[j-increment].key) //将L->[i]插入到有序增量子表{L->r[0]=L->r[j]; //暂存在L->r[0]L->r[j]=L->r[j-increment];(*moveCounts)+=2;for(n=j-2*increment;n>0&&L->r[0].key<L->r[n].key;n-=increment){L->r[n+increment]=L->r[n]; //记录后移，查找插入位置(*moveCounts)++;(*compareCounts)++;}L->r[n+increment]=L->r[0]; //插入(*moveCounts)++;}(*compareCounts)++;}}void ShellSort(SqList *L,int IncreList[],int times,int *compareCounts,int *moveCounts) //希尔排序{ //按增量序列Increlist［0.....times-1］对顺序表Ｌ作希尔排序int k; //for(k=0;k<times;k++){ShellInsert(L,IncreList[k],compareCounts,moveCounts); //一趟增量为IncreList[k]的插入排序}}/*******************************起泡排序*******************************/void BubbleSort(SqList *L,int *compareCounts,int *moveCounts) //起泡排序{int i,j;for(i=1;i<=L->length;i++){for(j=L->length;j>i;j--){ //从后往前两两进行比较，将元素关键字小的交换到前面if(L->r[j].key<L->r[j-1].key){L->r[0]=L->r[j];L->r[j]=L->r[j-1];L->r[j-1]=L->r[0];(*moveCounts)+=3;}(*compareCounts)++;}}}/*******************************快速排序*******************************/int Partition(SqList *L,int low,int high,int *compareCounts,int *moveCounts) //快速排序中的分{int pivotkey;L->r[0]=L->r[low];(*moveCounts)++;pivotkey=L->r[low].key;while(low<high){while(low<high&&L->r[high].key>=pivotkey){high--;(*compareCounts)++;}L->r[low]=L->r[high];(*moveCounts)++;while(low<high&&L->r[low].key<=pivotkey){low++;(*compareCounts)++;}L->r[high]=L->r[low];(*moveCounts)++;(*compareCounts)++;}L->r[low]=L->r[0];(*moveCounts)++;return low;}void QSort(SqList *L,int low,int high,int *compareCounts,int *moveCounts){int pivotloc;if(low<high){pivotloc=Partition(L,low,high,compareCounts,moveCounts);QSort(L,low,pivotloc-1,compareCounts,moveCounts);QSort(L,pivotloc+1,high,compareCounts,moveCounts);}}void QuickSort(SqList *L,int *compareCounts,int *moveCounts){QSort(L,1,L->length,compareCounts,moveCounts);}/*******************************简单选择排序*******************************/void SelectSort(SqList *L,int *compareCounts,int *moveCounts){int i,j,minPoint;for(i=1;i<=L->length;i++){L->r[0]=L->r[i];(*moveCounts)++;minPoint=i;for(j=i+1;j<=L->length;j++){if(L->r[j].key<L->r[0].key){L->r[0]=L->r[j];(*moveCounts)++;minPoint=j;}(*compareCounts)++;}L->r[minPoint]=L->r[i];L->r[i]=L->r[0];(*moveCounts)++;}}/*******************************堆排序*******************************/void HeapAdjust(SqList *L,int s,int m,int *compareCounts,int *moveCounts){RedType cmpKey; //待比较的值int j;cmpKey=L->r[s];(*moveCounts)++;for(j=s*2;j<=m;j*=2){(*compareCounts)+=2;if(j<m&&L->r[j].key<L->r[j+1].key) j++;if(!(cmpKey.key<L->r[j].key)) break;L->r[s]=L->r[j];(*moveCounts)++;s=j;}L->r[s]=cmpKey;(*moveCounts)++;}void HeapSort(SqList *L,int *compareCounts,int *moveCounts){int i;RedType temp;for(i=L->length/2;i>0;i--) HeapAdjust(L,i,L->length,compareCounts,moveCounts);for(i=L->length;i>1;i--){temp=L->r[1];L->r[1]=L->r[i];L->r[i]=temp;(*moveCounts)+=3;HeapAdjust(L,1,i-1,compareCounts,moveCounts);}}void SortCompare(){SqList L; //用顺序表存放待排序的元素int dataCopy[MAXSIZE+1],i;int compareCounts[7],moveCounts[7];int increList[6];for(i=0;i<5;i++){increList[i]=(int)pow(2,7-i)-1;}increList[5]=1;for(i=0;i<7;i++){compareCounts[i]=0;moveCounts[i]=0;}InitData(&L,dataCopy); //初始化数据，随机产生100个正整数的数列printf("\t\t\t初始化数据后产生的数列:\n");PrintData(L); //显示出未排序的数列printf("\n\n\t\t\t经过起泡排序后产生的数列:\n");BubbleSort(&L,&compareCounts[0],&moveCounts[0]); //对数列使用起泡排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过直接插入排序后产生的数列:\n");InsertSort(&L,&compareCounts[1],&moveCounts[1]); //对数列使用插入排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过简单选择排序后产生的数列:\n");SelectSort(&L,&compareCounts[2],&moveCounts[2]); //对数列使用简单选择排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过快速排序后产生的数列:\n");QuickSort(&L,&compareCounts[3],&moveCounts[3]); //对数列使用快速排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过希尔排序后产生的数列:\n");ShellSort(&L,increList,6,&compareCounts[4],&moveCounts[4]); //对数列使用希尔排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过堆排序后产生的数列:\n");HeapSort(&L,&compareCounts[5],&moveCounts[5]); //对数列使用堆排序PrintData(L); //显示出排序好的数列PrintStatistic(compareCounts,moveCounts);}main(){int i,temp;for(i=0;i<5;i++){SortCompare();printf("\n\t\t请按任意键进行下一组数据的排序对比\n\n");temp=getchar();}}4、调试分析成功运行，如图所示：。
数据结构课程设计报告排序算法演示系统
.1. 设计目的随着计算机技术的发展，各种排序算法不断的被提出。
排序算法在计算机科学中有非常重要的意义，且应用很广泛。
在以后的发展中排序对我们的学习和生活的影响会逐渐增大，很有必要学习排序知识。
此次课程设计一方面使自己掌握排序的知识，另一方面锻炼一下团队合作开发系统的能力。
2.1 设计内容和要求设计内容：（1）实现各种内部排序。
包括直接插入排序，希尔排序，冒泡排序，快速排序，直接选择排序，归并排序，堆排序。
（2）待排序的元素的关键字为整数或（字符）。
可用随机数据和用户输入数据作测试比较。
比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换以3次计)。
（3）演示程序以人机对话的形式进行。
每次测试完毕显示各种比较指标值的列表，以便比较各种排序的优劣。
3. 本设计所采用的数据结构typedef struct{int key;}RecType;4. 功能模块详细设计4.1 详细设计思想主函数：#include<stdio.h>#include<stdlib.h>#include <math.h>#define L 8 //排序元素个数#define FALSE 0#define TRUE 1typedef struct{int key;}RecType;RecType R[L];int num;int sum;int sun; //定义排序趟数的全局变量//主函数int main(){Seqlist S;int i,k;char ch1,ch2,q;printf("\n\t\t 排序算法演示系统\n\n\t\t请输入%d个待排序的数据：",L);for(i=1;i<=L;i++){scanf("%d",&S[i].key);getchar();printf("\t\t");}ch1='y';while(ch1=='y'){ printf("\n");printf("\n\t\t 菜单 \n");printf("\n\t\t***********************************************\n");printf("\n\t\t 1--------更新排序数据 2--------直接插入排序 \n"); printf("\n\t\t 3--------希尔排序 4--------冒泡排序 \n"); printf("\n\t\t 5--------快速排序 6--------直接选择排序 \n"); printf("\n\t\t 7--------堆排序 8--------归并排序 \n"); printf("\n\t\t *** 0--------退出 *** \n"); printf("\n\t\t***********************************************\n");printf("\n\t\t请选择:");scanf("%c",&ch2);getchar();for(i=1;i<=L;i++){R[i].key=S[i].key;}switch(ch2){case '1':printf("\n\t\t请输入%d个待排序数据\n\t\t",L);for(i=1;i<=L;i++){scanf("%d",&S[i].key);getchar();printf("\t\t");}printf("\n\t\t数据输入完毕！");break;case '2':Insertsort();break;case '3':Shellsort();break;case '4':Bubblesort();break;case '5':printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");for(k=1;k<=L;k++){printf("%5d",R[k].key);}getchar();printf("\n");num=0;sun=0;sum=0;Quicksort(1,L);printf("\n\t\t排序最终结果是：\n\t\t");for(k=1;k<=L;k++){printf("%5d",R[k].key);}printf("\n\t\t比较次数是：%d\n\t\t",sum);printf("\n\t\t交换次数是：%d\n\t\t",sun);break;case '6':Selectsort();break;case '7':Heap();break;case '8':Mergesort();break;case '0':ch1='n';break;default:system("cls");//清屏printf("\n\t\t对不起，您输入有误，请重新输入！\n");break;}if(ch2!='0'){if(ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8') {printf("\n\n\t\t排序完毕！");printf("\n\t\t按回车键继续！");q=getchar();if(q!='\n'){getchar();ch1='n';}}}}return 1;}//系统主界面4.1.1 冒泡排序核心思想依次比较相邻的两个数，将小数放在前面，大数放在后面，第一轮比较后，最大的数便被放到了最后；第二轮操作前n-1个数据（假设有n个数据），依然是依次比较相邻的两个数，将小数放在前面，大数放在后面，倒数第二个数便是第二大的数；同理第i轮操作前n-i+1的数据（假设i取值是从1开始的），则n-i+i位置上的数据为第i大的数据。
数据结构排序综合设计报告(含代码)参考模板
《数据结构》课程设计报告题目：排序综合专业：计算机科学与技术班级：嵌入式1102班组员：11160501 丁雷11160522 高明尧目录1需求分析 (3)2概要设计 (3)3 详细设计 (5)4调试结果 (8)5课程设计总结 (11)参考书目 (11)1需求分析1.1 任务与分析任务：利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。
要求：1)至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。
并把排序后的结果保存在不同的文件中。
2)统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。
分析：本系统实现了几种常用的排序方法，包括：插入排序、起泡排序、快速排序（递归、非递归）、堆排序。
1.2 功能模块的划分1.2.1 输入模块利用随机函数产生N个随机整数（20000以上），个数由用户自己输入。
1.2.2输出模块输出排序前或排序后的数据元素到屏幕显示，并且输出按照选择的算法排序后的数据元素到文件中保存。
1.2.3输出结论比较不同排序时间长短，输出两种最快的排序方法。
1.2.4排序模块插入排序思路:设有一组关键字{K1,K2,…….,Kn},排序开始变认为K1是一个有序的序列,让K2插入到表长为1的有序序列,使之成为一个表长为2的有序序列, 让K3插入到表长为2的有序序列,使之成为一个表长为3的有序序列,依次类推,最后让Kn插入上述表长为n-1的有序序列,得到一个表长为n的有序序列.冒泡排序如果有n个数，则要进行n-1趟比较。
在第1趟比较中要进行n-1次两两比较，在第j趟比较中要进行n-j次两两比较简单选择排序通过n-I次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换之2概要设计2.1程序结构框图2.2程序流程图2.3头文件#include<stdio.h>#include<stdlib.h>#include<cstdlib>#include<time.h>2.5各种操作函数：（1）创建一个数组函数：（2）输出数组函数：( 3 ) 简单选择排序（4）插入排序函数：（5）起泡排序函数：（6）时间函数：start = clock();end = clock();2.6主函数V oid main(){接受命令（选择要执行的操作）；处理命令；输出结果；}3 详细设计#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 30001void main(){int i,j,n,k;int n1,t;int a[N],b[N],c[3],d[3];clock_t start,finish;int time1,time2,time3;输入设计printf("*************************数据结构排序综合**************************\n"); printf("\n输入要产生的随机数个数：");scanf("%d",&n);srand((unsigned)time(NULL));for(i=0;i<n;i++)a[i]=rand();//插入排序for(i=0;i<n;i++)b[i]=a[i];printf("---------------------\n");printf("\t插入排序\n");printf("---------------------\n");start=clock();for(i=1;i<n;i++) //依次插入数字到它前面已经排好序的数字中去{t=b[i];j=i-1;while(b[j]>t && j>=0){b[j+1]=b[j];j--;}if(j!=(i-1)) //第i个数字比前面的都大，不需要重新插入{b[j+1]=t;}}for(i=n-1;i>=0;i--)printf("%d ",b[i]);finish=clock();c[0]=finish-start;printf("\n插入排序耗时%d毫秒！\n\n\n",c[0]);//起泡排序for(i=0;i<n;i++)b[i]=a[i];printf("-----------------------\n");printf("\t起泡排序\n");printf("-----------------------\n");start=clock();n1=n-1;while(n1>0){j=0;for(i=0;i<n;i++)if(b[i]>b[i+1]){t=b[i];b[i]=b[i+1];b[i+1]=t;j=i;}n1=j;printf("%d ",t);}finish=clock();c[1]=finish-start;printf("\n起泡排序耗时%d毫秒！\n\n\n",c[1]);//简单选择排序for(i=0;i<n;i++)b[i]=a[i];printf("-------------------------\n");printf("\t简单选择排序\n");printf("-------------------------\n");start=clock();for(i=1;i<n;i++){k=n-1;for(j=k-1;j>i-1;j--){if(b[j]<b[k])k=j;}if(k!=i-1){t=b[i-1];b[i-1]=b[k];b[k]=t;}}for(i=n-1;i>=0;i--)printf("%d ",b[i]);finish=clock();c[2]=finish-start;printf("\n简单选择排序耗时%d毫秒！\n\n\n",c[2]); //寻找两种最快方法for(i=0;i<3;i++)d[i]=c[i];for(i=0;i<3;i++){for(j=i+1;j<3;j++){if(d[i]>d[j]){t=d[i];d[i]=d[j];d[j]=t;}}}// printf("%d",c[0]);printf("排序这组数据最快的两组排序法是：\n");if(d[0]==c[0])printf("插入排序：%d毫秒\n",d[0]);if(d[0]==c[1])printf("起泡排序：%d毫秒\n",d[0]);if(d[0]==c[2])printf("简单选择排序：%d毫秒\n",d[0]);if(d[0]!=d[1]){if(d[1]==c[0])printf("插入排序：%d毫秒\n",d[1]);if(d[1]==c[1])printf("起泡排序：%d毫秒\n",d[1]);if(d[1]==c[2])printf("简单选择排序：%d毫秒\n",d[1]);}}4调试结果数据由系统随机产生，不需要输入测试数据，产生数据元素的个数由用户输入。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》课程设计报告专业计算机科学与技术班级(1)姓名学号指导教师起止时间2011.10~2011.12课程设计：排序综合一、任务描述（1）至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序、归并排序）。
并把排序后的结果保存在不同的文件中。
（2）统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。
二、问题分析1、功能分析分析设计课题的要求，要求编程实现以下功能：（1）显示随机数：调用Dip()函数输出数组a[]。
数组a[]中保存有随机产生的随机数。
（2）直接选择排序：通过n-I次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换之。
（3）冒泡排序：如果有n个数，则要进行n-1趟比较。
在第1趟比较中要进行n-1次两两比较，在第j趟比较中要进行n-j次两两比较。
（4）希尔排序：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
（5）直接插入排序：将一个记录插入到已排序好的有序表中，从而得到一个新的、记录数增1的有序表。
设整个排序有n个数，则进行n-1趟插入，即：先将序列中的第1个记录看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减有序列为止。
（6）显示各排序算法排序后的的数据和时间效率，并比较找出其中2种较快的方法。
2、数据对象分析排序方式：直接选择排序、冒泡排序、希尔排序、直接插入排序显示排序后的的数据和时间效率。
三、数据结构设计1.主要全程变量及数据结构数据结构：typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;2.算法的入口参数及说明#include <stdio.h>#define MAXSIZE 20#define LT(a,b) ((a)<(b)) //宏定义typedef int KeyType; //定义关键字KeyType为inttypedef int InfoType; //定义关键字InfoType为inttypedef struct{ //RedType结构定义KeyType key;InfoType otherinfo; //记录中其他信息域的类型}RedType;typedef struct{ //SqList结构定义RedType r[MAXSIZE+1]; //定义大小int length; //length为待排记录个数}SqList;四、功能设计（一）主控菜单设计为实现排序的操作功能，首先设计一个含有多个菜单项的主控菜单程序，然后再为这些菜单项配上相应的功能。
程序运行后，给出11个菜单项的内容和输入提示，如下：欢迎来到排序综合系统！菜单(1)---直接插入排序(2)---直接选择排序(3)---冒泡排序(4)---快速排序(5)---堆排序(6)---时间效率比较(7)---显示随机数(0)---退出系统请在上述序号中选择一个并输入：（二）程序模块结构由课题要求可将程序划分为以下几个模块（即实现程序功能所需的函数）：●主控菜单项选择函数menu_select()●插入排序函数：InsertS ort()●选择排序函数：SelectSort()●冒泡排序函数：BubbleSort()●堆排序函数：heapsort()（三）函数调用关系程序的主要结构（函数调用关系）如下图所示。
其中main()是主函数，它进行菜单驱动，根据选择项1~0调用相应的函数。
（四）函数实现#include <stdio.h>#include <conio.h>#include <stdlib.h>#include <windows.h>#include <time.h>#define N 30000void Wrong(){printf("\n=====>按键错误!\n");getchar();}void Disp(int a[]){int i;system("cls");for(i=0;i<N;i++){if((i-1)%10==9)printf("\n");printf("%-7d",a[i]);}}void InsertSort(int a[],int p) //插入排序{int i,j,temp;for(i=1;i<N;i++){temp=a[i];for(j=i;j>0&&a[j-1]>temp;j--)a[j]=a[j-1];a[j]=temp;}}void SelectSort(int a[],int p) //选择排序{int i,j,k;for(i=0;i<N-1;i++){k=i;for(j=i+1;j<N;j++)if(a[j]<a[k])k=j;if(k!=i){int temp;temp=a[k];a[k]=a[i];a[i]=temp;}}}void BubbleSort(int a[],int p) /*冒泡排序算法*/{int i,j,temp;for (i=0;i<N-1;i++){for (j=N-1;j>i;j--) /*比较,找出本趟最小关键字的记录*/ if (a[j]<a[j-1]){temp=a[j]; /*进行交换,将最小关键字记录前移*/a[j]=a[j-1];a[j-1]=temp;}}}void creatheap(int a[],int i,int n) //创建堆{int j;int t;t=a[i];j=2*(i+1)-1;while(j<=n){if((j<n)&&(a[j]<a[j+1]))j++;if(t<a[j]){a[i]=a[j];i=j;j=2*(i+1)-1;}elsej=n+1;}a[i]=t;}void heapsort(int a[],int n,int p) //堆排序{int i;int t;for(i=n/2-1;i>=0;i--)creatheap(a,i,n-1);for(i=n-1;i>=1;i--){t=a[0];a[0]=a[i];a[i]=t;creatheap(a,0,i-1);}}void quicksort(int a[],int n,int p){int i,j,low,high,temp,top=-1;struct node{int low,high;}st[N];top++;st[top].low=0;st[top].high=n-1;while(top>-1){ low=st[top].low;high=st[top].high;top--;i=low;j=high;if(low<high){ temp=a[low];while(i!=j){ while(i<j&&a[j]>temp)j--;if(i<j){a[i]=a[j];i++;}while(i<j&&a[i]<temp)i++;if(i<j){a[j]=a[i];j--;}}a[i]=temp;top++;st[top].low=low;st[top].high=i-1; top++;st[top].low=i+1;st[top].high=high; }}}double TInsertSort(int a[],int p){int i;int b[N];for(i=0;i<N;i++)b[i]=a[i];LARGE_INTEGER m_liPerfFreq={0}; QueryPerformanceFrequency(&m_liPerfFreq);LARGE_INTEGER m_liPerfStart={0};QueryPerformanceCounter(&m_liPerfStart);InsertSort(b,p);LARGE_INTEGER liPerfNow={0};QueryPerformanceCounter(&liPerfNow);double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;if(p!=6){Disp(b);getchar();}printf("\n用直接插入排序法用的时间为%f秒；",time);FILE *fp;fp=fopen("直接插入排序.txt","w");for(i=0;i<N;i++)fprintf(fp,"%d ",b[i]);fclose(fp);return(time);}double TSelectSort(int a[],int p){int i;int b[N];for(i=0;i<N;i++)b[i]=a[i];LARGE_INTEGER m_liPerfFreq={0}; QueryPerformanceFrequency(&m_liPerfFreq);LARGE_INTEGER m_liPerfStart={0};QueryPerformanceCounter(&m_liPerfStart);SelectSort(b,p);if(p!=6){Disp(b);getchar();}LARGE_INTEGER liPerfNow={0};QueryPerformanceCounter(&liPerfNow);double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;printf("\n用直接选择排序法用的时间为%f秒；",time);FILE *fp;fp=fopen("直接选择排序.txt","w");for(i=0;i<N;i++)fprintf(fp,"%d ",b[i]);fclose(fp);return(time);}double TBubbleSort(int a[],int p){int i;int b[N];for(i=0;i<N;i++)b[i]=a[i];LARGE_INTEGER m_liPerfFreq={0}; QueryPerformanceFrequency(&m_liPerfFreq);LARGE_INTEGER m_liPerfStart={0};QueryPerformanceCounter(&m_liPerfStart);BubbleSort(b,p);LARGE_INTEGER liPerfNow={0};QueryPerformanceCounter(&liPerfNow);double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;if(p!=6){Disp(b);getchar();}printf("\n用冒泡排序法用的时间为%f秒；",time);FILE *fp;fp=fopen("冒泡排序.txt","w");for(i=0;i<N;i++)fprintf(fp,"%d ",b[i]);fclose(fp);return(time);}double Theapsort(int a[],int n,int p){int i;int b[N];for(i=0;i<N;i++)b[i]=a[i];LARGE_INTEGER m_liPerfFreq={0}; QueryPerformanceFrequency(&m_liPerfFreq);LARGE_INTEGER m_liPerfStart={0};QueryPerformanceCounter(&m_liPerfStart);heapsort(b,N,p);LARGE_INTEGER liPerfNow={0};QueryPerformanceCounter(&liPerfNow);double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;if(p!=6){Disp(b);getchar();}printf("\n用堆排序法用的时间为%f秒；",time);FILE *fp;fp=fopen("堆排序.txt","w");for(i=0;i<N;i++)fprintf(fp,"%d ",b[i]);fclose(fp);return(time);}double Tquicksort(int a[],int n,int p){int i;int b[N];for(i=0;i<N;i++)b[i]=a[i];LARGE_INTEGER m_liPerfFreq={0}; QueryPerformanceFrequency(&m_liPerfFreq);LARGE_INTEGER m_liPerfStart={0};QueryPerformanceCounter(&m_liPerfStart);quicksort(b,N,p);LARGE_INTEGER liPerfNow={0};QueryPerformanceCounter(&liPerfNow);double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;if(p!=6){Disp(b);getchar(); }printf("\n用快速排序法用的时间为%f秒；",time);FILE *fp;fp=fopen("快速排序.txt","w");for(i=0;i<N;i++)fprintf(fp,"%d ",b[i]);fclose(fp); return(time);}void BubleSort(double a[]) //时间数组的冒泡排序{int i,j;double temp;for(i=1;i<6;i++){for(j=4;j>=i;j--)if(a[j+1]<a[j]){temp=a[j+1];a[j+1]=a[j];a[j]=temp;}}}void menu(){printf(" 欢迎来到排序综合系统! \n"); printf(" ============================================== \n"); printf(" \n"); printf(" 菜单 \n"); printf(" \n"); printf(" \n"); printf(" (1)---直接插入排序 \n"); printf(" (2)---直接选择排序 \n"); printf(" (3)---冒泡排序 \n"); printf(" (4)---快速排序 \n"); printf(" (5)---堆排序 \n"); printf(" (6)---时间效率比较 \n"); printf(" (7)---显示随机数 \n"); printf(" (0)---退出系统 \n"); printf("\n 请在上述序号中选择一个并输入: "); }void main(){int i,p,a[N];srand((int)time(NULL)); /*随机种子*/for(i=0;i<N;i++)a[i]=rand()%50000+1;while(1){system("cls");menu();scanf("%d",&p);if(p==0){printf("===>谢谢使用!\n");getchar();break;}double TIMES[5],TIMES1[5];//时间数组switch(p){case 1:TInsertSort(a,p);printf("\n请按任意键继续...");getchar();break;case 2:TSelectSort(a,p);printf("\n请按任意键继续...");getchar();break;case 3:TBubbleSort(a,p);printf("\n请按任意键继续...");getchar();break;case 4:Tquicksort(a,N,p);printf("\n请按任意键继续...");getchar();break;case 5:Theapsort(a,N,p);printf("\n请按任意键继续...");getchar();break;case 6:system("cls");TIMES1[1]=TIMES[1]=TInsertSort(a,p);TIMES1[2]=TIMES[2]=TSelectSort(a,p);TIMES1[3]=TIMES[3]=TBubbleSort(a,p);TIMES1[4]=TIMES[4]=Tquicksort(a,N,p);TIMES1 [5]=TIMES[5]=Theapsort(a,N,p);getchar();BubleSort(TIMES);printf("\n\n");{printf("排序这组数据两种较快的排序法分别是：\n");if(TIMES[1]==TIMES1[1]) printf("直接插入排序:%f秒!\n",TIMES[1]); if(TIMES[1]==TIMES1[2]) printf("直接选择排序:%f秒!\n",TIMES[1]);if(TIMES[1]==TIMES1[3]) printf("冒泡排序:%f秒!\n",TIMES[1]);if(TIMES[1]==TIMES1[4]) printf("快速排序:%f秒!\n",TIMES[1]);if(TIMES[1]==TIMES1[5]) printf("堆排序:%f秒!\n",TIMES[1]);if(TIMES[1]!=TIMES[2]){if(TIMES[2]==TIMES1[1]) printf("直接插入排序:%f秒!\n",TIMES[2]); if(TIMES[2]==TIMES1[2]) printf("直接选择排序%f秒!\n",TIMES[2]);if(TIMES[2]==TIMES1[3]) printf("冒泡排序%f秒!\n",TIMES[2]);if(TIMES[2]==TIMES1[4]) printf("快速排序%f秒!\n",TIMES[2]);if(TIMES[2]==TIMES1[5]) printf("堆排序%f秒!\n",TIMES[2]);}} printf("\n请按任意键继续...");srand((int)time(NULL));for(i=0;i<N;i++) {a[i]=rand()%30000+1;} getchar();break;case 7:Disp(a);FILE *fp;fp=fopen("随机数.txt","w");for(i=0;i<N;i++)fprintf(fp,"%d ",a[i]);fclose(fp);getchar();printf("\n请按任意键继续...");getchar();break;default:Wrong();printf("\n请按任意键继续...");getchar();break;}}}五、测试数据和结果本程序在VC++环境下实现，下面是对以上测试数据的运行结果。