排序算法数据结构课程设计说明书

合集下载

数据结构课程设计-排序

数据结构课程设计-排序

一、问题描述1、排序问题描述排序是计算机程序设计的一种重要操作,他的功能是将一组任意顺序数据元素(记录),根据某一个(或几个)关键字按一定的顺序重新排列成为有序的序列。

简单地说,就是将一组“无序”的记录序列调整为“有序”的记录序列的一种操作。

本次课程设计主要涉及几种常用的排序方法,分析了排序的实质,排序的应用,排序的分类,同时进行各排序方法的效率比较,包括比较次数和交换次数。

我们利用java语言来实现本排序综合系统,该系统包含了:插入排序、交换排序、选择排序、归并排序。

其中包括:(1)插入排序的有关算法:不带监视哨的直接插入排序的实现;(2)交换排序有关算法:冒泡排序、快速排序的实现;(3)选择排序的有关算法:直接选择排序、堆排序的实现;(4)归并排序的有关算法:2-路归并排序的实现。

2、界面设计模块问题描述设计一个菜单式界面,让用户可以选择要解决的问题,同时可以退出程序。

界面要求简洁明了,大方得体,便于用户的使用,同时,对于用户的错误选择可以进行有效的处理。

二、问题分析本人设计的是交换排序,它的基本思想是两两比较带排序记录的关键字,若两个记录的次序相反则交换这两个记录,直到没有反序的记录为止。

应用交换排序基本思想的主要排序方法有冒泡排序和快速排序。

冒泡排序的基本思想是:将待排序的数组看作从上到下排列,把关键字值较小的记录看作“较轻的”,关键字值较大的纪录看作“较重的”,较小关键字值的记录好像水中的气泡一样,向上浮;较大关键字值的纪录如水中的石块向下沉,当所有的气泡都浮到了相应的位置,并且所有的石块都沉到了水中,排序就结束了。

冒泡排序的步骤:1)置初值i=1;2)在无序序列{r[0],r[1],…,r[n-i]}中,从头至尾依次比较相邻的两个记录r[j]与r[j+1](0<=j<=n-i-1),若r[j].key>r[j+1].key,则交换位置;3)i=i+1;4)重复步骤2)和3),直到步骤2)中未发生记录交换或i=n-1为止;要实现上述步骤,需要引入一个布尔变量flag,用来标记相邻记录是否发生交换。

数据结构七个排序课程设计

数据结构七个排序课程设计

数据结构课程设计报告题目:排序的实现专业:软件工程班级:1502学号:姓名:时间:2016-12-26—2017-1-6一、问题描述1.题目内容:排序算法实现。

2.基本要求:用C语言或者C++设计一个排序综合系统。

3.测试数据:手写输入数据。

二、需求分析1.程序所能达到的基本功能。

1)设计一个菜单,格式如下:1.选择排序2.插入排序-3.起泡排序4.快速排序5.归并排序6.堆排序7.基数排序8.重新输入数据9.退出2)选择不同的菜单但进行相应的排序,并给出排序的关键字序列。

求出该排序算法运行时间,比较各排序间效率。

2.输入的形式和输入值的范围:所有整型的数。

3.输出的形式:从小到大输出排序结果和运行时间。

4.测试数据要求。

输入元素个数为正整数。

输入将要排序的数都为整型。

三、概要设计1.所需的ADT,它们的作用。

ADT SORT{数据对象:D=用户输入n数据元素;基本操作:void ShuRu(SqList &L); ------------------- 用户输入Void SelectSort(SqList &L);------------------- 选择排序void nsertSort(SqList &L); ------------------- 插入排序-void BBubbleSort(SqList &L); ------------------- 起泡排序void QuickSort(SqList &L); ------------------- 快速排序void MergeSort(SqList &L); ------------------- 归并排序void HeapSort(SqList &L); ------------------- 堆排序void RadixSort(SqList &L) ------------------- 基数排序}ADT SORT2.主程序流程及模块调用关系。

排序的数据结构课程设计

排序的数据结构课程设计

排序的数据结构课程设计一、教学目标本课程旨在让学生理解排序算法的原理和应用,掌握常见的排序算法,如冒泡排序、选择排序、插入排序等,培养学生分析问题、解决问题的能力,并提高学生的逻辑思维和编程实践能力。

1.理解排序算法的概念和作用;2.掌握冒泡排序、选择排序、插入排序等常见排序算法的原理和实现;3.了解排序算法的应用场景。

4.能够运用排序算法解决实际问题;5.能够编写程序实现常见的排序算法;6.能够分析排序算法的效率和适用条件。

情感态度价值观目标:1.培养学生对计算机科学和编程的兴趣和热情;2.培养学生勇于探索、积极思考的科学精神;3.培养学生团队协作、相互帮助的良好学习习惯。

二、教学内容本课程的教学内容主要包括排序算法的原理、实现和应用。

具体安排如下:第1课时:排序算法概述1.1 排序的概念和作用1.2 排序算法的分类和评价指标第2课时:冒泡排序2.1 冒泡排序的原理2.2 冒泡排序的实现2.3 冒泡排序的效率分析第3课时:选择排序3.1 选择排序的原理3.2 选择排序的实现3.3 选择排序的效率分析第4课时:插入排序4.1 插入排序的原理4.2 插入排序的实现4.3 插入排序的效率分析第5课时:排序算法的应用5.1 排序算法在实际问题中的应用5.2 排序算法的选择和优化三、教学方法本课程采用讲授法、讨论法和实验法相结合的教学方法。

1.讲授法:通过教师的讲解,让学生掌握排序算法的原理和实现;2.讨论法:通过小组讨论,让学生深入理解排序算法,提高解决问题的能力;3.实验法:通过编写程序,让学生动手实践,培养学生的编程能力和实际应用能力。

