数据结构课程设计(内部排序算法比较).doc

合集下载

数据结构 内部排序算法比较

数据结构 内部排序算法比较

内部排序算法比较目录摘要 ......................................................................................... 错误!未定义书签。

1绪论 . (1)2系统分析 (1)2.1功能需求 (1)2.2数据需求 (1)2.3性能需求 (1)3总体设计 (1)3.1系统设计方案 (1)3.2功能模块设计 (2)4详细设计 (3)4.1数据结构定义 (3)4.2伪随机产生数据模块 (4)4.3简单选择排序模块 (5)4.4起泡排序模块 (6)4.5直接插入排序模块 (7)4.6希尔排序模块 (8)4.7快速排序模块 (9)4.8归并排序模块 (10)4.9条形图模块 (11)5调试与测试 (12)5.1调试 (12)5.2测试 .................................................................................. 错误!未定义书签。

6结论 .. (13)结束语 (13)参考文献 (14)附录1-用户手册 (15)附录2-源程序 (17)1绪论随着科技的快速发展,越来越多的企业不再浪费人力财力去计算一些统计性结果,而是应用一些简单的程序或系统来完成这些任务。

随着学习数据结构课程的深入,了解了不同排序算法的不同排序方法,每种排序对数据的比较次数、移动次数和排序用时都是不同的,本程序实现了六种内部排序算法的比较,并用条形图直观的显示出各种算法的优劣。

运用伪随机产生的数据,调用六种排序算法,记录其比较次数、移动次数和排序时间,再分别用条形图(星号表示)表示出来。

2系统分析2.1 功能需求(1)对起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、归并排序算法进行比较。

(2)待排序的元素的关键字为整数,其中数据要用伪随机产生程序产生,并且至少用5组的输入数据做比较,再使用各种算法对其进行排序,记录其排序时间,再汇总比较。

数据结构专业课程设计十种排序算法比较样本

数据结构专业课程设计十种排序算法比较样本

数据结构专业课程设计十种排序算法比较合肥学院计算机科学与技术系课程设计报告2014 ~2015 学年第学期课程数据结构与算法课程设计名称内部排序算法比较学生姓名学号专业班级指导教师2015 年1 月【课题22、】内部排序算法比较一、问题分析和任务定义各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。

试通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受。

根据对本设计任务要求的理解和分析,按以下两点问题进行分析:题目要求对十种排序算法进行比较,比较的主要内容是关键字的比较次数和移动次数,其中待排序数用。

二、数据结构的选择和概要设计为了实现十种排序算法,产生的随机数用顺序表存储比较方便。

顺序表数据类型(存储结构)描述如下:typedef int KeyType;struct rec{KeyType key;};typedef rec sqlist[N];:(1) void gensort(int b[],int n)起泡排序(2) void insertsort(sqlist b,int n)插入排序(3) void so(sqlist num,int n)折半插入排序(4) void shellsort(sqlist b,int n)希尔排序(5) void gentsort(int b[],int n)选择排序(6) void output(sqlist b,int n)快速排序(7) void sort3(sqlist nu,int n) //2-路插入排序(8) void Merge(sqlist a, sqlist b, int low, int mid, int high)二路归并排序(9) void MergePass(sqlist a, sqlist b, int n, int lenth)一趟归并排序(10) void MergeSort(sqlist a, int n) //进行二路归并(11) void sift(sqlist r,int s,int m) 堆排序(12) void init(int a[])//随机生成N个整数三、详细设计和编码在整个课程设计中,要求实现要求的功能,必须要有主函数,并通过主函数调用各功能子模块,以上展示各个模块的功能,以下将分析主函数和各个模块中的具体算法和实现。

数据结构课程设计各种排序算法比较附带源代码.doc

数据结构课程设计各种排序算法比较附带源代码.doc

数据结构课程设计各种排序算法比较附带源代码.课程设计课程:数据结构题目:排序算法比较专业班级:姓名:学号:设计时间:指导教师:设计题目排序算法比较运行环境(软、硬件环境)操作系统windows运行环境vc6.0算法设计的思想大架构采用模块化编程的思想,将每个不同的功能分别写成不同的子程序,分别进行封装构成各个小的模块,最后将各个模块组合起来。

在每个子程序的编写过程中特事特办面对不同的预想功能采取不同的数据结构不同的算法实现。

总体算法思想为按功能分块,依照预想功能实现顺序拼装。

具体思想请见流程图。

流程图开始功能流程图请用户输入将要生成随机数的上下限,按照上下限生成30000个随机数并输出随机生成随机数并输出请用户选择想要使用的排序方法计算其使用的排序时间并输出询问用户是否继续运行程序否是输出结束语句结束程序编写流程图开始定义全局变量a[30000],aaaa[3000],结构体数组aa[30000]用来存放随机数,choice,choice1编写各个子算法子函数,和时间选择函数,既菜单选择函数,部分需要声明的函数在头文件下声明。

各模块依据功能流程图组装结束算法流程图开始局部变量l,h收集上下限,sjs()将用户选择数值赋值于choice,将choice作为参数调用time(),用if语句判断选择将要调用的算法子函数main1()menu()choice1==1Choice1==2结束算法设计分析程序总体采用模块化设计,程序间通过传参和调用进行有机组合。

这样的总体布局将将各个功能隔离开来,每个模块负责每个模块的功能,使得程序的布局简单明了。

且子程序只有在被调用时才会运行大大节约系统资源减少了运算时间。

同时由于功能的隔离使得程序的扩展性大大提高,无论程序将要任何改动时,都会方便很多。

