数据结构-多关键字排序课设报告
多关键字排序数据结构-设计
多关键字排序数据结构-设计第一篇：多关键字排序数据结构-设计多关键字排序【问题描述】多关键字的排序有一定的实用范围。
例如：在进行高考分数处理时，除了需对总分进行排序外，不同的专业对单科分数的要求不同，因此尚需在总分相同的情况下，按用户提出的单科分数的次序要求排出考生录取的次序。
【基本要求】（1）假设待排序的记录数不超过10000，表中记录的关键字数不超过5，各个关键字的范围均为0至100.。
按用户给定的进行排序的关键字的优先关系，输出排序结果。
（2）约定按LSD法进行多关键字的排序。
在对各个关键字进行排序时采用两种策略：其一是利用稳定的内部排序法，其二是利用“分配”和“收集”的方法。
并综合比较这两种策略。
【测试数据】由随机数产生器生成。
C语言源程序#include#include#include#include#define N 200typedef struct{int key[5];}score;score sr[N];void Merge(scoreR[],int low,int m,int high,int keynum){//将两个有序的R[low..m)和R[m+1..high]归并成一个有序的R[low..high]int i,j,k;i=low,j=m+1,k=0;score *R1;R1=(score*)malloc((high-low+1)*sizeof(score));//临时申请空间if(!R1)return;//申请空间失败while(i<=m&&j<=high)//两子文件非空时取较大者复制到R1[k]上{if(R[i].key[keynum]>=R[j].key[keynum])R1[k++]=R[i++];else R1[k++]=R[j++];}while(i<=m)//若第1个数组非空，则复制剩余记录到R1中R1[k++]=R[i++];while(j<=high)//若第2个数组非空，则复制剩余记录到R1中R1[k++]=R[j++];for(k=0,i=low;i<=high;k++,i++)R[i]=R1[k];//归并完成后将结果复制回R[low..high]}void MergeSort(score R[],int low,int high,int keynumber){//对R[low..high]进行二路归并排序int mid;if(low{ //区间长度大于1mid=(low+high)/2;//分解MergeSort(R,low,mid,keynumber);//递归地对R[low..mid]排序MergeSort(R,mid+1,high,keynumber);//递归地对R[mid+1..high]排序Merge(R,low,mid,high,keynumber);//组合，将两个有序区归并为一个有序区}}intmain(){int i,j,n,pepole;printf(“请输入总记录条数，和关键字的个数，并且以空格作为间隔符n”);scanf(“%d%d”,&pepole,&n);printf(“按记录顺序：以关键字优先次序从低到高产生随机关键字，最后一个关键字是总分由系统自动计算n”);srand((unsigned)time(NULL));for(i=0;i{ sr[i].key[n-1]=0;for(j=0;j{sr[i].key[j]=rand()%100;sr[i].key[n-1]=sr[i].key[n-1]+sr[i].key[j];printf(“ %4d”,sr[i].key[j]);}printf(“ %4d”,sr[i].key[n-1]);printf(“n”);}for(i=0;iMergeSort(sr,0,pepole-1,i);printf(“n排序结果为：n”);for(i=0;i{ for(j=0;jprintf(“ %3d ”,sr[i].key[j]);printf(“n”);}system(“pause”);return 0;}第二篇：数据排序教学设计数据的排序一、教材分析：“数据的排序”是冀教版《信息技术》1初中一年级第三单元第十三课的内容，本节课是在学生初步掌握了Excel工作表的基本操作及数据计算等基本知识的延伸，在整个Excel学习中占据重要的地位，是学生在掌握Excel基本操作的基础上解决实际问题的开始。
多关键字排序课程设计
多关键字排序课程设计一、教学目标本课程旨在让学生掌握多关键字排序的基本原理和方法，通过学习，学生应能理解关键字排序在实际应用中的重要性，掌握排序算法的选择和实现，以及分析排序算法的时间和空间复杂度。
在技能方面，学生应能独立完成多关键字排序的代码实现，并能够根据实际需求选择合适的排序算法。
在情感态度价值观方面，学生应培养对计算机科学的热爱，增强解决实际问题的信心和勇气。
二、教学内容本课程的教学内容主要包括多关键字排序的原理、排序算法的选择和实现、排序算法的时间和空间复杂度分析。
具体包括以下几个部分：1.多关键字排序的概念和重要性2.常见的排序算法简介：冒泡排序、选择排序、插入排序、快速排序、归并排序等3.多关键字排序算法的实现：如何处理多个关键字4.排序算法的时间和空间复杂度分析5.排序算法在实际应用中的选择和优化三、教学方法为了提高学生的学习兴趣和主动性，本课程将采用多种教学方法相结合的方式进行教学。
包括：1.讲授法：用于讲解多关键字排序的基本概念、原理和算法。
2.案例分析法：通过分析实际案例，使学生更好地理解和掌握排序算法的应用。
3.实验法：通过编程实验，让学生亲手实现排序算法，提高其实践能力。
4.讨论法：学生进行小组讨论，培养学生的团队合作精神和批判性思维。
四、教学资源为了支持教学内容和教学方法的实施，丰富学生的学习体验，我们将选择和准备以下教学资源：1.教材：《数据结构与算法》等相关教材，用于提供理论知识和算法描述。
2.参考书：提供一些相关的参考书籍，供学生深入学习和研究。
3.多媒体资料：制作课件、视频等多媒体资料，以直观展示排序算法的原理和实现。
4.实验设备：提供计算机实验室，让学生进行编程实验和讨论。
五、教学评估本课程的评估方式将包括平时表现、作业、考试等多个方面，以全面、客观、公正地评价学生的学习成果。
具体包括以下几个部分：1.平时表现：通过课堂参与、小组讨论、提问等环节，评估学生的学习态度和参与度。
数据结构 多关键字排序课设报告
目录一．设计题目 (2)二．需求分析 (2)1.程序设计问题描述 (2)2.基本要求 (2)3.流程图 (2)三．详细设计 (3)1.数据结构定义 (4)2.主要算法设计 (5)3.函数调用关系图 (8)4.程序主要流程 (8)四．调试分析 (13)五．用户手册 (15)六．测试结果 (19)七．源代码（带注释） (21)八．参考文献 (26)数据结构课设报告一．设计题目多关键字排序二．需求分析1.程序设计问题描述多关键字的排序有其一定的实用范围。
例如:在进行高考分数处理时，除了需对总分进行排序外，不同的专业对单科分数的要求不同，因此尚需在总分相同的情况下，按用户提出的单科分数的次序要求排出考生录取的次序。
2.基本要求(1)假设待排序的记录数不超过10000，表中记录的关键字数不超过5，各个关键字的范围均为0至100。
按用户给定的进行排序的关键字的优先关系，输出排序结果。
(2)约定按LSD法进行多关键字的排序。
在对各个关键字进行排序时采用两种策略:其一是利用稳定的内部排序法，其二是利用"分配"和"收集"的方法。
并综合比较这两种策略。
（3）测试数据由随机数生成器产生。
3.流程图开始输出菜单输入记录数选择排序方法输入不是1或2，重新输入选择排序方法判断1 2内部排序基数排序第 1 页共26 页三．详细设计本程序是对语文，数学，英语，体育，综合这5门成绩按照此顺序进行优先排序。
各科分数为0～100。
由于本实验约定按LSD 进行多关键字的排序。
在对个关键字进行排序时采用两种策略：其一是利用稳定的内部排序法，其二是利用“分配”和“收集”的方法。
所以在一个程序里实现了这两种排序方法。
第一种排序方法由于要使用稳定的排序方法，故参考书上的几种排序方法后，选用了冒泡排序和静态链表存储方式，每一趟排序后，找出最高分 。
第二种排序方法利用“分配”与“收集”的基数排序算法，用静态链表存储分数，在一趟排序中，将结点分配到相应的链显示排序结果输入结束或继续执行判断输入退出结束非零值继续执行数据结构课设报告队列中去，再按从高到低链接起来。
多关键字排序_数据结构-设计
多关键字排序_数据结构-设计多关键字排序_数据结构设计在计算机科学中，数据的排序是一项基础且重要的任务。
多关键字排序作为排序问题的一个重要分支，在实际应用中具有广泛的需求。
当我们面对复杂的数据集合，其中每个数据项包含多个属性或关键字时，如何高效地对其进行排序就成为了一个关键的问题。
想象一下，我们有一个学生成绩的数据集，每个学生的记录包含了学号、姓名、语文成绩、数学成绩、英语成绩等多个关键字。
如果我们想要按照总成绩从高到低对学生进行排序，这就是一个典型的多关键字排序问题。
又或者在一个电商平台上，商品的信息包含了价格、销量、评价得分等关键字，要根据用户的需求对商品进行排序展示，也需要用到多关键字排序。
多关键字排序的基本思想是，将多个关键字看作一个整体，通过比较这些关键字的组合值来确定数据项的顺序。
常见的多关键字排序方法有两种：一种是基于比较的排序方法，另一种是基于分配的排序方法。
基于比较的多关键字排序方法，最常见的就是冒泡排序、插入排序、选择排序、快速排序等。
以快速排序为例，它的基本思想是选择一个基准元素，将待排序的序列划分成两部分，一部分的元素都小于等于基准元素，另一部分的元素都大于等于基准元素，然后对这两部分分别进行快速排序，从而实现整个序列的排序。
在多关键字排序中，可以先对主要关键字进行快速排序，然后对于主要关键字相同的数据项，再按照次要关键字进行快速排序。
例如，对于学生成绩数据，先按照总成绩进行快速排序，对于总成绩相同的学生，再按照语文成绩进行快速排序。
基于分配的多关键字排序方法，例如桶排序和基数排序，则是通过将数据分配到不同的桶或位置来实现排序。
以基数排序为例，它适用于关键字可以分解为多个位或数位的情况。
例如，对于整数关键字，可以按照个位、十位、百位等逐位进行排序。
在设计多关键字排序的数据结构时，需要考虑数据的特点和排序的需求。
如果数据量较小，并且对排序的时间复杂度要求不高，简单的冒泡排序或插入排序可能就足够了。
数据结构__排序综合报告
数学与计算机学院课程设计说明书课程名称: 数据结构-课程设计课程代码: 8404181题目: 排序综合年级/专业/班: 2009级软件工程四班学生姓名: 学号: 开始时间: 2011 年 06 月 20 日完成时间: 2011 年 07 月 03 日课程设计成绩：指导教师签名：年月摘要排序（sorting）是计算机程序设计的一种重要操作，他的功能是将一组任意顺序数据元素（记录），根据某一个（或几个）关键字按一定的顺序重新排列成为有序的序列。
由于待排序的记录数量不同，使得排序过程中涉及的存储器的不同，可将排序方法分为两大类：一类是内部排序，指的是待排序的记录存放在计算机随机存储器中进行的排序过程；另一类是外部排序，指的是待排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中尚需要对外存进行访问的排序过程。
内部排序又分为：插入排序、快速排序、选择排序、归并排序和基数排序。
其中插入排序又分为：直接插入排序、其他插入排序和希尔排序；选择排序分为：简单选择排序、树形选择排序和堆排序；基数排序分为：多关键字排序和链式基数排序。
本次课程设计就是内部排序中的几个常用排序方法。
分析了排序的实质，排序的应用，排序的分类，利用C语言采用数组存储结构编程实现了本排序综合系统，该系统包含了几种常见的排序方法，有直接插入排序、希尔排序、冒泡排序、非递归的快速排序、递归的快速排序、简单排序、堆排序。
关键字：内部排序，外部排序，排序，重新排列，关键字目录1需求分析 (1)1.1任务与分析 (1)1.2功能模块的划分 (1)1.2.1 输入模块 (1)1.2.2 选择排序方法模块 (1)1.2.3 输出模块 (1)1.3排序模块分析 (2)1.3.1 直接插入排序 (2)1.3.2 希尔排序 (2)1.3.3 冒泡排序 (2)1.3.4 快速排序（递归和非递归） (2)1.3.5 简单排序 (3)1.3.6 堆排序 (3)1.4系统需求分析规格说明书 (3)2开发及运行平台 (4)2.1 WINDOWS操作系统 (4)2.2VC++6.0 (4)3 概要设计 (4)3.1程序结构框图 (4)3.2程序流程图 (5)3.3抽象数据类型定义 (5)3.4各种操作函数： (6)3.5主函数 (6)4 详细设计 (7)4.1数据类型定义 (7)4.2主要模块内部设计 (7)4.2.1 模块1 —直接插入排序模块设计 (7)4.2.2 模块2 —希尔排序模块设计 (7)4.2.3 模块3 —冒泡排序模块设计 (8)4.2.4 模块4 —非递归快排模块设计 (9)4.2.5 模块5 —递归快排模块设计 (10)4.2.6 模块6 —简单排序模块设计 (10)4.2.7 模块7 —堆排序模块设计 (10)5 调试分析 (12)5.1调试过程 (12)5.2性能分析 (12)6 测试分析 (13)6.1测试用例 (13)6.2测试结果 (13)7 结论 (15)参考文献 (16)附录 (17)1需求分析1.1 任务与分析任务：机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。
多关键字排序课程设计
多关键字排序课程设计一、教学目标本课程的学习目标包括知识目标、技能目标和情感态度价值观目标。
知识目标要求学生掌握多关键字排序的原理和算法；技能目标要求学生能够运用多关键字排序解决实际问题；情感态度价值观目标要求学生培养团队合作意识，提高解决问题的能力。
通过分析课程性质、学生特点和教学要求，明确课程目标，将目标分解为具体的学习成果，以便后续的教学设计和评估。
二、教学内容根据课程目标，选择和教学内容，确保内容的科学性和系统性。
本课程的教学大纲如下：1.介绍多关键字排序的基本概念和原理；2.讲解多关键字排序的算法实现；3.通过案例分析，让学生了解多关键字排序在实际问题中的应用；4.进行团队协作项目，让学生亲自动手实践，提高解决问题的能力。
三、教学方法选择合适的教学方法，如讲授法、讨论法、案例分析法、实验法等，以激发学生的学习兴趣和主动性。
1.通过讲授法，向学生介绍多关键字排序的基本概念和原理；2.通过讨论法，让学生参与课堂讨论，提高思考和分析问题的能力；3.通过案例分析法，让学生了解多关键字排序在实际问题中的应用；4.通过实验法，让学生亲自动手实践，提高解决问题的能力。
四、教学资源选择和准备适当的教学资源，包括教材、参考书、多媒体资料、实验设备等。
教学资源应该能够支持教学内容和教学方法的实施，丰富学生的学习体验。
1.教材：选用权威、实用的教材，为学生提供系统、全面的知识体系；2.参考书：提供相关的参考书籍，拓展学生的知识面；3.多媒体资料：制作精美的多媒体课件，提高课堂教学效果；4.实验设备：准备充足的实验设备，确保学生能够顺利进行实验操作。
五、教学评估为了全面、客观地评估学生的学习成果，本课程采用多元化的评估方式。
评估内容包括平时表现、作业、考试等。
1.平时表现：通过观察学生在课堂上的参与程度、提问回答等情况，评估其学习态度和理解能力；2.作业：布置适量的作业，让学生巩固课堂所学知识，通过批改作业了解学生的掌握情况；3.考试：设置期中考试和期末考试，全面测试学生对多关键字排序知识的掌握程度。
数据排序课程设计报告
数据排序课程设计报告一、教学目标本课程的教学目标是使学生掌握数据排序的基本概念和方法，培养学生运用数据分析问题、解决问题的能力。
具体目标如下：1.知识目标：（1）了解数据排序的定义和分类；（2）掌握常见排序算法的原理和实现；（3）理解排序在实际应用中的重要性。
2.技能目标：（1）能够运用排序算法对给定数据进行排序；（2）能够分析不同排序算法的优缺点，选择合适的排序算法解决实际问题；（3）能够运用编程语言实现排序算法。
3.情感态度价值观目标：（1）培养学生对数据排序的兴趣，提高学生主动探索问题的意识；（2）培养学生团队合作精神，鼓励学生在讨论中分享自己的想法；（3）培养学生养成良好的编程习惯，提高学生代码规范的意识。
二、教学内容本课程的教学内容主要包括数据排序的定义和分类、常见排序算法的原理和实现、排序在实际应用中的案例分析等。
具体安排如下：1.数据排序的定义和分类：介绍数据排序的基本概念，分析不同排序方法的分类及特点。
2.常见排序算法的原理和实现：详细讲解冒泡排序、选择排序、插入排序、快速排序等常见排序算法的原理和实现过程。
3.排序在实际应用中的案例分析：通过具体案例，分析排序算法在实际问题中的应用，如搜索引擎、数据库排序等。
4.编程实践：让学生动手编写代码，实现排序算法，培养学生的编程能力和解决问题的能力。
三、教学方法本课程采用多种教学方法相结合的方式，以提高学生的学习兴趣和主动性。
具体方法如下：1.讲授法：讲解数据排序的基本概念、排序算法的原理和实现方法。
2.讨论法：学生分组讨论，分享不同排序算法的优缺点，培养学生团队合作精神。
3.案例分析法：分析实际应用中的排序问题，让学生了解排序算法在实际问题中的应用。
4.实验法：让学生动手编写代码，实现排序算法，培养学生的编程能力和解决问题的能力。
四、教学资源本课程所需教学资源包括教材、参考书、多媒体资料、实验设备等。
具体资源如下：1.教材：选用权威、实用的教材，为学生提供系统、全面的学习资料。
数据结构排序算法实验报告
移动次数 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，再进行初始建堆，直至完全排好序。
数据结构课程设计报告
目录第一章课程设计的目的和意义 (1)第二章需求分析 ...................................................................... 错误!未定义书签。
第三章系统设计 (3)3.1 概要设计 (3)3.2详细设计 (5)第四章系统测试 (5)4.1系统运行初始界面 (6)4.2录入航班、客户信息界面 (6)4.3 查看所有航班信息界面 (6)4.4 买票、退票界面 (7)第五章心得体会 (7)第六章参考文献 (8)致谢 (8)附录 (9)源程序： (9)第一章课程设计的目的和意义《数据结构》主要介绍一些最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论。
数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。
学习数据结构是为了将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理。
通过课程设计可以提高学生的思维能力，促进学生的综合应用能力和专业素质的提高。
通过此次课程设计主要达到以下目的：一：了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；二：初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；三：提高综合运用所学的理论知识和方法独立分析和解决问题的能力；四：训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。
五：锻炼动手操作能力，培养我们的创新思维能力。
从编写代码，到调试程序，再到运行程序，这是设计的最重要环节，它需要我们用逻辑思维将我们所学知识和实际相结合，并在对方案的分析过程中能够有所创新，从而使运行方案更严谨更简洁。
培养好良好的思维，便要将这种思维赋予实践，即动手操作能力。
《数据结构》课程设计报告实验五 排序
《数据结构》课程设计报告实验五排序一、需求分析：本演示程序用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的实现，其实在设计上的改进可以利用类进行操作，这种类的改进了存储上的不足还可以实现了，对各种的函数基于类的实现，这就是对本程序的改进，这是十分重要的与是改进的基础。
(完整word版)数据结构各种排序实验报告
目录1。
引言 .................................................................................................................... 错误!未定义书签。
2.需求分析 (2)3.详细设计 (2)3。
1 直接插入排序 (2)3.2折半排序 (2)3。
3 希尔排序 (4)3。
4简单选择排序 (4)3.5堆排序 (4)3。
6归并排序 (5)3。
7冒泡排序 (7)4.调试 (8)5.调试及检验 (8)5.1 直接插入排序 (8)5。
2折半插入排序 (9)5。
3 希尔排序 (10)5。
4简单选择排序 (10)5。
5堆排序 (11)5.6归并排序 (12)5。
7冒泡排序 (12)6。
测试与比较........................................................................................................ 错误!未定义书签。
6.1调试步骤.................................................................................................... 错误!未定义书签。
6.2结论 (13)7.实验心得与分析 (13)8.附录 (14)8。
1直接插入排序 (14)8.2折半插入排序 (15)8。
3希尔排序 (17)8。
4简单选择排序 (18)8。
5堆排序 (20)8。
6归并排序 (22)8.7冒泡排序 (25)8.8主程序 (26)1。
需求分析课程题目是排序算法的实现，课程设计一共要设计八种排序算法。
这八种算法共包括：堆排序，归并排序，希尔排序,冒泡排序，快速排序,基数排序，折半插入排序，直接插入排序。
为了运行时的方便，将八种排序方法进行编号，其中1为堆排序，2为归并排序，3为希尔排序，4为冒泡排序，5为快速排序，6为基数排序,7为折半插入排序8为直接插入排序。
数据结构排序综合课程设计报告
《数据结构》课程设计报告专业计算机科学与技术班级网络工程姓名李华学号20111205066指导教师起止时间2013.5.6~2013.5.20课程设计：排序综合一、任务描述（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;四、功能设计（一）主控菜单设计为实现排序的操作功能，首先设计一个含有多个菜单项的主控菜单程序，然后再为这些菜单项配上相应的功能。
数据结构课程设计排序实验报告
《数据结构》课程设计报告专业班级姓名学号指导教师起止时间课程设计：排序综合一、任务描述利用随机函数产生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++环境下实现，下面是对以上测试数据的运行结果。
数据结构排序实验报告
引言概述：数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。
通过实验，可以深入理解和掌握不同排序算法的原理、特点和性能表现。
本文将针对数据结构排序实验进行详细的阐述和总结，包括实验目的、实验内容、实验结果分析和总结。
一、实验目的1. 加深对数据结构排序算法的理解：通过实验，掌握不同排序算法的工作原理和实现方式。
2. 分析和比较不同排序算法的性能：对比不同排序算法在不同数据规模下的时间复杂度和空间复杂度，理解它们的优劣势。
3. 提高编程和算法设计能力：通过实验的编写，提升对排序算法的实现能力和代码质量。
二、实验内容1. 选择排序算法：选择排序是一种简单直观的排序算法，将序列分为有序和无序两部分，每次从无序部分选择最小（最大）元素，放到有序部分的末尾（开头）。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析2. 插入排序算法：插入排序逐步构建有序序列，对于未排序的元素，在已排序序列中从后向前扫描，找到对应位置插入。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析3. 快速排序算法：快速排序利用分治的思想，将序列分为左右两部分，选取基准元素，将小于基准的放在左边，大于基准的放在右边，递归地对左右部分进行排序。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析4. 归并排序算法：归并排序是一种稳定的排序算法，通过将序列分为若干子序列，分别进行排序，然后再将排好序的子序列合并成整体有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析5. 堆排序算法：堆是一种特殊的树状数据结构，堆排序利用堆的性质进行排序，通过构建大顶堆或小顶堆，并逐个将堆顶元素移出形成有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析三、实验结果分析1. 比较不同排序算法的执行时间：根据实验数据和分析，对比不同排序算法在不同数据规模下的执行时间，并针对其时间复杂度进行验证和分析。
多关键字排序课程设计
多关键字排序 课程设计一、课程目标知识目标：1. 学生能理解多关键字排序的概念，掌握多关键字排序的基本原理。
2. 学生能掌握两种以上的多关键字排序算法，如冒泡排序、选择排序等。
3. 学生能分析不同排序算法的时间复杂度和空间复杂度。
技能目标：1. 学生能运用编程语言实现多关键字排序算法，提高编程能力。
2. 学生能通过实际案例，运用多关键字排序解决实际问题。
3. 学生能对排序算法进行优化，提高算法效率。
情感态度价值观目标：1. 学生通过学习多关键字排序，培养解决问题的耐心和毅力。
2. 学生能够主动探索排序算法的优化方法，培养创新精神和团队合作意识。
3. 学生能够认识到排序算法在实际生活中的广泛应用，增强学以致用的意识。
课程性质：本课程为计算机科学学科的一门核心课程，旨在培养学生掌握多关键字排序的基本原理和实际应用。
学生特点：学生处于初中阶段，已具备一定的编程基础和逻辑思维能力，但对复杂算法的理解和运用尚需引导。
教学要求：教师应结合实际案例，引导学生动手实践，注重培养学生的编程能力和解决问题的能力。
在教学过程中，关注学生的情感态度，激发学生的学习兴趣和探究精神。
通过分解课程目标为具体学习成果，使学生在学习过程中有明确的目标导向，便于教学设计和评估。
二、教学内容本章节教学内容主要包括以下几部分：1. 多关键字排序概念：介绍什么是多关键字排序，多关键字排序的应用场景，如何确定关键字优先级。
2. 常见多关键字排序算法：- 冒泡排序：讲解冒泡排序的基本原理，实现过程，以及如何优化。
- 选择排序：介绍选择排序的基本思路，实现方法，以及优缺点分析。
3. 排序算法时间复杂度和空间复杂度分析：引导学生分析不同排序算法的性能，理解时间复杂度和空间复杂度的概念。
4. 排序算法实践与应用：- 设计实际案例，让学生运用所学排序算法解决问题。
- 分析案例中排序算法的选择和优化，提高学生编程能力和问题解决能力。
5. 排序算法拓展：介绍其他多关键字排序算法，如快速排序、归并排序等，拓展学生知识面。
数据结构课程设计排序
---《数据结构》课程设计报告内部排序算法研究指导老师：姓名：学号：班级：专业：日期：一、问题描述（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、调试分析成功运行，如图所示：。
(002)(任务书-多关键字排序)(学号)(姓名 )
任务书设计名称：多关键字排序指导教师：下达时间： 2011-6-18学生姓名：学号：专业：一、课程设计的基本要求利用《数据结构》课程的相关知识完成一个具有一定难度的综合设计题目，利用C/C++语言进行程序设计，并规范地完成课程设计报告。
通过课程设计，巩固和加深对线性表、栈、队列、字符串、树、图、查找、排序等理论知识的理解；掌握现实复杂问题的分析建模和解决方法（包括问题描述、系统分析、设计建模、代码实现、结果分析等）；提高利用计算机分析解决综合性实际问题的基本能力。
具体要求如下：1、对现实复杂问题中的数据对象特性及组织方法进行分析和研究，设计适当的数据逻辑结构、存贮结构以及相应运算操作，把现实世界问题建模转化为计算机内部表示并进行处理。
2、采取模块化方式进行程序设计，要求程序的功能设计、数据结构设计及整体结构设计合理。
学生也可根据自己对题目的理解增加新的功能模块（视情况可另外加分）。
3、系统以菜单界面方式（至少采用文本菜单界面，如能采用图形菜单界面更好）工作，运行界面友好，演示程序以用户和计算机的对话方式进行，利用文件进行数据的提取与存储。
4、程序算法说明清晰，理论分析与计算正确，运行情况良好，实验测试数据无误，容错性强（能对错误输入进行判断控制）。
5、编程风格良好（包括缩进、空行、适当注释、变量名和函数名见名知意，程序容易阅读等）。
6、写出规范的课程设计报告，具体要求见相关说明文档。
二、课程设计的主要内容【问题描述】多关键字的排序有一定的使用范围。
例如：在进行高考分数处理时，除了需要对总分进行排序外。
不同的专业单科分数的要求不同，因此尚需在总分相同的情况下，按用户提出的单科分数的次序要求排除考生录取的次序。
【基本要求】(1) 假设待排序的记录数不超过10000，不少于50条；表中记录的关键字数不超过5，各个关键字的范围均为0至100。
按用户给定的进行排序的关键词优先关系，输出排序结果。
(2) 约定按LSD法进行多关键字的排序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录
一．设计题目 (2)
二．需求分析 (2)
1.程序设计问题描述 (2)
2.基本要求 (2)
3.流程图 (2)
三．详细设计 (3)
1.数据结构定义 (4)
2.主要算法设计 (5)
3.函数调用关系图 (8)
4.程序主要流程 (8)
四．调试分析 (13)
五．用户手册 (15)
六．测试结果 (19)
七．源代码（带注释） (21)
八．参考文献 (26)
一．设计题目
多关键字排序
二．需求分析
1.程序设计问题描述
多关键字的排序有其一定的实用范围。
例如:在进行高考分数处理时，除了需对总分进行排序外，不同的专业对单科分数的要求不同，因此尚需在总分相同的情况下，按用户提出的单科分数的次序要求排出考生录取的次序。
2.基本要求
(1)假设待排序的记录数不超过10000，表中记录的关键字数不超过5，各个关键字的范围均为0至100。
按用户给定的进行排序的关键字的优先关系，输出排序结果。
(2)约定按LSD法进行多关键字的排序。
在对各个关键字进行排序时采用两种策略:其一是利用稳定的内部排序法，其二是利用"分配"和"收集"的方法。
并综合比较这两种策略。
（3）测试数据由随机数生成器产生。
3.流程图
三．详细设计
本程序是对语文，数学，英语，体育，综合这5门成绩按照此顺序进行优先排序。
各科分数为0～100。
由于本实验约定按LSD进行多关键字的排序。
在对个关键字进行排序时采用两种策略：其一是利用稳定的内部排序法，其二是利用“分配”和“收集”的方法。
所以在一个程序里实现了这两种排序方法。
第一种排序方法由于要使用稳定的排序方法，故参考书上的几种排序方法后，选用了冒泡排序和静态链表存储方式，每一趟排序后，找出最高分。
第二种排序方法利用“分配”与“收集”的基数排序算法，用静态链表存储分数，在一趟排序中，将结点分配到相应的链
队列中去，再按从高到低链接起来。
1.数据结构设计
（1）稳定的内部排序法
结构体定义 typedef struct node 机产生数据：输入想要排序的学生成绩记录数并随机产生成绩： typedef struct node 数据进行冒泡法排序 "<<endl <<" 2.对数据进行基数排序 "<<endl <<"#################################################"<<endl;
do
{
cin>>b;
if(b==1)
{
cout<<setw(8)<<"语文"<<setw(8)<<"数学"<<setw(8)<<"英语"<<setw(8)<<"体育"<<setw(8)<<"综合"<<endl; BubbleSort(L); 码设计分析 看到题目“多关键字排序”后，首先对课本的第十章所有的算法复习了一遍并对所有的排序方法进行了总结。
内部排序法可详细的分为：插入排序（直接插入排序），快速排序，选择排序（简单选择排序），归并排序，冒泡排序，希尔排序，堆排序，基数排序。
通过对算法的分析。
可将这些排序方法分为稳定排序和不稳定排序。
其中不稳定排序包括快速排序和堆排序，其余都为稳定排序方法。
故基于对算法的时间空间复杂度和熟练程度，稳定的内部排序法，我选择了冒泡排序法。
由于待排序的记录序列可有3种存储方式：顺序存储，链表存储和地址存储。
考虑到算法的执行效率和当前能力，我选择了第二种记录序列的存储方式。
故确定了排序方法和记录的存储方式后，开始设计代码。
程序的重要设计模块为：结构体定义，算法设计，界面设计和主函数的定义。
2.调试过程中的问题
（1）在基数排序中，输入2后一直无显示，如下图所示：
经调试检查后发现是因为排序完一条记录后，没有将指针指向下一条记录。
所以在while （）循环结束处添加一条指向下一条记录第指针p=p->next; 如下代码所示：
while(p)
{
if(d==1) m=p->key[n]%10;
else m=p->key[n]/10;
if(head[m]==NULL)
{
void main() Menu() BubbleSort(L) PrintScore(L) RandData(L,n) RadixSort(L) PrintScore(L
)
调用
If （b=1）调用 If （b=2）调用 调用
head[m]=p;
tail[m]=p;
}
else
{
tail[m]->next=p;
tail[m]=p;
}
p=p->next;
数据进行冒泡法排序
"<<endl
<<" 2.对数据进行基数排序 "<<endl
<<"#################################################"<<endl;
do
{
cin>>b;
if(b==1)
{
cout<<setw(8)<<"语文"<<setw(8)<<"数学"<<setw(8)<<"英语"<<setw(8)<<"体育"<<setw(8)<<"综合"<<endl;
BubbleSort(L); 据结构（c语言版）严蔚敏吴伟民编著。