四、教学资源1.教材:《数据结构与算法》;2.参考书:《算法导论》、《排序与搜索》;3.多媒体资料:课件、教学视频;4.实验设备:计算机、编程环境。

五、教学评估本课程的评估方式包括平时表现、作业和考试三个部分,以全面、客观、公正地评价学生的学习成果。

1.平时表现:通过课堂参与、提问、小组讨论等环节,评估学生的学习态度和理解能力,占总评的30%。

排序算法课课程设计书

排序算法课课程设计书

排序算法课课程设计书一、教学目标本节课的学习目标主要包括以下三个方面:1.知识目标:学生需要掌握排序算法的概念、原理和常见的排序算法(如冒泡排序、选择排序、插入排序等);理解排序算法的应用场景和性能特点,能够根据实际问题选择合适的排序算法。

2.技能目标:学生能够运用排序算法解决实际问题,具备编写排序算法代码的能力;能够对给定的数据集进行排序,并分析排序算法的执行时间和空间复杂度。

3.情感态度价值观目标:培养学生对计算机科学和算法的兴趣,使其认识算法在实际生活中的重要性,培养学生的创新意识和团队合作精神。

通过对本节课的学习,学生应能够了解排序算法的相关知识,掌握常见的排序算法,具备运用排序算法解决实际问题的能力,并培养对计算机科学和算法的兴趣。

二、教学内容本节课的教学内容主要包括以下几个部分:1.排序算法的概念和原理:介绍排序算法的定义、分类和性能评价指标。

2.常见排序算法:讲解冒泡排序、选择排序、插入排序等基本排序算法,并通过实例演示其实现过程。

3.排序算法的应用场景和性能特点:分析不同排序算法在实际应用中的优缺点,引导学生根据问题特点选择合适的排序算法。

4.排序算法的代码实现:让学生动手编写排序算法代码,培养其编程能力。

5.排序算法的执行时间和空间复杂度分析:讲解排序算法的时间复杂度、空间复杂度概念,并分析不同排序算法的复杂度。

通过对本节课的教学内容的学习,学生应能够掌握排序算法的相关知识,了解常见的排序算法,并具备运用排序算法解决实际问题的能力。

三、教学方法为了提高教学效果,本节课将采用以下教学方法:1.讲授法:教师讲解排序算法的相关概念、原理和算法实现,引导学生掌握排序算法的基本知识。

2.案例分析法:通过分析实际应用场景,让学生了解排序算法的应用价值和性能特点。

3.实验法:让学生动手编写排序算法代码,培养其编程能力和实际操作能力。

4.讨论法:分组讨论排序算法的优缺点,引导学生学会分析问题、解决问题。

数据结构课程设计——拓扑排序

数据结构课程设计——拓扑排序

数据结构课程设计——拓扑排序数据结构课程设计——拓扑排序1、引言拓扑排序是一种对有向无环图(DAG)进行排序的算法,它可以用来确定一组任务的执行顺序,或者检测图中是否存在环。

本文档旨在介绍拓扑排序的基本概念、算法原理以及实现过程。

2、基本概念2.1 有向图有向图是由一组顶点和一组有向边组成的图,每条边都有一个方向。

在有向图中,顶点表示实体,有向边表示实体之间的关系。

2.2 DAGDAG(Directed Acyclic Graph)是一种无环有向图,即不存在从某个顶点出发经过若干个有向边后能够回到该顶点的路径。

3、算法原理拓扑排序算法基于有向无环图的性质,通过选择没有前驱的顶点,将该顶点及其对应的边从图中删除,并将该顶点加入到排序结果中。

重复这个过程,直到所有顶点都被加入到排序结果中,或者图中存在环。

4、算法步骤4.1 初始化创建一个数组inDegree,并将所有顶点的入度初始化为0。

创建一个队列queue,并将所有入度为0的顶点入队。

4.2 执行拓扑排序4.2.1 从队列中取出一个顶点vertex。

4.2.2 将vertex加入到排序结果中。

4.2.3 遍历vertex的所有邻接顶点neighbor。

\t- 将neighbor的入度减1:\t- 如果neighbor的入度为0,将其入队。

4.2.4 重复步骤4.2.1至4.2.3,直到队列为空。

5、实现过程5.1 定义数据结构我们可以使用一个邻接表来表示有向图,其中每个顶点对应一个链表,链表中存储了该顶点指向的邻接顶点。

5.2 实现拓扑排序算法```function topologicalSort(graph):inDegree = new Array(graph:numOfVertices):fill(0) queue = new Queue()result = []// 初始化入度数组for each vertex in graph:vertices:for each neighbor in vertex:neighbors:inDegree[neighbor]++// 将入度为0的顶点入队for each vertex in graph:vertices:if inDegree[vertex] == 0:queue:enqueue(vertex)// 执行拓扑排序while queue is not empty:vertex = queue:dequeue()result:push(vertex)for each neighbor in vertex:neighbors:inDegree[neighbor]--if inDegree[neighbor] == 0: queue:enqueue(neighbor) return result```6、附件本文档不涉及任何附件。

数据结构课程设计-扑克牌的排序

数据结构课程设计-扑克牌的排序

课程设计报告课程设计名称:数据结构课程设计课程设计题目:扑克牌的排序目录1 课程设计介绍 (1)1.1课程设计内容 (1)1.2课程设计要求 (1)2 课程设计原理 (2)2.1课设题目粗略分析 (2)2.2原理图介绍 (2)2.2.1 功能模块图 (2)2.2.2 流程图分析 (3)3 数据结构分析 (6)3.1存储结构 (6)3.2算法描述 (6)4 调试与分析 (12)4.1调试过程 (12)4.2程序执行过程 (12)参考文献 (15)附录(关键部分程序清单) (16)1 课程设计介绍1.1 课程设计内容编写算法能够用基数排序算法对扑克牌进行排序。