源代码#include#include#includeint a[30000];int choice;int choice1;struct xlx{ int key; int link;} aa[30000];int aaa[300000];void main1();/*************************直接插入排序函数***********************/void direct(int a[]){printf("\n现在使用直接插入排序法进行排序:\n");int i,j,w; for(i=0;i=0;j-数据结构题目:排序算法比较专业班级:姓名:学号:设计时间:指导教师:设计题目排序算法比较运行环境(软、硬件环境)操作系统windows运行环境vc6.0算法设计的思想大架构采用模块化编程的思想,将每个不同的功能分别写成不同的子程序,分别进行封装构成各个小的模块,最后将各个模块组合起来。

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

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

(完整)数据结构(C语言版)实验报告 (内部排序算法比较)编辑整理:尊敬的读者朋友们:这里是精品文档编辑中心,本文档内容是由我和我的同事精心编辑整理后发布的,发布之前我们对文中内容进行仔细校对,但是难免会有疏漏的地方,但是任然希望((完整)数据结构(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]。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构课程设计(内部排序算法性能分析)

数据结构课程设计(内部排序算法性能分析)

“数据结构”课程设计报告(内部排序算法性能分析)学生姓名:指导教师:所在系:所学专业:年级:目录1、需求分析..................................................... - 1 -1.1、选题要求 (1)1.2、选题的意义及背景 (1)1.3、课程设计目标 (1)2、概要设计..................................................... - 2 -2.1、原始数据 (2)2.2、输出数据 (2)2.3、数据处理 (2)2.4、逻辑结构及物理结构 (3)2.5、系统的模块划分及模块功能 (3)2.5.1主程序模块....................................................................................................... - 3 -2.5.2可排序表单元模块........................................................................................... - 3 -2.6、模块的测试数据 (4)3、详细分析..................................................... - 5 -4、调试分析..................................................... - 6 -5、用户手册..................................................... - 9 -6、测试结果.................................................... - 10 -6.1测试用例及选择原因 (10)6.2测试结果 (10)7、总结........................................................ - 12 -8、参考文献.................................................... - 13 -9、小组人员分工................................................ - 13 -致谢......................................................... - 13 -1、需求分析1.1、选题要求对各种排序算法进行定量的性能分析。

数据结构课程设计(内部排序算法比较-C语言)

数据结构课程设计(内部排序算法比较-C语言)

`课题:内部排序算法比较…第一章问题描述排序是数据结构中重要的一个部分,也是在实际开发中易遇到的问题,所以研究各种排算法的时间消耗对于在实际应用当中很有必要通过分析实际结合算法的特性进行选择和使用哪种算法可以使实际问题得到更好更充分的解决!该系统通过对各种内部排序算法如直接插入排序,冒泡排序,简单选择排序,快速排序,希尔排序,堆排序、二路归并排序等,以关键码的比较次数和移动次数分析其特点,并进行比较,估算每种算法的时间消耗,从而比较各种算法的优劣和使用情况!排序表的数据是多种不同的情况,如随机产生数据、极端的数据如已是正序或逆序数据。

比较的结果用一个直方图表示。

第二章系统分析界面的设计如图所示:!|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|~请选择操作方式:如上图所示该系统的功能有:(1):选择 1 时系统由客户输入要进行测试的元素个数由电脑随机选取数字进行各种排序结果得到准确的比较和移动次数并打印出结果。

(2)选择 2 时系统由客户自己输入要进行测试的元素进行各种排序结果得到准确的比较和移动次数并打印出结果。

(3)选择0 打印“谢谢使用!!”退出系统的使用!!、第三章系统设计(I)友好的人机界面设计:(如图所示)|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|:()(II)方便快捷的操作:用户只需要根据不同的需要在界面上输入系统提醒的操作形式直接进行相应的操作方式即可!如图(所示)|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|;请选择操作方式:(用户在此输入操作方式)()(III)系统采用定义结构体数组来存储数据。

数据结构 各种内排序性能比较 课程设计报告

数据结构 各种内排序性能比较 课程设计报告

数据结构课程设计报告题目:各种内排序性能比较学生姓名:学号:班级:指导教师:2011-6-13目录1、需求分析说明 (2)1.1所需完成的任务及要求1.2程序实现的功能2、总体设计 (3)2.1 总体设计说明2.2 总体流程图2.3各主程序详细流程图3、详细设计 (7)3.1使用的算法思想3.2各个算法的效率简析4、实现部分 (8)4.1程序算法的代码5、程序测试 (15)5.1程序运行的主界面5.2 各算法运行界面6、总结 (18)1、需求分析说明排序是数据处理中经常遇到的一种重要操作。

然而排序的算法有很多,各有其优缺点和使用场合。

本程序的设计的主要目的是通过比较各种内部排序(包括:插入法排序、起泡法、选择法、快速法、合并法排序)的时间复杂度,即元素比较次数和移动次数,来分析各种算法优缺点和适合排列何种序列。

达到在实际应用中选择合适的方法消耗最短的时间完成排序。

1.1所需完成的任务及要求任务:1)用程序实现插入法排序、起泡法、选择法、快速法、合并法排序;2)输入的数据形式为任何一个正整数,大小不限。

要求:排序后的数组是从小到大的;1.2程序实现的功能(1)使用随机函数实现数组初始化,生成多组元素个数不同的数组;(2)用列表打印出每种排序下的各趟排序结果;(3)打印使用各种排序算法以后元素比较和交换的次数;(4)设计合理的打印列表来打印。

2、总体设计(从总体上说明该题目的框架,用文字和图表说明)2.1 总体设计说明采用插入气泡,选择,快速,合并的方法实现各种排序算法,并且在实现过程中插入适当变量来实现计数元素交换次数和比较次数的统计。

对于每一趟比较之后元素顺序以及最后的结果使用单独的函数来实现,形成单独的一个模块;2.2 总体流程图2.3 各主程序详细流程图①主函数流程图:3、详细设计3.1 使用的算法思想(1)对主界面的menu菜单,在主函数里面用switch语句调用各个模块的功能调用;(2)在插入法时,其算法思想是:将第一个元素作为单独的一个数组独立出来,对剩下的元素,逐个与前面的数组从后往前进行比较,一旦发现当前的元素大于或是等于前面已经排序好的元素中某个元素,则在这个元素之后插入即可;(3)在起泡法时,其算法思想是:将待排序的数组从后往前,依次比较相邻的两个元素,如果发现逆序则交换序列,使得数值、比较小的元素逐渐往前排列,在这个算法时要用flag作为标记位,用来判断元素是否交换,用以减少不必要的交换次数;(4)对于选择法,其排序思想是:从第一个元素开始,并且标记当前元素的位置,比较后面所有的元素,找到其中最小的元素,也标记当前元素的位置,然后把两个标记位的元素进行交换,前面的标记位不断地向后移动,直到最后一个元素的位置,则排序完成;(5)对于快速法,其算法思想是:一般取数组中的第一个元素为基准,通过一趟排序将待排序元素分为左右两个子序列,左子序列的所有元素都小于或等于右子序列的所有元素,然后将左右两个序列按照与此相同的原理进行排序,直至整个序列有序为止,排序完成。

内部排序算法比较课程设计报告种基本排序

内部排序算法比较课程设计报告种基本排序

合肥学院计算机科学与技术系课程设计报告2017〜2018 学年第一学期课程课程设计名称学生姓名学号数据结构与算法内部排序算法比较操彦1504012027指导教师2017 年9 月1、问题分析和任务定义各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间,存在一定的却缺陷。

我们将通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受。

所设计的程序应能够将产生的随机数据同时用不同的内部排序算法排序,并列出关键字比较次数与移动次数,方便比较。

待排序表的表长不少于100,为方便起见,我们令表长等于100,用5组随机的数据排序的结果作比较。

2、数据结构的选择和概要设计一.可能排序表的抽象数据类型定义:ADT OrderableList {数据对象:D=個€ IntegerSet , i=1 , 2, ........... , n, n>0}数据关系:R1= { 已:| 丘:—L,机| € D,i=2, n}基本操作:Ini tList (n)操作结果:构造一个长度为n,元素值依次为1, 2, ....... , n的有序表。

Ran domizeList(d,is In verseOrder)操作结果:首先根据islnverseOrder 为True或False,将表置为逆序或正序,然后将表进行d (0< d< 8)级随机打乱。

d为0时表不打乱,d越大,打乱程度越高。

RecallList ()操作结果:恢复最后一次用Ran domizeList随机大乱的可排序表。

ListLe ngth ()操作结果:返回可排序的长度。

ListEmpty ()操作结果:若可排序表为空表,则返回True,否则返回False。

BubbleSort (&c, &s)操作结果:进行冒泡排序,返回关键字比较次数c和移动次数s。

InsertSort (&c, &s)操作结果:进行插入排序,返回关键字比较次数c和移动次数S。

数据结构内部排序算法比较

数据结构内部排序算法比较

数据结构内部排序算法比较一、引言二、基本概念1. 数据结构2. 排序算法三、内部排序算法分类1. 插入排序a. 直接插入排序b. 希尔排序2. 选择排序a. 简单选择排序b. 堆排序3. 交换排序a. 冒泡排序b. 快速排序4. 归并排序5. 基数排序四、内部排序算法比较分析1. 时间复杂度比较2. 空间复杂度比较3. 稳定性比较五、应用场景分析六、总结与展望一、引言数据结构是计算机科学中的重要组成部分,它是指数据元素之间的关系和组织方式。

而对于数据结构中的数据进行操作时,往往需要进行一些特定的操作,如查找、插入和删除等,这些操作都需要使用到排序算法。

因此,本文将从数据结构和内部排序算法两个方面来探讨内部排序算法的比较。

二、基本概念1. 数据结构数据结构是指相互之间存在一种或多种特定关系的数据元素集合。

其中,数据元素是指数据的基本单位,而关系则是指数据元素之间的相互联系。

2. 排序算法排序算法是对一组数据进行排序的一种算法。

其中,排序过程可以按照升序或降序排列,并且可以使用内部排序和外部排序两种方式进行。

三、内部排序算法分类内部排序算法是指将需要排序的数据全部加载到内存中进行操作的一种方式。

根据其实现方式不同,内部排序算法可以分为以下五类:1. 插入排序插入排序是将一个记录插入到已经排好序的有序表中,从而得到一个新的有序表。

它包括直接插入排序和希尔排序两种方式。

a. 直接插入排序直接插入排序是将待排记录按其大小依次插入到已经排好序的有序表中。

具体实现过程如下:1. 将第一个记录作为有序表。

2. 从第二个记录开始,依次将记录插入到已经排好序的有序表中。

3. 重复步骤2,直至所有记录都被插入到有序表中。

b. 希尔排序希尔排序是基于直接插入排序改进而来的一种算法。

它通过比较相隔一定间隔(称为增量)的元素来进行比较和移动。

具体实现过程如下:1. 将待排记录按照增量进行分组。

2. 对每个分组进行直接插入排序。

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

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

数据结构课程设计题目:内部排序算法的比较姓名:李吉倩学号:020*********系年级:计算机科学与技术2010级完成时间:2012.8-2012.9实验报告一、需求分析1.本程序对以下六种常用的内部排序进行实测比较:起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

2.待排序表的元素的关键字为整数,雍正徐、逆序和随机数产生器产生的随机数做测试比较。

比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换记为3次移动)。

3.程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”下,用户可由键盘输入产生随机数的种子,计算机终端显示各内部排序的比较参数。

4.最终对结果做出简单分析,包括对各组数据得出结果波动大小给予解释。

二、概要设计1.可排序表的抽象数据类型定义:ADT OrderableList{数据对象:D = {ai |ai∈IntegerSet,i = 1,2,……,n,n >= 0}数据关系:R1 = {<ai-1,ai>|ai-1,ai∈D.i = 2,……,n}基本操作:SelectListType(c)操作结果:打印提示信息,请用户选择待排序表的类型,顺序型、逆序型还是随机数组。

BubbleSort(&L)操作结果:进行起泡排序,返回排序后的顺序表InsertSort(&L)操作结果:进行插入排序,返回排序后的顺序表SelectSort(&L)操作结果:进行选择排序,返回排序后的顺序表QuickSort(&L)操作结果:进行快速排序,返回排序后的顺序表ShellSort(&L)操作结果:进行希尔排序,返回排序后的顺序表HeapSort(&L)操作结果:进行堆排序,返回排序后的顺序表SelectSortMethod(&L,c1)操作结果:打印提示信息,请用户选择排序方法,起泡排序、插入排序、选择排序、快速排序、希尔排序还是堆排序OutPut(L)操作结果:打印排序中关键字的比较次数和移动次数}ADT OrderableList2.本程序包含两个模块:1).主程序模块int mian(){初始化;用户选择待测表的类型;输入选择,用switch语句判断;While(“命令”!= “退出”){接受命令;处理命令;}}2).可排序表单元模块----实现可排序表的抽象数据类型各模块之间的调用关系:主程序模块可排序表单元模块三、详细设计1.根据题目要求何可排序表的基本操作特点,可排序表采用证书顺序表存储结构,并实现在头文件SqList.H。

内部排序算法比较课程设计报告(7种基本排序)

内部排序算法比较课程设计报告(7种基本排序)

合肥学院计算机科学与技术系课程设计报告2017 ~2018 学年第一学期课程数据结构与算法课程设计名称内部排序算法比较学生姓名操彦学号1504012027专业班级计算机科学与技术系15级2 班指导教师2017 年9 月1、问题分析和任务定义各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间,存在一定的却缺陷。

我们将通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受。

所设计的程序应能够将产生的随机数据同时用不同的内部排序算法排序,并列出关键字比较次数与移动次数,方便比较。

待排序表的表长不少于100,为方便起见,我们令表长等于100,用5组随机的数据排序的结果作比较。

2、数据结构的选择和概要设计一.可能排序表的抽象数据类型定义:ADT OrderableList{数据对象:D={|∈IntegerSet,i=1,2,……,n,n≥0}数据关系:R1={<,|,∈D,i=2,……n}基本操作:InitList(n)操作结果:构造一个长度为n,元素值依次为1,2,……,n的有序表。

RandomizeList(d,isInverseOrder)操作结果:首先根据isInverseOrder为True或False,将表置为逆序或正序,然后将表进行d(0≤d≤8)级随机打乱。

d为0时表不打乱,d越大,打乱程度越高。

RecallList()操作结果:恢复最后一次用RandomizeList随机大乱的可排序表。

ListLength()操作结果:返回可排序的长度。

ListEmpty()操作结果:若可排序表为空表,则返回True,否则返回False。

BubbleSort(&c,&s)操作结果:进行冒泡排序,返回关键字比较次数c和移动次数s。

InsertSort(&c,&s)操作结果:进行插入排序,返回关键字比较次数c和移动次数s。

SelectSort(&c,&s)操作结果:进行选择排序,返回关键字比较次数c和移动次数s。

数据结构 内部排序算法比较

数据结构 内部排序算法比较

内部排序算法比较1、课程设计的目的本课程设计为了更好的了解和认识数据结构常用的内部排序算法。

排序对于数据结构的管理来说是至关重要的,所以熟悉掌握和深入了解这些常用的经典内部排序算法是有必要的。

2、课程设计的要求1. 掌握常用的排序方法和各种排序方法的特点。

2.熟悉排序的基本概念。

3、课程设计的内容3.1需求分析编制一个演示内部排序算法比较的程序。

可对冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序和堆排序进行比较。

3.2概要设计(1)冒泡排序基本思想是:设数组a中存放了n 个数据元素,循环进行n-1次如下的排序过程:第一次时,依次比较相邻两个数据元素a[i]和a[i+1].key(i=0,1,2,3...,n-2).若为逆序,则交换两个数据元素,否则不交换,这样,当作完n-1次比较后数值最大的数据元素将比放置在a[n-1]中。

第二次时,数据元素个数减1,即数据元素个数为n-1,操作方法与第一次类似,这样,n个数据元素集合中数值次大的数据元素将被放置在a[n-2]中。

当第n-1次排序结束时,n个数据元素集合中次小的数据元素将被放置在a[1]中,而a[0]中放置了最小的数据元素。

冒泡排序算法的空间复杂度为o(n2)。

(2)直接插入排序基本思想是:顺序地把待插入的数据元素按其关键字的大小插入到已排序数据元素子集合的适当位置.子集合的数据元素个数从只有一个数据元素开始逐次增大,当子集合最终与集合大小相同时排序完毕.设待排序的N个数据元素存放在数组A中,初始时子集合a[0]以排好序.第一次循环准备把数据元素a[1]插入到以排好序的子集合中,这只需比较a[0].key和a[1].key,若a[0].key<=a[1].key,则说明序列已有序,否则,将a[1]插入到a[0]之前,这样子集合的大小增大为2;第二次循环是把数据元素a[2]插入到以排好序的子集合中,这需要先比较a[2].key和a[1].key,已确定是否需要把a[2]插到a[1]之前,然后比较a[2].key和a[0].key,以确定是否需要把a[2]插入到a[0]之前;这样的循环过程一直进行到a[n-1]插入完为止.这时,数据元素集合a[0],a[1],a[2],...,a[n-1]就全部排好了序。

数据结构实验报告:内部排序算法比较

数据结构实验报告:内部排序算法比较
# include "stdlib.h"
# define OVERFLOW -2
typedef struct
{ int * elem;
int length;
}SqList;
SqList create(int n)//建立一个顺序表
{ SqList L;
L.elem = (int *)malloc( n*sizeof(int));
T=QuickSort(T);
printf("排序后数据如下:\n");
for(int k=2;k<=n;k++)
printf("%6d",T.elem[k]);
printf("\n");
do
{ printf("如果想继续验证请输入Y或y,否则输入N或n:\n\n");
scanf("%s",&yes_no);
实验报告
课程名称:数据结构实验名称:内部排序算法比较任课教师:
专业:计网类班 级:2007级1班学号:
姓名:___________完成日期:2008年12月30日
一、实验目的:
掌握主要排序算法的基本思想,包括插入排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序及基数排序;掌握以上排序算法的实现方法;对各种算法的效率进行比较。
printf("%6d",L.elem[k]);
printf("\n");
}
} // InsertSort
void main()
{ SqList T;
int n=0,k,flag=0;
char yes_no;

数据结构课程设计实验报告-内部排序算法比较

数据结构课程设计实验报告-内部排序算法比较

内部排序算法比较【实验简介】1、在教科书各种内部排序算法的时间复杂度分析结果只给出了算法执行的时间的阶,或大概的执行时间,如:直接插入排序即时间复杂度为O(n*n)2、通过五组随机数据、一组正序数据与一组逆序数据比较6种常用的内部算法(起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序)的关键字比较次数和关键字移动次数,以取得直观感受;3、用五组不同的长度不小于100的数据进行测试,并对测试结果作出简单的分析,对得出结果拨动大小的进行解释;【设计模块】【对应模块算法说明】(1) 此算法程序中需要用到顺序表数据类型,数据元素的类型定义如下:typedef struct{KeyType key; //关键字项}RedType;typedef struct{RedType r[MAXSIZE+1]; //0号单元闲置或用作哨兵单元int length; //顺序表长度int info; //记录关键字移动次数int cmp; //关键字的比较次数}Sqlist;(2) 本实验用到六种排序算法,一个主函数和菜单函数,其中排序算法分别为起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序;相应时间复杂度分析如下:起泡排序:若待排序列为“正序”,则需进行一趟排序在排序过程中关键字需进行n-1次比较,无须移动纪录;若是“逆序”,则进行n-1趟排序,需n(n-1)/2次比较,并坐等数量级的移动,因此总的事件复杂度为O(n2);直接插入排序待排序纪录是随机的,关键字间的移动次数和比较次数的平均值约为n*n/4,即时间复杂度为O(n2);简单的选择排序虽然在排序过程中所需要的移动次数较少,最小时为0,最大时为3(n-1);但是关键字的比较次数总是相同的,均为n(n-1)/2,因此,时间复杂度亦为O(n2);快速排序其平均时间是kn*㏑n,其中n为待排序列中纪录的个数,k为某个常数,其时间复杂度为O(n*㏑n);希尔排序当增序序列为dlta[k]=2t-k+1-1时,时间复杂度为O(n3/2),其中t为排序趟数,1≤k≤t≤㏒2(n+1);堆排序此排序对于含n个元素的序列排序时,总共进行的关键字比较次数不超过4n,且在最坏的情况下,其时间复杂度为O(n*㏑n);算法分析如下:①冒泡排序该算法的的思路是首先将第1个记录的关键字负值给L.r[0],然后用L.r[0]与第(i+1)个记录的关键字比较,若为逆序,则交换第i与第i+1两记录的位置,然后让i加1,重复以上操作,直至i=n-1为止;依次进行第二趟、第三趟……作同样的操作,直至所有的记录按正序排列(一般需要n-1趟比较,第i趟从L.r[1]到L.r[n-i+1]依次比较,1≦ i ≦n-i,比较结果是让其中最大的记录放在L.r[n-i+1]的位置)void BubbleSort(Sqlist *L) //冒泡排序{for(i=0;i<L->length;i++){L->r[0]=L->r[1];for(j=1;j<N-i;j++)if(L->r[0].key>=L->r[j+1].key)L->r[j] L->r[j+1]; //交换两记录的位置elseL->r[0]=L->r[j+1]; //保证L->r[0]始终为较大的记录L->r[j+1]=L->r[0]; //把最大的记录放到祠堂排序的最高位置}printf(L->r[MAXSIZE]);//输出排序后数组和相关数据}②直接插入排序本算法的思路是,把L->r[0]设置为哨兵,排序时把第i个记录复制给哨兵,并于其前的i-1个记录进行比较,找到第一个比起大的记录,利用循环让记录后移,把其放到第一个比起大的记录前面。

(完整word版)数据结构课程设计-排序算法比较【完整版】(word文档良心出品)

(完整word版)数据结构课程设计-排序算法比较【完整版】(word文档良心出品)

XXXXXX大学《数据结构》课程设计报告目录排序算法比较一、需求分析二、程序的主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码二感想体会与总结排序算法比较一、需求分析利用随机函数产生N个随机整数(N = 500, 1000, 1500, 2000,2500, …,30000), 利用直接插入排序、折半插入排序, 起泡排序、快速排序、选择排序、堆排序, 基数排序七种排序方法(可添加其它排序方法)进行排序(结果为由小到大的顺序), 并统计每一种排序所耗费的时间(统计为图表坐标形式)。

二、程序的主要功能1.用户输入任意个数, 产生相应的随机数2.用户可以自己选择排序方式(直接插入排序、折半插入排序、起泡排序、快速排序、选择排序、堆排序、基数排序)的一种3.程序给出原始数据、排序后从小到大的数据, 并给出排序所用的时间。

三、程序运行平台Visual C++ 6.0版本四、数据结构本程序的数据结构为线形表, 线性顺序表、线性链表。

1.结构体:typedef struct{int *r; //r指向线形表的第一个结点。

r[0]闲置, 不同的算法有不同的用处, 如用作哨兵等。

int length; //顺序表的总长度}Sqlist;2.空线性表Status InitSqlist(Sqlist &L){L.r=(int *)malloc(MAXSIZE*sizeof(int)); //分配存储空间if(!L.r){printf("存储分配失败!");exit(0);} //存储分配失败L.length=0;//初始长度为0return OK;}五、算法及时间复杂度(一)各个排序是算法思想:(1)直接插入排序: 将一个记录插入到已排好的有序表中, 从而得到一个新的, 记录数增加1的有序表。

(2)折半插入排序: 插入排序的基本插入是在一个有序表中进行查找和插入, 这个查找可利用折半查找来实现, 即为折半插入排序。

内部排序算法的实现与比较-数据结构课程设计

内部排序算法的实现与比较-数据结构课程设计

内部排序算法的实现与⽐较-数据结构课程设计内部排序算法的实现与⽐较1)问题描述在教科书中,各种内部排序算法的时间复杂度分析结果只给出了算法执⾏时间的阶,或⼤概执⾏时间。

试通过随机数据⽐较各算法的关键字⽐较次数和关键字移动次数,以取得直观感受。

2)基本要求(1) 对常⽤的内部排序算法进⾏⽐较:直接插⼊排序、简单选择排序、冒泡排序、快速排序、希尔排序、归并排序。

(2) 利⽤随机函数产⽣N(N=30000)个随机整数,作为输⼊数据作⽐较;⽐较的指标为关键字参加的⽐较次数和关键字的移动次数(关键字交换计为3次移动)。

(3) 对结果作出简要分析。

3)测试数据随机函数产⽣。

4)提⽰主要⼯作是设法在已知算法中适当位置插⼊对关键字的⽐较次数和移动次数的计数操作。

注意采⽤分块调试的⽅法。

5)输⼊输出:输⼊数据:参加排序的整数个数N(N=30000,注:不得减少N);输出数据:各种排序⽅法的关键字⽐较次数和移动次数(从⼩到⼤排列)。

本来冒泡排序交换次数想⽤树状数组BIT发现数据太多时 ⽤BIT加的数据会超限 所以还是直接⽤了冒泡排序上代码--纯C语⾔:/** zhagoodwell 查昊昊QQ微信:2423824433* 直接插⼊: charu函数* 选择: xuanzepai函数* 冒泡: maopao函数* 快排: Qsort 递归函数* 希尔:shell 函数* 归并:GB 函数*/# include <stdio.h># include <stdlib.h># include <time.h># define N 30000# define SR 1001int A[N],B[N],C[N],D[N],E[N],F[N],G[N];int a,aa,b,bb,d,dd,e,ee,f,ff,num; //单个字母的为记录的⽐较次数-移动的次数,双字母为关键字的移动次数long long c,cc;void charu(int A[],int n);//对n个元素直接插⼊排序void xuanzepai(int A[],int n);//对n个元素选择升序void maopao(int A[],int n); // 冒泡排序void Quicksort(int A[],int L,int R);//对[L,R]个元素快速升序void shell(int A[],int n);//对n个元素 shell 升序void GBPX(int S[],int L,int R,int T[]);// 归并排序int GB(int S[],int L,int M,int R,int T[]);//数组归并操作int gainint(int *p,int min,int max);//防输错⽽建的函数 *p的范围[min,max]int change(int *a,int *b);//交换函数交换a b的值void charu(int A[],int n)//返回循环⽐较次数int i,j,temp;for (i=1,a++;i<n;i++,a++)if (A[i]<A[i-1]){temp=A[i];for(a++,aa++,j=i-1;j>=0&& A[j]>temp;j--,a++,aa++) A[j+1]=A[j];A[j+1]=temp;}}void xuanzepai(int A[],int n)//以A[0]为⽐较依据升序{int i,j,k;for(i=0,b++;i<n-1;i++,b++){k=i;for(j=i+1,b++;j<n;j++,b++)if(A[j]<A[k]){ k=j;b++;}if(k!=i){bb+=change(&A[i],&A[k]);}}}void maopao(int A[],int n){int i,j;for (i = n -1 ; i>=0 ;i--){for (j = 0; j<i; j++){if(A[j]>A[j+1])cc+=change(&A[j],&A[j+1]);}}}void Quicksort(int A[],int L,int R)//快速排序升序{int i=L,j=R,T=A[L]; //T为基准数if(L>R) return;while(i!=j) //当数组左右两边没相遇{while(A[j]>=T&&i<j){j--;d++;} //从右向左找while(A[i]<=T&&i<j){i++;d++;} //从左向右找if(i<j)dd+=change(&A[i],&A[j]); //交换两数}if(L!=i)dd+=change(&A[L],&A[i]); //基准数归位Quicksort(A,L,i-1); //递归左Quicksort(A,i+1,R); //递归右}void shell(int A[],int n)//希尔排序增量为2{int i,j,k;for(k=n>>1,e++;k>0;k=k>>1,e++){for(i=k,e++;i<n;i++,e++){for(j=i-k,e++;j>=0;j-=k,e++)if(A[j]>A[j+k])ee+=change(&A[j],&A[j+k]);}}int GB(int S[],int L,int M,int R,int T[])//数组归并操作{int i=M,j=R,k=0,count=0;while(i>=L&&j>M){f++;if(S[i]>S[j]){T[k++]=S[i--];//从临时数组的最后⼀个位置开始排序}else T[k++]=S[j--];count++;}while(i>=L){f++;T[k++]=S[i--];} //若前半段数组还有元素未放⼊临时数组T中while(j>M){f++;T[k++]=S[j--];}for(i=0,f+=k;i<k;i++) S[R-i]=T[i];//写回原数组return count;}void GBPX(int S[],int L,int R,int T[]){int M;if(L<R){M=(L+R)>>1;GBPX(S,L,M,T);//找左半段的逆序对数⽬GBPX(S,M+1,R,T);//找右半段的逆序对数⽬ff+=GB(S,L,M,R,T);//找完左右半段逆序对以后两段数组有序,找两段之间的逆序对。

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

数据结构实训目录一、问题描述 (2)二、系统分析 (2)三、系统设计 (3)(1)友好的人机界面设计: (3)(2)方便快捷的操作:用户只需要根据不同的需要在界面上输入系统提醒的操作形式直接进行相应的操作方式即可! (3)(3)系统采用定义结构体数组来存储数据 (3)(4)功能介绍: (3)四、系统实现 (4)定义结构体数组 (4)直接排序 (4)简单选择排序 (5)冒泡排序 (5)堆排序 (6)归并排序 (6)快速排序 (7)电脑随机取数 (8)用户自行输入 (8)主函数调用 (9)五、系统测试 (10)随机取数的测试: (10)自行输入的测试: (11)退出系统: (11)时间的估算: (11)六、参考文献 (12)七、实训体会 (12)姓名:学号:联系方式:内部排序算法比较一、问题描述排序是数据结构中重要的一个部分,也是在实际开发中易遇到的问题,所以研究各种排算法的时间消耗对于在实际应用当中很有必要通过分析实际结合算法的特性进行选择和使用哪种算法可以使实际问题得到更好更充分的解决!该系统通过对各种内部排序算法如直接插入排序,冒泡排序,简单选择排序,快速排序,希尔排序,堆排序、二路归并排序等,以关键码的比较次数和移动次数分析其特点,并进行比较,估算每种算法的时间消耗,从而比较各种算法的优劣和使用情况!排序表的数据是多种不同的情况,如随机产生数据、极端的数据如已是正序或逆序数据。

比较的结果用一个直方图表示。

二、系统分析界面的设计如图所示:|*****************************||--------欢迎使用-------||------(1)随机取数-----||------(2)自行输入-----||------(0)退出使用-----||*****************************|请选择操作方式:如上图所示该系统的功能有:(1):选择 1 时系统由客户输入要进行测试的元素个数由电脑随机选取数字进行各种排序结果得到准确的比较和移动次数并打印出结果。

(2)选择 2 时系统由客户自己输入要进行测试的元素进行各种排序结果得到准确的比较和移动次数并打印出结果。

(3)选择0 打印“谢谢使用!!”退出系统的使用!!三、系统设计(1)友好的人机界面设计:|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|(2)方便快捷的操作:用户只需要根据不同的需要在界面上输入系统提醒的操作形式直接进行相应的操作方式即可!|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|请选择操作方式:(用户在此输入操作方式)(3)系统采用定义结构体数组来存储数据(4)功能介绍:①操作功能:a .当用户选择随即电脑随机取数时系统将弹出——>请输入你要输入的个数:(用户在此输入要电脑取数的个数)要是用户输入的数据过大系统将提醒错误——>超出范围重新输入!!!b . .当用户选择自行输入时系统将弹出——>请输入你要输入的个数(不大于于30的整数):当用户输完元素的个数之后系统将提示用户依次输入各个元素。

——>请输入各个元素:②排序功能:系统有简单选择排序,冒泡排序,堆排序,二路归并排序,快速排序的功能。

③打印清晰:系统会打印出在排序操作之前电脑随机取数或者用户输入的原始排列顺序;并将排序操作之后的有序数据打印在原始数据的下面以便用户的对比。

在排序操作结束之后系统将以直方图的形式打出排序过程中比较和移动次数让客户一目了然地看到排序的结果:四、系统实现定义结构体数组typedef struct{ int key;} datatype;datatype R[MAXNUM];//定义结构体数组直接排序void D_InsertSort(datatype R[ ], int n)//直接排序{int i,j;for(i=2; i<=n; i++){ cn[0]++;if (R[i].key<R[i-1].key){R[0]=R[i]; mn[0]++;for(j=i-1; R[0].key<R[j].key; j--)R[j+1]=R[j];R[j+1]=R[0]; mn[0]+=2;}}}简单选择排序void Select_Sort(datatype R[ ],int n)//简单选择排序{int i,j,k;for(i=1;i<n;i++){ k=i;for(j=i+1; j<=n; j++){cn[1]++;if(R[j].key<R[k].key)k=j;}if (i=k){ R[0]=R[k];R[k]=R[i];R[i]=R[0]; mn[1]+=3; }}}冒泡排序void Bubble_Sort (datatype R[ ], int n)//冒泡排序{int i, j;int swap;for(i=1; i<n-1; i++){swap=0;for(j=1; j<=n-i; j++){cn[2]++;if (R[j].key<R[j+1].key){R[0]=R[j];R[j]=R[j+1];R[j+1]=R[0]; mn[2]+=3;swap=1;}}if(swap==0) break;}}堆排序void HeapAdjust(datatype R[ ], int s, int t){datatype rc;int i,j ;rc=R[s];i=s;for(j=2*i; j<=t; j=2*j){ cn[3]++;if(j<t && R[j].key<R[j+1].key)j=j+1;if(rc.key > R[j].key) break;R[i]=R[j]; mn[3]++;i=j;}R[i]=rc;}void HeapSort(datatype R[ ], int n)//堆排序{int i;for(i=n/2; i>0; i-- )HeapAdjust(R, i, n);for(i=n; i>1; i--){ R[0]=R[1];R[1]=R[i];R[i]=R[0]; mn[3]+=3;HeapAdjust(R,1, i-1);}}归并排序void Merge(datatype R[ ], datatype R1[ ], int s, int m , int t) {int i,j,k;i=s; j=m+1; k=s;while (i<=m&&j<=t){cn[4]++;if(R[i].key<R[j].key){ R1[k++]=R[i++]; mn[4]++;}else{ R1[k++]=R[j++]; mn[4]++;}}while (i<=m) { R1[k++]=R[i++]; mn[4]++; }while (j<=t) { R1[k++]=R[j++]; mn[4]++;}}void MSort(datatype R[ ], datatype R1[ ], int s, int t){int m;if(s==t) { R1[s]=R[s]; mn[4]++;}else {m=(s+t)/2;MSort(R, R1, s, m);MSort(R, R1, m+1, t);Merge(R1, R, s, m, t);}}void MergeSort(datatype R[ ], datatype R1[ ], int n)//归并排序{MSort(R, R1,1, n);}int Partition(datatype R[ ], int low, int high){R[0]=R[low]; mn[5]++;while(low<high){ while(low<high&&R[high].key>=R[0].key) {cn[5]++; high--;}if(low<high) { R[low]=R[high]; low++; mn[5]++; }while(low<high&&R[low].key<R[0].key) { mn[5]++; low++; } if(low<high) {R[high]=R[low]; high--; mn[5]++; }}R[low]=R[0]; mn[5]++;return low;}快速排序void Quick_Sort(datatype R[ ], int s, int t)//快速排序{int i;if( s<t ){i = Partition(R, s, t);Quick_Sort(R, s, i-1);Quick_Sort(R, i+1, t);}}void prin(datatype R[],int n){int i ;printf("排序的结果为:");for(i=1;i<=n;i++)printf("%d ",R[i]);printf("\n ");}电脑随机取数void sui_ji(){int i,n;datatype R[MAXNUM]={0};a: printf("请输入你要输入的个数:");scanf("%d",&n);if(n>25){printf("超出范围重新输入!!!\n");goto a;}addlist(R,n);printf("排序前元素顺序为:");for(i=1;i<n+1;i++) printf("%d ",R[i].key);printf("\n");D_InsertSort(R,n);//直接排序prin(R,n);Select_Sort(R,n);//简单选择排序Bubble_Sort(R, n);//冒泡排序HeapSort(R, n);//堆排序datatype R1[MAXNUM]={0};MergeSort(R, R1, n);//二路归并排序Quick_Sort(R,0, n);//快速排序}用户自行输入void zixing_input(){ int n,i;datatype R1[MAXNUM]={0};printf("请输入你要输入的个数(不大于于30的整数):");scanf("%d",&n);printf("请输入各个元素:");for(i=1;i<n+1;i++)scanf("%d",&R1[i].key);printf("排序前元素顺序为:");for(i=1;i<n+1;i++) printf("%d ",R1[i].key);printf("\n");D_InsertSort(R1,n);//直接排序prin(R1,n);Select_Sort(R1,n);//简单选择排序Bubble_Sort(R1, n);//冒泡排序HeapSort(R1, n);//堆排序datatype R2[MAXNUM]={0};MergeSort(R1, R2, n);//二路归并排序Quick_Sort(R1,0, n);//快速排序}主函数调用int main(void){int s;printf(" |******************************|\n");printf(" |-------欢迎使用-----------------|\n");printf(" |-----(1)随机取数-------------|\n");printf(" |-----(2)自行输入-------------|\n");printf(" |-----(0)退出使用-------------|\n");printf(" |******************************|\n");printf(" 请选择操作方式:");scanf("%d",&s);switch(s){case 1: system("cls") ; sui_ji(); break;case 2: system("cls") ; zixing_input(); break;case 0: printf(" 谢谢使用!!"); exit(0); break;}printf("\n ");printf(" 比较结果\n");printf(" \n");printf(" 排序方式比较次数移动次数\n");printf(" \n");printf(" 直接%d %d \n",cn[0],mn[0]); printf(" \n");printf(" 简单选择%d %d \n",cn[1],mn[1]); printf(" \n");printf(" 冒泡%d %d \n",cn[2],mn[2]); printf(" \n");printf(" 堆排序%d %d \n",cn[3],mn[3]);printf(" \n");printf(" 二路归并%d %d \n",cn[4],mn[4]);printf(" \n");printf(" 快速%d %d \n",cn[5],mn[5]);}五、系统测试随机取数的测试:自行输入的测试:退出系统:时间的估算:六、参考文献数据结构(c语言版)清华大学出版社严蔚敏吴伟民编著数据结构题集(c语言版)清华大学出版社严蔚敏吴伟民米宁编著七、实训体会本学期我们学习了数据结构这门课程,虽说是今年才开的,但基于上学期的C语言实训,也不能说我们毫无基础可言。

相关文档
最新文档