应能够选择按花色优先或按面值优先,初始扑克牌牌序要求能自动生成(随机生成)。

1.2课程设计要求1.花色的符号可自定,输出要求给出初始牌序和结果牌序。

2.参考相应资料,独立完成课程设计任务。

3.交规范课程设计报告和软件代码。

2 课程设计原理2.1 课设题目粗略分析根据课设题目要求,拟将整体程序分为三大模块。

此三个模块相互独立,没有嵌套调用的情况,以下是三个模块的大体分析:1.建立一个结构体数组存放整副扑克。

2.根据要求的扑克数及生成的随机数建立一个结构体数组存放需要排序的扑克。

3.用基数排序的方法对随机生成的扑克进行相应要求的排序2.2 原理图介绍2.2.1 功能模块图图2. 1 功能模块图2.2.2 流程图分析1图2.2生成随机扑克的流程图利用一个for循环及随机函数rand(),利用每次循环生成的随机数对应的数值num建立初始的无序扑克,同时将huase、value分别赋给关键字key[0]、key[1]以对其进行排序2. 对扑克进行花色优先排序的函数流程图,如图2.3所示:图2.3对扑克进行花色优先排序的流程图对长为n的数组R,利用next域建立为静态链表,进行关键字先key[1](面值)后key[0](花色)的基数排序,排序后的数组按关键字key[0](花色)优先的顺序存放,利用静态链表依次将其输出。

C语言课程设计说明书排序算法系统设计(实用)文档

C语言课程设计说明书排序算法系统设计(实用)文档

C语言课程设计说明书排序算法系统设计(文档可以直接使用,也可根据实际需要修改使用,可编辑欢迎下载)摘要C是一种通用的程序设计语言,C语言在很多方面继承和发展了以往许多高级程序设计语言的成功经验和特色,具有书写格式自由、数据类型丰富、语句功能强大、执行速度快和存储控制能力强等优点。

排序算法系统设计是关于顺序表排序算法来设计的一个系统。

整个系统从符合操作简便、界面友好、灵活、实用、安全的要求出发,完成顺序表排序算法的全过程,包括直接插入排序、二分法插入排序、直接选择排序、冒泡排序、两路冒泡排序、分块归并排序、归并排序以及重新生成随机数组。

本课程主要介绍了本课题的开发背景,所要完成的功能和开发的过程。

重点说明了系统的设计思路、总体设计、各个功能模块的设计与实现方法。

关键词:排序算法系统,C语言,数据结构,CFreeV5.0目录1课题背景的介绍 (1)1.1 课题背景 (1)1.2 目的 (1)2需求分析 (2)2.1 数据需求分析 (2)2.2 功能需求分析 (2)3系统总体设计 (3)3.1 系统模块划分 (3)3.2 系统模块结构图 (3)4系统详细设计 (4)4.1 系统主界面设计 (4)4.2初始化学生信息 (5)4.3查找学生信息 (6)4.4删除学生信息 (8)4.5更新学生信息 (9)4.6排序...................................................................................................... 错误!未定义书签。

4.7统计学生信息...................................................................................... 错误!未定义书签。

4.8插入学生信息...................................................................................... 错误!未定义书签。

数据结构课程设计:快速排序

数据结构课程设计:快速排序

学号武汉理工大学华夏学院课程设计课程名称数据结构题目:用C语言实现成绩表的快速排序程序设计专业软件工程班级姓名成绩指导教师2009 年6月28日至2009年7月3 日课程设计任务书设计题目:用C语言实现成绩表的快速排序程序设计设计目的1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法;2.选择合适的数据的逻辑结构和存储结构以及相应操作,实现一个班的成绩统计3. 提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养;设计任务(在规定的时间内完成下列任务)〔问题描述〕给出n个学生的1门课程的考试成绩信息,每条信息由姓名与分数组成,要求设计快速排序算法,进行:(1)按成绩排序;(2)输出形式为:张强张平曾芽王华孙军李应程滨90888278706965〔基本要求〕学生的考试成绩必须通过键盘输入,且需对输出进行格式控制;〔算法提示〕利用快速排序算法求解;具体要完成的任务是:A.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。

B.写出规范的课程设计报告书;时间安排6月 29日布置课程设计任务,查阅相关资料,确定设计课题;6月 30日查阅资料、准备程序;6月30~7月2日上机调试程序、教师验收程序、书写课程设计报告;7月3 日下午4点前提交课程设计报告及相关文档。

具体要求1. 课程设计报告按统一通用格式书写,具体内容如下:①设计任务与要求②总体方案与说明③软件主要模块的流程图④源程序清单与注释⑤问题分析与解决方案(包括调式报告,即在调式过程中遇到的主要问题、解决方法及改进设想);⑥小结与体会附录:①源程序(必须有简单注释)②使用说明③参考资料2.每位学生应独立完成各自的任务且每天至少在设计室工作半天;指导教师签名:09 年6月27日教研室主任(或责任教师)签名:09 年6月28日成绩表的快速排序程序设计一、实验报告实验目的1.掌握用Turbo C 上机调试常规算法的程序;2.掌握快速排序的基本方法和过程;基本原理与方法:利用快速排序算法原理用C语言编程实现实验设备:PC机一台、配置Turbo C软件二、实验内容[问题描述] 对于用户输入的数据序列,用快速排序法按从大到小或从小到大两种顺序进行排序,并显示每一趟的排序过程;[基本要求] 采用递归算法和非递归算法两种算法;[算法实现] 采用快速排序原理编写C程序;[基本思想] 通过一趟排序将待排序记录分割成独立的两个区间,其中左区间记录的关键字的值均比右区间中记录的关键字的值小,再分别对这两个区间中的记录进行快速排序,以达到整个序列有序为止。

《数据结构》课程设计报告实验五 排序

《数据结构》课程设计报告实验五 排序

《数据结构》课程设计报告实验五排序一、需求分析:本演示程序用C++6.0编写,完成各种排序的实现,对输入的一组数字实现不同的排序方法,对其由小到大顺序输出。

(1)分别对直接插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序算法进行编写。

(2)、对存储的函数即输入的数字进行遍历。

(3)、初始化函数对输入的数字进行保存。

(4)、主函数实现使用者操作界面的编写,对输入、选择、保存、输出的各种实现。

这当中还包括了各个函数的调用的实现。

(5)、程序所能达到的功能:完成对输入的数字的生成,并通过对各排序的选择实现数字从小到大的输出。

二、程序主要功能以及基本要求:(1)、设计一个菜单,格式如下:1、直接插入排序2、希尔排序3、冒泡排序4、快速排序5、选择排序6、堆排序7、退出(2)、选择不同的菜单但进行相应的排序,并给出排序的关键字序列。

三、系统框架图:本程序包含了9个函数,它们分别是:(1)、直接插入排序的算法函数InsertSort ()。

(2)、希尔排序的算法函数(3)、冒泡排序算法函数(4)、快速排序的算法函数(5)、选择排序算法函数(6)、堆排序算法函数(7)、对存储数字的遍历函数(8)、初始化函数InitSqList()。

(9)、主函数main()。

四、详细设计实现各个算法的主要内容,下面是各个函数的主要信息:(1)各个排序函数的算法:一、直接插入排序void InsertSort(SqList &L){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];for( j=i-2; (L.r[0].key < L.r[j].key); j--)L.r[j+1] = L.r[j];L.r[j+1] = L.r[0];}}}二、希尔排序void ShellSort(SqList &L){int i, j;int dk = 1;//增量while(dk <=L.length/3)dk = 3*dk+1;//增大增量while(dk>0){dk /= 3;//减小增量for (i = dk; i <=L.length; i++){L.r[0].key = L.r[i].key;j = i;while ((j >= dk) &&(L.r[j-dk].key > L.r[0].key)){L.r[j].key = L.r[j-dk].key;j -= dk;}L.r[j].key = L.r[0].key;}}}三、冒泡排序void BubbleSort(SqList &L){int i,j;for(i=0;i<L.length-2;i++){int flag = 1;for(j=0;j<L.length-i-2;j++)if(L.r[j].key > L.r[j+1].key){flag = 0;int temp;temp = L.r[j].key;L.r[j].key = L.r[j+1].key;L.r[j+1].key = temp;}//若无交换说明已经有序if(flag==1)break;}}四、快速排序int Partition(SqList &L,int low,int high){//分割区域函数L.r[0] = L.r[low];int pivotkey = L.r[low].key;//一般将顺序表第一个元素作为支点while(low < high){while(low<high &&L.r[high].key>=pivotkey)high--;L.r[low] = L.r[high];while(low<high &&L.r[low].key<=pivotkey)low++;L.r[high] = L.r[low];}L.r[low] = L.r[0];//返回枢轴位置return low;}void QSort(SqList &L,int low,int high){//每张子表的快速排序if(low<high){int pivotloc =Partition(L,low,high);QSort(L,low,pivotloc-1);QSort(L,pivotloc+1,high);}}void QuickSort(SqList &L){QSort(L,1,L.length);}五、简单选择排序void SelectSort(SqList &L){int min;int j;for (int i = 0; i <L.length; i++){ // 选择第i小的记录,并交换j = i;min = L.r[i].key;for (int k = i; k < L.length; k++){ // 在R[i..n-1]中选择最小的记if (L.r[k].key < min){min = L.r[k].key ;j = k;}}if (i != j){ // 与第i个记录交换int temp = L.r[i].key;L.r[i].key = L.r[j].key;L.r[j].key = temp;}}}六、堆排序void HeapAdjust(HeapType &H,int s,int m){//堆调整,将记录调整为小顶堆int j;RedType rc = H.r[s];//暂时存储根结for(j=2*s; j<=m; j*=2){//沿着结点记录较小的向下筛选if(j<m &&H.r[j].key<H.r[j+1].key)++j;if(rc.key>= H.r[j].key)break;H.r[s] = H.r[j];s = j;}H.r[s] = rc;}void HeapSort(HeapType &H){int i;RedType temp;for(i = H.length; i>0; --i)HeapAdjust(H,i,H.length);for(i=H.length; i>1; --i){temp = H.r[1];H.r[1] = H.r[i];H.r[i] = temp;HeapAdjust(H,1,i-1);}}(2)遍历函数与初始化void Visit(SqList L){for(int i=1; i<=L.length; i++)cout<<L.r[i].key<<" ";cout<<endl;}void InitSqList(SqList &L,int a[]){for(int i=1;i<=L.length;i++)L.r[i].key = a[i];}五、测试结果以下是各种界面的测试结果:(1)输入的界面:(2)排序操作界面:(3)各种排序的结果:六、设计不足以及存在问题本程序是基于C++6.0的实现,其实在设计上的改进可以利用类进行操作,这种类的改进了存储上的不足还可以实现了,对各种的函数基于类的实现,这就是对本程序的改进,这是十分重要的与是改进的基础。

数据结构课程设计(排序算法)

数据结构课程设计(排序算法)

排序算法1.需求分析输入部分:要求用户能从屏幕上格式化输入元素个数。

系统将自动生成用户输入的元素个数,存储在线性表list中。

要求用户选择用插入排序、冒泡排序、选择排序及快速排序中的一种,然后程序根据用户的选择对线性表list从小到大进行排序。

最终,输出排序结果。

1.1 插入排序思路:设有一组关键字{K1,K2,…….,Kn},排序开始变认为K1是一个有序的序列,让K2插入到表长为1的有序序列,使之成为一个表长为2的有序序列, 让K3插入到表长为2的有序序列,使之成为一个表长为3的有序序列,依次类推,最后让Kn插入上述表长为n-1的有序序列,得到一个表长为n的有序序列。

1.2 冒泡排序思路:比较相邻的元素。

如果第一个比第二个大,就交换他们两个。

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

在这一点,最后的元素应该会是最大的数。

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

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

1.3 选择排序思路:首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。

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

1.4 快速排序思路:以第一个关键字K1为控制字,将[K1、K2、….Kn]分成两个子区,使左区的有关键字小于等于K1,右区所有关键字大于等于K1,最后控制居两个子区中间的适当位置。

在子区内数据尚处于无序状态。

将右区首、尾指针保存入栈,对左区进行与第(1)步相类似的处理,又得到它的左子区和右子区,控制字区中。

重复第(1)、(2)步,直到左区处理完毕。

然后退栈对一个个子区进行相类似的处理,直到栈空。

2.概要设计程序流程可以用以下流程图来刻画3.详细设计采用Microsoft Visual C++6.0作为开发工具,C语言作为开发语言。

用顺序表类来储存数字,并编写插入排序、冒泡排序、选择排序及快速排序等成员函数。

数据结构课程设计-排序

数据结构课程设计-排序

五.综合排序1、设计目的对于数据处理工作,排序是其最基本的运算之一。

在当今的计算机系统中,花费在排序上的时间占系统CPU运行时间的很大比重(约20%~60%)。

为了提高计算机的工作效率,人们提出了各种各样的排序算法,这些算法充分地展示了算法设计的某些重要原则和高超技巧。

本设计旨在对一些常用的内部排序算法作深入地探讨和理解,通过比较,评价各算法的优劣。

2、问题描述各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。

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

3、设计要求(1) 实现基本排序方法:直接插入排序、希尔排序、冒泡、快速排序、直接选择、堆排序;(我们要求至少实现三种算法)(2) 对每种基本排序方法尽量给出改进算法; (3) 利用随机函数产生不少于100个随机整数,利用直接插入排序、希尔排序、冒泡、快速排序、直接选择、堆排序等排序方法进行递增排序,统计各算法的关键字比较次数和关键字移动次数; (4) 以菜单的形式组织程序各功能; (5) 至少要用5组不同的输入数据作比较,比较的指标为有关键字参加的比较次数和关键字移动次数(关键字交换计为3次移动); (6) 观察所有实验结果并汇集成表格加以总结。

4、相关知识介绍将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列叫排序。

排序的目的是为了便于查找和处理,提高数据检索的效率。

排序问题是要把若干无序数据元素序列排成一个有序序列。

因此排序问题的数据元素集合是线性结构。

在这个数据元素集合上也允许存取任意位置的数据元素,所以排序问题的数据结构是线性表。

任何算法的实现方法都和算法所处理数据元素的存储结构有关。

线性表的存储结构有顺序表和链表两种,因为数组具有随机存取特性,而链表不具备,所以排序算法基本上是基于顺序表设计的。

排序的方法很多,若按待排序记录所在位置可分为外部排序(排序过程中需对外存进行访问的排序)和内部排序(待排序记录存放在内存);按排序依据的不同原则来看,内部排序又可分为插入排序(直接插入排序、折半插入排序、希尔排序等)、交换排序(冒泡排序、快速排序等)、选择排序(简单选择排序、堆排序)、归并排序(2-路归并排序)和基数排序。

数据结构课程设计报告排序算法演示系统

数据结构课程设计报告排序算法演示系统

.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大的数据。

排序(数据结构课程设计)

排序(数据结构课程设计)

《数据结构》课程设计实验报告题目:排序(必做题)姓名:学号:指导老师:时间: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]调整为堆。

数据结构课程设计(排序)

数据结构课程设计(排序)

数据结构课程设计[排序综合]学生姓名:学生学号:院(系):计算机科学与信息技术学院年级专业:指导教师:付丹丹二〇一一年十二月2- 3 - 3摘要数据结构是由数据元素依据某种逻辑联系组织起来的。

对数据元素间逻辑关系的描述称为数据的逻辑结构;数据必须在计算机内存储,数据的存储结构是数据结构的实现形式,是其在计算机内的表示;此外讨论一个数据结构必须同时讨论在该类数据上执行的运算才有意义。

在许多类型的程序的设计中,数据结构的选择是一个基本的设计考虑因素。

许多大型系统的构造经验表明,系统实现的困难程度和系统构造的质量都严重的依赖于是否选择了最优的数据结构。

许多时候,确定了数据结构后,算法就容易得到了。

有些时候事情也会反过来,我们根据特定算法来选择数据结构与之适应。

不论哪种情况,选择合适的数据结构都是非常重要的。

排序算法是数据结构学科经典的内容,其中内部排序现有的算法有很多种,其中包含冒泡排序,直接插入排序,简单选择排序,希尔排序,快速排序,堆排序等,各有其特点。

对排序算法比较的分析可以遵循若干种不同的准则,通常以排序过程所需要的算法步数作为度量,有时也以排序过程中所作的键比较次数作为度量。

特别是当作一次键比较需要较长时间,例如,当键是较长的字符串时,常以键比较次数作为排序算法计算时间复杂性的度量。

当排序时需要移动记录,且记录都很大时,还应该考虑记录的移动次数。

究竟采用哪种度量方法比较合适要根据具体情况而定。

在下面的讨论中我们主要考虑用比较的次数作为复杂性的度量。

41概要1.1设计目的数据结构与算法课程主要是研究非数值计算的程序设计问题中所出现的计算机操作对象以及它们之间的关系和操作的学科。

数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程,它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础,广泛的应用于信息学、系统工程等各种领域。

学习数据结构与算法是为了将实际问题中涉及的对象在计算机中表示出来并对它们进行处理。

排序的数据结构课程设计

排序的数据结构课程设计

排序的数据结构课程设计一、课程目标知识目标:1. 理解排序数据结构的基本概念,掌握冒泡排序、选择排序、插入排序等常见排序算法的原理和应用。

2. 学会分析排序算法的时间复杂度和空间复杂度,理解各种排序算法的优缺点。

3. 了解排序算法在实际问题中的应用场景,能够运用合适的排序算法解决实际问题。

技能目标:1. 能够运用编程语言实现常见排序算法,并编写相应的代码。

2. 能够通过分析问题,选择合适的排序算法进行数据处理,提高解决问题的效率。

3. 能够运用排序算法对数据进行整理和分析,培养良好的数据处理能力和逻辑思维能力。

情感态度价值观目标:1. 培养学生对数据结构和排序算法的兴趣,激发他们学习计算机科学的热情。

2. 培养学生的团队合作意识,学会与他人合作共同解决问题,提高沟通与协作能力。

3. 培养学生面对复杂问题时,保持耐心和细心的态度,勇于克服困难,培养解决问题的毅力。

课程性质:本课程属于计算机科学领域,旨在让学生掌握排序数据结构的基本知识,培养其编程能力和逻辑思维能力。

学生特点:学生已具备一定的编程基础和逻辑思维能力,对数据结构有一定了解,但对排序算法的深入应用尚需提高。

教学要求:结合学生特点,注重理论与实践相结合,通过案例分析和实际操作,使学生能够熟练掌握排序算法的应用,并培养其情感态度价值观。

教学过程中,将目标分解为具体的学习成果,便于后续教学设计和评估。

二、教学内容本章节教学内容主要包括以下几部分:1. 排序数据结构基本概念:介绍排序数据结构的基本原理,包括排序的定义、排序算法的分类及排序过程中涉及的关键概念。

- 教材章节:第3章 排序数据结构概述2. 常见排序算法原理及实现:- 冒泡排序:讲解冒泡排序的原理,分析其时间复杂度和空间复杂度,并通过编程实现。

- 选择排序:介绍选择排序的原理,分析其时间复杂度和空间复杂度,并通过编程实现。

- 插入排序:阐述插入排序的原理,分析其时间复杂度和空间复杂度,并通过编程实现。

数据结构课程设计排序实验报告

数据结构课程设计排序实验报告

《数据结构》课程设计报告专业班级姓名学号指导教师起止时间课程设计:排序综合一、任务描述利用随机函数产生n个随机整数(20000以上),对这些数进行多种方法进行排序。

(1)至少采用三种方法实现上述问题求解(提示,可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序)。

并把排序后的结果保存在不同的文件中。

(2)统计每一种排序方法的性能(以上机运行程序所花费的时间为准进行对比),找出其中两种较快的方法。

要求:根据以上任务说明,设计程序完成功能。

二、问题分析1、功能分析分析设计课题的要求,要求编程实现以下功能:(1)随机生成N个整数,存放到线性表中;(2)起泡排序并计算所需时间;(3)简单选择排序并计算时间;(4)希尔排序并计算时间;(5)直接插入排序并计算所需时间;(6)时间效率比较。

2、数据对象分析存储数据的线性表应为顺序存储。

三、数据结构设计使用顺序表实现,有关定义如下:typedef int Status;typedef int KeyType ; //设排序码为整型量typedef int InfoType;typedef struct { //定义被排序记录结构类型KeyType key ; //排序码I nfoType otherinfo; //其它数据项} RedType ;typedef struct {RedType * r; //存储带排序记录的顺序表//r[0]作哨兵或缓冲区int length ; //顺序表的长度} SqList ; //定义顺序表类型四、功能设计(一)主控菜单设计为实现通各种排序的功能,首先设计一个含有多个菜单项的主控菜单程序,然后再为这些菜单项配上相应的功能。

程序运行后,给出5个菜单项的内容和输入提示,如下:1.起泡排序2.简单选择排序3.希尔排序4. 直接插入排序0. 退出系统(二)程序模块结构由课题要求可将程序划分为以下几个模块(即实现程序功能所需的函数):●主控菜单项选择函数menu()●创建排序表函数InitList_Sq()●起泡排序函数Bubble_sort()●简单选择排序函数SelectSort()●希尔排序函数ShellSort();●对顺序表L进行直接插入排序函数Insertsort()(三)函数调用关系程序的主要结构(函数调用关系)如下图所示。

快速排序(算法与数据结构课程设计)

快速排序(算法与数据结构课程设计)

快速排序一、问题描述排序是数据结构中典型的算法,经常有插入排序、选择排序、快速排序等。

本文要求对排序表中的无序数据进行快速排序,并讨论快速排序的改进方法(双倍快速排序、基于归并的快速排序),这样可以对排序进行优化,提高效率。

二、基本要求1、选择合适的存储结构建立排序表,并能遍历表输出元素。

2、编写快速排序算法,并能够输出排序的结果。

3. 快速排序及其改进—双倍快速排序和基于归并的快速排序算法。

三、测试数据输入以下数据:5 、3、7、11、1、9、4、8四、算法思想1、普通快速排序的基本思想:可以运用一趟快速排序把序列分成分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行快速排序,以达到整个序列有序。

一趟的快速排序是:附设两个指针low和high,它们的初值分别为low和high,设枢轴记录的关键字为pivotkey,则首先从high所指位置起向前搜索到第一个关键字小于pivotkey大的记录和枢轴记录互相交换,然后从low所指位置向后搜索,找到第一个关键字大于pivotkey的记录和枢轴记录互相交换,重复这两部直至low=high为止。

2、双倍快速排序思想:快速排序的基本思想是基于分支策略的思想。

即对于输入的子序列L[low..high],如果规模足够小则直接进行排序,否则分三步处理:1) 分解(Divide) :设输入的序列L[low..High],确定支点元素L[low]和L[High],并使L[Low].key<=Ll[High].key ,然后分解(Divide):将序列L[low ..High ]划分成三个子序列L[Low..L-1]、L[L+1..H-1]和L[H+1..High],使L[low ..High]中元素的关系为L[Low..L-1]<L[L]<L[L+1..H-1]<L[H]<L[H+1..High]。

数据结构课程设计--二路归并排序说明书

数据结构课程设计--二路归并排序说明书

前言1.1排序的重要性生活中,无时不刻不充满这排序,比如:班级同学的成绩排名问题,公司产值高低的问题等等,解决这些问题的过程中,都涉及到了一个数据结构的构造思想过程。

数据结构中的排序,也有很多种,如:插入排序、交换排序、选择排序等等,此时我们就要注意选择具有优解的算法,将一个数据元素(或记录)的任意序列,重新排列成一个有序的排列,便于我们查找。

假设含有n个记录的序列为{R1,R2,Rn},其相应的关键字序列为{K1,K2,…,Kn}需确定1,2…n的一种排序P1,P2…Pn,使其相应的关键字满足如下的非递减的关系:Kp1≤Kp2≤…≤Kpn,即按关键字{Rp1,Rp2,…,Rpn}有序的排列,这样的一种操作称为排序。

一般情况下,排序又分为内部排序和外部排序。

而在内部排序中又含有很多排序方法,就其全面性能而言,很难提出一种被认为是最好的方法,因为每一种方法都有它的优缺点,适合在不同的环境下使用。

我们学习的排序有:直接插入排序、折半插入排序、希尔排序、快速排序、基数排序、归并排序等。

本次课题研究中,我主要进行了二路归并排序的研究和学习。

1.2设计的背景和意义排序是计算机领域的一类非常重要的问题,计算机在出来数据的过程中,有25%的时间花在了排序上,有许多的计算机设备,排序用去计算机处理数据时间的一半以上,这对于提高计算机的运行速度有一定的影响。

此时排序算法的高效率显得尤为重要。

在排序算法汇中,归并排序(Merging sort)是与插入排序、交换排序、选择排序不同的另一类排序方法。

归并的含义是将两个或两个以上的有序表组合成一个新的有序表。

归并排序可分为多路归并排序,两路归并排序,既可用于内排序,也可以用于外排序。

这里仅对内排序的两路归并排序进行讨论。

而我们这里所探究学习的二路归并排序,设计思路更加清晰、明了,程序本身也不像堆结构那样复杂,同时时间复杂度仅为0(N),同时在处理大规模归并排序的时候,排序速度也明显优于冒泡法等一些排序算法,提高排序算法的效率。

排序系统设计数据结构课程设计

排序系统设计数据结构课程设计

排序系统设计数据结构课程设计一、项目背景和目的排序系统是计算机科学中常见的一种算法,用于将一组数据按照特定的顺序进行排列。

在数据结构课程设计中,我们需要设计一个排序系统,以实现对输入数据的排序功能。

本文将详细介绍排序系统的设计思路、数据结构的选择和实现方法。

二、设计思路1. 功能需求根据任务名称所描述的需求,我们的排序系统需要具备以下功能:- 支持多种排序算法,如冒泡排序、插入排序、选择排序、快速排序等。

- 能够处理不同类型的数据,如整数、浮点数、字符串等。

- 具备可扩展性,方便后续添加更多的排序算法。

2. 数据结构选择为了实现排序系统的功能,我们需要选择适合的数据结构来存储和操作数据。

常见的数据结构有数组、链表、栈、队列等。

在排序系统中,我们可以使用数组来存储待排序的数据。

3. 算法选择根据任务名称所描述的排序系统,我们需要选择多种排序算法来实现。

以下是几种常见的排序算法:- 冒泡排序:通过相邻元素的比较和交换,将较大的元素逐渐“冒泡”到数组末尾。

- 插入排序:将待排序的元素按照顺序插入到已排序的数组中。

- 选择排序:每次从待排序的数组中选择最小的元素,放到已排序的数组末尾。

- 快速排序:通过一趟排序将待排序的数组分割成独立的两部分,其中一部分的元素都比另一部分的元素小。

4. 系统设计基于以上的设计思路,我们可以将排序系统设计为以下几个模块:- 输入模块:用于接收用户输入的待排序数据。

- 排序算法模块:包含多种排序算法的实现。

- 输出模块:将排序结果输出给用户。

三、数据结构的实现在排序系统中,我们选择使用数组来存储待排序的数据。

数组具有随机访问的特性,方便进行元素的比较和交换。

以下是数组的实现代码示例:```pythonclass Array:def __init__(self, capacity):self.capacity = capacityself.data = [None] * capacityself.size = 0def append(self, value):if self.size == self.capacity:# 数组已满,需要扩容self.resize()self.data[self.size] = valueself.size += 1def resize(self):self.capacity *= 2new_data = [None] * self.capacityfor i in range(self.size):new_data[i] = self.data[i]self.data = new_datadef swap(self, i, j):self.data[i], self.data[j] = self.data[j], self.data[i]```四、排序算法的实现在排序系统中,我们需要实现多种排序算法。

数据结构课程设计_排序算法比较【完整版】

数据结构课程设计_排序算法比较【完整版】

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

中北大学数据结构课程设计说明书2012 年 1月 8 日1设计目的本系统是为了实现和比较各种不同排序方法的不同复杂度,而建立的,从不同的角度比较各算法的优劣,从而使使用者能对个排序方法有更清晰的了解.2.设计内容和要求本次设计的内容主要有实现各种排序算法以及比较各种算法。

要求主要是要执行对一种数据类型的序列进行所有排序方法的排序计算,并返回序列及各算法的排序指标。

3.本设计所采用的数据结构本次设计主要采用的数据结构有结构体定义,直接排序,选择排序,归并排序,快速排序,冒泡排序,希尔排序,堆排序等。

4.功能模块详细设计4.1 详细设计思想本次设计分主题设计和模块设计两部分。

主体设计方面,本系统的主要数据类型为含有一个关键字的结构体类型,命名为datatype;设置两个全局变量数组,cn和mn,分别用于记录每种排序方法中的各排序元素的比较次数和移动次数(关键字交换以3次计)的总和。

模块设计方面,本系统大致可分为排序模块部分和运行模块部分。

排序模块部分分为归并排序模块,快速排序模块,冒泡排序模块,选择排序模块,直接排序模块,希尔排序模块,堆排序模块;运行模块部分分为主函数,自行输入模块,随机模块,输出模块。

以下是各排序算法的核心设计思想:运行模块个算法如下:4.2 核心代码#include<stdio.h>#include<stdlib.h>#include<conio.h>#define MAXNUM 100typedef struct{ int key;} datatype;datatype R[MAXNUM];/*定义类型*/int cn[MAXNUM],mn[MAXNUM];void D_InsertSort(datatype R[ ], int n)/*直接排序*/ {int i,j;extern int cn[MAXNUM],mn[MAXNUM];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;extern int cn[MAXNUM],mn[MAXNUM];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;extern int cn[MAXNUM],mn[MAXNUM];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;extern int cn[MAXNUM],mn[MAXNUM];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;extern int cn[MAXNUM],mn[MAXNUM];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;extern int cn[MAXNUM],mn[MAXNUM];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;extern int cn[MAXNUM],mn[MAXNUM];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){extern int cn[MAXNUM],mn[MAXNUM];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 sort(datatype R[],int n)/*希尔排序*/{int gap,i,j,temp;extern int cn[MAXNUM],mn[MAXNUM];for(gap=n/2;gap>0;gap /= 2) /* 设置排序的步长,步长gap每次减半,直到减到1 */ {for(i=gap;i<n;i++) /* 定位到每一个元素*/{for(j=i-gap;(j >= 0) && (R[j].key > R[j+gap].key);j -= gap ) /* 比较相距gap 远的两个元素的大小,根据排序方向决定如何调换*/{temp=R[j].key;R[j].key=R[j+gap].key;R[j+gap].key=temp;cn[6]+=1;mn[6]+=3;}}}}void sui_ji(){int i,n;datatype R[MAXNUM]={0},R1[MAXNUM]={0};;a:printf("请输入你要输入的个数:");scanf("%d",&n);if(n>100){printf("超出范围重新输入!!!\n");goto a;}printf("排序前元素顺序为:");for(i=1;i<n+1;i++){R[i].key=rand();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);/*堆排序*/MergeSort(R, R1, n);/*二路归并排序*/Quick_Sort(R,0, n);/*快速排序*/sort(R,n);/*希尔排序*/}void zi_xing_input(){ int n,i;datatype R1[MAXNUM]={0};printf("请输入你要输入的个数(不大于100的整数):");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);/*堆排序*/Quick_Sort(R1,0, n);/*快速排序*/sort(R,n);/*希尔排序*/}int main(){extern int cn[MAXNUM],mn[MAXNUM];char s;printf(“排序算法实现与演示统\n ”);printf(" ┏******************************┓\n");printf(" ┃------- 欢迎使用----┃\n");printf(" ┃-----(1)随机取数-------┃\n");printf(" ┃-----(2)自行输入-------┃\n");printf(" ┃-----(0)退出使用-------┃\n");printf(" ┗******************************┛\n");printf(" 请选择操作方式:");b:s=getch();switch(s){case '1': system("cls") ; sui_ji(); break;case '2': system("cls"); zi_xing_input(); break;case '0': printf(" 谢谢使用!!"); exit(0); break;default:printf("错误输入,重新输入!");goto b;}printf("\n ");printf(" 比较结果\n");printf(" \n");printf(" 排序方式比较次数移动次数\n");printf(" \n");printf(" 直接%d %d \n",cn[0],mn[0]/3); printf(" \n");printf(" 简单选择%d %d \n",cn[1],mn[1]/3); printf(" \n");printf(" 冒泡%d %d \n",cn[2],mn[2]/3); printf(" \n");printf(" 堆排序%d %d \n",cn[3],mn[3]/3);printf(" \n");printf(" 二路归并%d %d \n",cn[4],mn[4]/3);printf(" \n");printf(" 快速%d %d \n",cn[5],mn[5]/3);printf(" \n");printf(" 希尔排序%d %d \n",cn[6],mn[6]/3);getchar();printf("谢谢使用!^ _ ^\n");system("PAUSE");return 0;}(此页附在说明书后,请在验收前填好)。

相关文档
最新文档