排序综合数据结构课程设计论文
数据结构课程设计-排序
一、问题描述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，用来标记相邻记录是否发生交换。
排序综合课程设计
.大连科技学院数据结构课程设计题目排序综合学生专业班级指导教师职称副教授所在单位信息科学系软件教研室教学部主任完成日期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 个工作日：上交课程设计报告，由教师检查软件测试效果、检查课程设计报告，给出学生成绩。
数据结构之排序算法操作论文1111111111 - 副本
排序算法操作课程名称：数据结构研究论文题目：排序算法操作院系：学生姓名：学号：专业班级：年月日数据结构之排序算法操作摘要：本文通过对数据结构中排序算法深入研究,实现了排序算法中的直接插入排序、快速排序和简单选择排序操作，进一步加深了对数据结构中排序算法的理解，得到的算法可以应用到以后的编程实践中。
关键词：排序时间复杂度空间复杂度稳定性1.引言排序是日常生活和工作中的一个常见问题，其目的是将一组原本无序的数据元素（或记录）序列，按照人们所需要的顺序，排列成有规律的按关键字有序的序列。
在现实生活中，人们要用到排序。
如：学生成绩往往需要按照成绩高低或按学号从前到后排序；在图书馆众多的图书中，需要按照各个学科将书籍归类；排队时从高到低的顺序排队等问题。
同样，排序也是计算机程序设计中的一个非常重要的操作，在计算机软件设计中占有极其重要的地位。
本文将对排序算法中直接插入排序、快速排序和简单选择排序三种算法的实现做一些研究。
2.算法的实现直接插入排序算法中，第i趟进行的操作为：在含有i-1个记录的有序子序列r[1…i-1]中插入一个记录r[i]后，变成含有i个记录的有序子序列r[1….i]；并且为了在查找插入位置的过程中避免数组下标出界，在r[0]处设置监视哨，在自i-1起往前搜索的过程中，可以同时后移记录。
算法1 直接插入排序算法Step1:从第二个记录起逐个进行关键字与前面关键字的比较并判断是否把该记录作为哨兵for ( i=2; i<=L.length; ++i )if(LT(L.r[i].key, L.r[i-1].key))L.r[0] = L.r[i]; //若“<”，将L.r[i]复制为哨兵Step2:在进行关键字比较的同时后移记录for ( j=i-1; LT( L.r[0].key, L.r[j].key ); --j )L.r[j+1] = L.r[j]; //记录后移Step3:把记录插入到正确的位置L.r[j+1] = L.r[0]; //插入到正确位置快速排序算法中，一趟快速排序的具体作法为：附设两个指针low 和high，他们的初值分别为low和high，设枢轴的关键字为pivokey，则首先从high所指位置起向前搜索找到第一个关键字小于pivokey 的记录和枢轴记录相互交换，然后从low所指位置起向后搜索，找到第一个关键字大于的pivokey记录和枢轴记录相互交换，重复这两步直至low=high为止。
综合排序正式论文
目录一、问题描述 (1)2.1 基本要求： (1)2.2. 算法思想： (1)2.3. 模块划分： (3)2.4. 数据结构： (16)2.5. 源程序： (17)2.6. 测试情况： (27)三、小结 (34)四、参考文献 (35)一、问题描述用C语言编程解决插入、冒泡，快速排序，简单选择，堆排序以及分析各种算法的时间复杂度和空间复杂度，比较各种排序在不同场合的适用程度，分析各种排序算法的实用性。
内容简介2.1 基本要求：（1）设计一个的菜单将在实现的功能显示出来，并有选择提示；（2）分别实现直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序，堆排序算法；（3）通过多种测试数据，对各种排序算法的时间复杂度和空间复杂度进行比较2.2. 算法思想：2.2.1简单选择排序<1> 基本思想每一趟在n-i+1(i=1,2,…,n-1)个记录中选取关键字最小的记录作为有序序列的第i个关键字。
2.2.2 直接插入排序<1> 基本思想插入排序的思想就是读一个，排一个，将第１个数放入数组的第１个元素中，以后读入的数与已存入数组的数进行比较，确定它在从大到小的排列中应处的位置．将该位置以及以后的元素向后推移一个位置，将读入的新数填入空出的位置中．2.2.3折半插入排序<1>基本思想从第二个数开始逐个置入监视哨，使用low，high标签进行折半判断比较大小，并确认插入位置，该位置到最后一个数全部后移一位，最后腾出该位置，把监视哨里面的数置入该位置。
后面的数以此类推进行排序，直到最后一个数比较完毕。
2.2.4希尔排序<1> 基本思想希尔排序法是1959年由D.L.Shell提出来的,又称减少增量的排序。
下表是以八个元素排序示范的例子.在该例中,开始时相隔4个成分,分别按组进行排序,这时每组2个成分,共4组; 然后相隔2个成分,在按组排序......最后,对所有相邻成分进行排序.2.2.5冒泡排序<1> 基本思想依次比较相邻的两个数,把大的放前面,小的放后面.即首先比较第1个数和第2个数,大数放前,小数放后.然后比较第2个数和第3个数......直到比较最后两个数.第一趟结束,最小的一定沉到最后.重复上过程,仍从第1个数开始,到最后第2个数.然后...... 由于在排序过程中总是大数往前,小数往后,相当气泡上升,所以叫冒泡排序.2.2.6快速排序<1> 基本思想快速排序的基本思想是基于分治策略的。
排序综合-课程设计报告
课程设计课程设计名称：专业班级：学生姓名：学号：指导教师：排序综合0000000000000 0000000000000 00000000000000 00000000000000课程设计时间:2010621 -2010625计算机科学与技术专业课程设计任务书说明：本表由指导教师填写，由教研室主任审核后下达给选题学生，装订在设计（论文）首页信息科学与工程学院课程设计成绩评价表信息科学与工程学院课程设计成绩评价表课程名称：数据结构课程设计设计题目：排序1、需求分析1.1、直接插入排序思路:设有一组关键字{K1,K2,…….,Kn},排序开始变认为K1是一个有序的序列, 让K2插入到表长为1的有序序列，使之成为一个表长为2的有序序列,让K3插入到表长为2的有序序列,使之成为一个表长为3的有序序列，依次类推,最后让Kn插入上述表长为n-1的有序序列,得到一个表长为n的有序序列.1.2、希尔排序思路：先取一个正整数d1（d1<n）把全部记录分成di个组，所有距离为di的倍数的记录看成是一组，然后在各组内进行插入排序；然后取d2（d2<d1）,重复上述分组和排序操作，直到取di=1（>=1）,即所有记录成为一个组为此.一般选di约为n/2,d2 为d1/2,…….,di=11・3、快速排序：（递归和非递归）思路:以第一个关键字K1为控制字，将[Ki、K2、….K n]分成两个子区，使左区的有关键字小于等于K1 ,右区所有关键字大于等于K1,最后控制居两个子区中间的适当位置。
在子区内数据尚处于无序状态。
将右区首、尾指针保存入栈，对左区进行与第（1）步相类似的处理，又得到它的左子区和右子区，控制字区中。
重复第（1）、（2）步，直到左区处理完毕。
然后退栈对一个个子区进行相类似的处理，直到栈空分区处理函数hoare思路：首先用两个指针i、j分别指向首、尾两个关键字，i=1，j=8。
如对（46、56、14、43、95、10、19、72）。
排序系统设计数据结构课程设计
数据结构课程设计题目：排序系统设计班级：姓名学号：同组人姓名：起迄日期: 2014.12.28-2015.01.04 课程设计地点:指导教师：完成日期：2014年12月目录一、问题描述 (3)二、概要设计 (4)三、详细设计 (6)四、程序调试与测试 (12)五、实验心得 (14)六、程序代码............................................................. 错误!未定义书签。
参考文献 (15)一、问题：1.题目13：排序系统设计功能：设编号为1，2，3，……，n的n(n>0)个人按顺时针方向围坐一圈，每个人持有一个正整数密码。
开始时任选一个正整数做为报数上限m，从第一个人开始顺时针方向自1起顺序报数，报到m是停止报数，报m的人出列，将他的密码作为新的m值，从他的下一个人开始重新从1报数。
如此下去，直到所有人全部出列为止。
令n最大值取30。
要求设计一个程序模拟此过程，求出出列编号序列。
1.分步实施：1初步完成总体设计，搭好框架，确定人机对话的界面，确定函数个数；2完成最低要求：建立一个文件，包括某人5个人的情况。
3进一步要求：有兴趣的同学可以自己扩充系统功能。
2.要求：1）界面友好，函数功能要划分好2）总体设计应画一流程图3）程序要加必要的注释4）要提供程序测试方案5) 程序一定要经得起测试，宁可功能少一些，也要能运行起来，不能运行的程序是没有价值的。
二、概要设计1、循环链表抽象数据类型定义typedef struct LNode//定义单循环链表中节点的结构{int num;//编号int pwd;//passwordstruct LNode *next;//指向下一结点的指针}LNode;2、本程序包含一下几个模块（1）构造结点模块LNode *createNode(int m_num,int m_pwd){LNode *p;p=(LNode *)malloc(sizeof(LNode));//生成一个结点p->num=m_num;//把实参赋给相应的数据域p->pwd=m_pwd;p->next=NULL;//指针域为空return p;}（2）创建链表模块void createList(LNode *ppHead,int n)（3）出队处理模块void jose(LNode *ppHead,int m_pwd)（4）约瑟夫环说明输出模块void instruction()（5）菜单模块void menu()（6）主函数模块int main（）函数的调用关系图如下：三、详细设计1.主函数图4 主函数数据流程图根据流程图，主函数程序如下：int main(){int n,m,x;LNode *ppHead=NULL;menu();for(;;){printf("\n请选择要执行的操作：");scanf("%d",&x);system("cls");switch(x){case 1:printf("*************************************************************** *\n");printf("约瑟夫环:\n");printf(" 编号为1,2,3,4…,n的n个人按顺时针方向围坐一圈,每人持有一个密\n");printf("码(正整数).一开始任选一个正整数作为报数的上限值m,从第一个人开始\n");printf("按顺时针方向自1开始顺序报数,报到m时停止.报m的人出列，将他的密码\n");printf("m作为新的m值,从他在顺时针方向上的下一人开始重新从1报数,如此下去,\n");printf("直到所有人全部出列为止.编程打印出列顺序.\n");printf("*************************************************************** *\n");main();break;case 2:printf("\n请输入总人数n：");scanf("%d",&n);printf("请输入开始上限数m：");scanf("%d",&m);createList(&ppHead,n);printf("\n");printf("出队顺序：\n");jose(ppHead,m);printf("\n约瑟夫环游戏结束!\n");main();break;case 0:exit(0);default:system("cls");printf("\n您选择的操作有误，请重新选择...\n\n\n");main();}}return 0;}2.链表的创建图5 创建链表函数的数据流程图/*创建单向循环链表ppHead，人数个数为n，并输入每个人的密码值，若建立失败则生成头结点，让cur指向他，若建立成功则插入结点P，cur指向的数据元素为p,后续为"空"的节点，再把P插入循环链表ppHead中*/根据流程图，创建链表函数程序如下：void createList(LNode **ppHead,int n)int i,m_pwd;LNode *p,*cur;//cur:浮标指针for(i=1;i<=n;i++){printf("输入第%d个人的密码：",i);scanf("%d",&m_pwd);//输入持有密码p=createNode(i,m_pwd);//调用构造结点函数if(*ppHead==NULL)//如果头结点为空{*ppHead=cur=p;//生成头结点，让cur指向他cur->next=*ppHead;//cur的指针域指向自身}else//如果不为空，则插入结点{p->next = cur->next;cur->next = p;cur= p;//cur指向新插入结点}}printf("完成创建！\n"); //提示链表创建完成}3.出队处理图6 出队函数的数据流程图/*p指向要删除节点的前一个节点，ppHead指向要删除的节点，使p=ppHead，ppHead再指向要删除节点的下一个节点，使p和ppHead链接，输出p指向节点的编号和密码值，释放ppHead，如此循环，直至把所有节点都打印和删除为止！*/根据流程图，出队函数程序如下：void jose(LNode *ppHead,int m_pwd){int i,j;LNode *p,*p_del;//定义指针变量for(i=1;p!=ppHead;i++){for(j=1;j<m_pwd;++j){p=ppHead;//p赋值为ppHead，p指向要删除结点的前一个结点ppHead=ppHead->next;//ppHead指向下一个元素}p->next = ppHead->next;//p结点与头结点链接i=ppHead->pwd;//i赋值为ppHead->pwdj=ppHead->num;//j赋值为ppHead->num，j为要删除的密码值printf("第%d个人出列，密码：%d\n",j,i);m_pwd=ppHead->pwd;//m_pwd赋值为ppHead->pwdfree(ppHead);//释放头结点ppHead=p->next;//ppHead重新赋值给p->next,即释放前的ppHead->pwd 指针//删除报数结点}i=ppHead->pwd;//i赋值为ppHead->pwdj=ppHead->num;//j赋值为ppHead->numprintf("最后一个出列是%d号，密码是:%d\n",j,i);free(ppHead);//释放头结点}4. 约瑟夫环说明模块void instruction(){printf("*************************************************************** *\n");printf("约瑟夫环:\n");printf(" 编号为1,2,3,4…,n的n个人按顺时针方向围坐一圈,每人持有一个密\n");printf("码(正整数).一开始任选一个正整数作为报数的上限值m,从第一个人开始\n");printf("按顺时针方向自1开始顺序报数,报到时停止.报m的人出列，将他的密码\n");printf("m作为新的m值,从他在顺时针方向上的下一人开始重新从1报数,如此下去,\n");printf("直到所有人全部出列为止.编程打印出列顺序.\n");printf("******************************************************\n");return 0;}5. 菜单模块void menu(){printf("**************************约瑟夫环*****************************\n");printf("\n");printf(" [1]约瑟夫环问题的阐述\n");printf(" [2]按要求求解约瑟夫环\n");printf(" [0]退出\n");printf("************************** 欢迎使用！****************************\n");}四、程序调试与测试本程序开始运行界面如下：选择1进入问题。
《数据结构》课程设计报告
《数据结构》课程设计报告一、课程目标《数据结构》课程旨在帮助学生掌握计算机科学中数据结构的基本概念、原理及实现方法，培养其运用数据结构解决实际问题的能力。
本课程目标如下：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课时，学习排序和查找算法，掌握各类算法的实现和应用。
数据结构论文
级课程（设计）论文题目阿克曼函数专业班级学号学生姓名指导教师指导教师职称学院名称完成日期：年月日武汉工程大学本科课程设计(论文)目录目录 (I)摘要 (II)前言 (II)第1章绪论 (1)1．1课题背景 (1)1．2课题意义 (1)1．3文献综述 (1)第2章课题的具体分析及程序的实现 (1)2．1 课题分析 (1)2．2 递归算法 (3)2．2．1 递归 (3)2．2．2 递归算法程序的设计 (3)2．2．3 实验结果 (3)2．3 利用栈的非递归算法 (9)2．3．1 栈 (9)2．3．2 主要成员函数的设计 (9)2．3．3利用栈的非递归算法程序的设计 (88)2．3．4实验结果 (99)2．4算法的复杂性分析 (10)2．5存在的问题及改进 (10)第3章总结 (11)致谢 (11)参考文献 (11)附录 (15)武汉工程大学本科课程设计(论文)摘要“数据结构”是计算机程序设计的重要理论技术基础，它是计算机学科的核心课程。
用数据结构中的知识、算法、思想解决一些实际问题可使得一些问题变得一目了然，易懂。
本课程设计的目的是通过C++语言平台实现阿克曼函数问题的算法设计，采用递归调用和以栈作为存储的非递归调用的方法解决，使抽象的数学问题程序化，并一目了然，更便于理解。
关键词：数据结构，阿克曼函数，递归，非递归武汉工程大学本科课程设计(论文)前言本文解决了递归和非递归方法实现阿克曼函数的问题，同时在非递归调用时利用了栈作为元素的存储空间。
全文共3章，详细的介绍了对本课题的算法设计过程及类容。
第1章介绍了课题背景和课题的意义。
在本章中，还给出了我们查阅并借用的一些参考文献的主要内容。
第2章主要介绍了课题的分析与算法的设计，对存在的问题作了简要分析并予以改进以及算法的复杂性的分析。
第3章是本次课程设计的总结。
全文的最后是致谢、参考文献和对程序优化处理的源代码。
高金金2011-1-6于武汉工程大学理学院武汉工程大学本科课程设计(论文)第1章 课题背景1．1课题背景阿克曼函数是数学中的经典问题，是非原始递归函数的例子。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
.XX职业技术师X大学课程设计任务书理学院数学0902班学生（16）马新月课程设计课题：16、综合排序：利用随机函数随机产生N=200个随机整数，对这些数进行多种方法的排序。
要求：1）至少采用三种方法实现上述问题求解（插入排序、希尔排序、冒泡排序、快速排序、堆排序、归并排序）。
把排序后的结果存在不同的文件中。
2）记录不同排序方法的运行时间，找出自己排序方法中最快的两种方法。
3）统计每种算法所用的比较次数和交换次数，以列表显示出来。
一、课程设计工作日自2012 年2月21日至2012年3月4日二、同组学生：马新月三、课程设计任务要求（包括课题来源、类型、目的和意义、基本要求、完成时间、主要参考资料等）：课题来源：教师提供课题类型：设计课程设计的目的1)使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法。
2)使学生掌握软件设计的基本内容和设计方法，并培养学生进行规X化软件设计的能力。
3）使学生掌握使用各种计算机资料和有关参考资料，提高学生进行程序设计的基本能力XX职业技术师X大学课程设计评审表学院班学生1概要1.1设计目的数据结构与算法课程主要是研究非数值计算的程序设计问题中所出现的计算机操作对象以及它们之间的关系和操作的学科。
数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。
学习数据结构与算法是为了将实际问题中涉及的对象在计算机中表示出来并对它们进行处理。
通过课程设计可以提高学生的思维能力，促进学生的综合应用能力和专业素质的提高。
1）本演示程序对以下6种常用的内部排序算法进行实测比较：冒泡排序，直接插入排序，简单选择排序，快速排序，希尔排序，堆排序；2）待排序表的元素的关键字为整数。
比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）；3）演示程序以以用户和计算机的对话方式执行，在计算机终端上显示提示信息，对随机数组进行排序，并输出比较指标值；4）最后对结果作出简单分析。
1.2预期目标按要求输入不同的操作。
输入后，根据不同的输入进行不同的操作，最终达到对各算法进行比较的目的。
通过此次课程设计主要达到以下目的了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；提高综合运用所学的理论知识和方法独立分析和解决问题的能力；训练用系统的观点和软件开发一般规X进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。
2排序算法2.1各排序算法的特点1）冒泡排序冒泡排序的基本概念是：依次比较相邻的两个数，将大数放在前面，小数放在后面。
即首先比较第1个和第2个数，将大数放前，小数放后。
然后比较第2个数和第3个数，将大数放前，小数放后，如此继续，直至比较最后两个数，将大数放前，小数放后，此时第一趟结束，在最后的数必是所有数中的最小数。
重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数），将大数放前，小数放后，一直比较到最小数前的一对相邻数，将大数放前，小数放后，第二趟结束，在倒数第二个数中得到一个新的最小数。
如此下去，直至最终完成排序。
由于在排序过程中总是大数往前放，小数往后放，相当于气泡往上升，所以称作冒泡排序。
2）直接插入排序每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。
第一趟比较前两个数,然后把第二个数按大小插入到有序表中;第二趟把第三个数据与前两个数从后向前扫描，把第三个数按大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。
3）简单选择排序（1）在一组元素V[i]~V[n-1]中选择具有最小排序码的元素（2）若它不是这组元素中的第个元素，则将它与这一组元素中的第一个元素对调；（3）在这组元素中剔除这个具有最小排序码的元素，在剩下的元素V[i+1]~V[n-1]中重复执行第（1）（2）步，直到剩余元素只有一个为止。
4）快速排序首先检查数据列表中的数据数，如果小于两个，则直接退出程序。
如果有超过两个以上的数据，就选择一个分割点将数据分成两个部分，小于分割点的数据放在一组，其余的放在另一组，然后分别对两组数据排序；5）希尔排序先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止；6) 堆排序堆排序是一树形选择排序，在排序过程中，将R[1..N]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素；堆的定义: N个元素的序列K1，K2，K3，...，Kn.称为堆，当且仅当该序列满足特性：Ki≤K2i Ki ≤K2i+1(1≤ I≤ [N/2])；2.2各算法的比较方法1.稳定性比较插入排序、冒泡排序、简单选择排序及其他线形排序是稳定的希尔排序、快速排序、堆排序是不稳定的2.时间复杂性比较插入排序、冒泡排序、选择排序的时间复杂性为O(n2)其它非线形排序的时间复杂性为O(nlog2n)线形排序的时间复杂性为O(n);3.辅助空间的比较线形排序的辅助空间为O(n),其它排序的辅助空间为O(1);4.其它比较插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。
反而在这种情况下，快速排序反而慢了。
当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
若待排序的记录的关键字在一个明显有限X围内时,且空间允许是用桶排序。
当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下，宜用归并排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序3流程图及详细算法3.1流程图函数的调用关系图反映了演示程序的层次结构：图3.1 流程图3.2流程图模块说明1）Main为主函数模块2）bubblesort，insertsort，selectsort，quicksort，shellsort，heansort分别对应冒泡排序，直接插入排序，简单选择排序，快速排序，希尔排序，堆排序的各函数模块3）在初始化数据之后，选择对应的排序模块进行排序，并对排序做出比较3.3可排序表的抽象数据类型定义：typedef struct{ //定义一个RedType型结构体，存放关键字int key; //关键字为整型} RedType;class LinkList //定义一个顺序表{public:RedType r[MAXSIZE+1]; //长度为MAXSIZE+1的数组r，数组里每个元素均为RedTypeint Length; //数组长度int CmpNum, ChgNum; //关键字的比较次数，移动次数LinkList(); //构造函数bool LT(int i, int j); //比较i和j的大小void Display(); //输出数组元素void Insert( int dk); //插入排序void ShellSort(); //希尔排序int Partition( int low, int high); //比基准小的数放左边，比起大的数放右边，返回基准位置void QSort( int low, int high); //从low到high位置进行快速排序void QuickSort(); //对有序表进行快速排序void HeapAdjust( int s, int m); //将无序堆调整为大顶堆void HeapSort(); //堆排序，将大顶堆转换为小顶堆void BubbleSort(); //冒泡排序int SelectMinKey( int k); //找到数组中最小值，返回最小值位置void SelSort(); //对顺序表进行选择排序void SelectSort(); //界面设计void AllAbove(); //统计以上所有排序关键字的比较次数、移动次数及所消耗的时间};3.4程序代码3.4.1 函数声明#include <stdio.h>#include <iostream.h>#include <stdlib.h>#include <string.h>#include <time.h>#include <windows.h>#include <winbase.h>#include <iomanip.h>#define MAXSIZE 1000#define TRUE 1#define FALSE 0typedef int BOOL;typedef struct{int key;} RedType;class LinkList{public:RedType r[MAXSIZE+1];int Length;int CmpNum, ChgNum; LinkList();bool LT(int i, int j);void Display();void Insert( int dk);void ShellSort();int Partition( int low, int high); void QSort( int low, int high); void QuickSort();void HeapAdjust( int s, int m); void HeapSort();void BubbleSort();int SelectMinKey( int k);void SelSort();void SelectSort();void AllAbove();};LinkList::LinkList(){int i;for (i = 0; i <= MAXSIZE; i++)r[i].key = rand()%1000; Length=MAXSIZE+1; CmpNum=0;ChgNum=0;}bool LinkList::LT(int i, int j){ (CmpNum)++;if (i < j)return TRUE;elsereturn FALSE;}void LinkList::Display(){int j;for(int i=0;i<=MAXSIZE;i++){cout<<setw(6)<<r[i].key;if(++j%10==0)cout<<endl;}cout<<endl;}4.3.2六种排序算法代码//插入排序void LinkList::Insert(int dk){int i, j;RedType Temp;for (i = dk; i < Length; i++){if (LT(r[i].key, r[i - dk].key)){memcpy(&Temp, &r[i], sizeof(RedType));for (j = i - dk; j >= 0 && LT(Temp.key, r[j].key); j -= dk){(ChgNum)++;memcpy(&r[j + dk], &r[j], sizeof(RedType));}memcpy(&r[j + dk], &Temp, sizeof(RedType));}}}//希尔排序void LinkList::ShellSort(){int t=Length+1;do{t=t/3+1;Insert( t);}while(t>1);}//快速排序int LinkList::Partition(int low, int high){RedType Temp;int PivotKey;memcpy(&Temp, &r[low], sizeof(RedType));PivotKey = r[low].key;while (low < high){while (low < high &&r[high].key >= PivotKey){high--;(CmpNum)++;}(ChgNum)++;memcpy(&r[low], &r[high], sizeof(RedType));while (low < high && r[low].key <= PivotKey){low++;(CmpNum)++;}(ChgNum)++;}memcpy(&r[low], &Temp, sizeof(RedType)); return low;}void LinkList::QSort( int low, int high){int PivotLoc = 0;if (low < high){PivotLoc = Partition( low, high);QSort(low, PivotLoc - 1);QSort( PivotLoc + 1, high);}}void LinkList::QuickSort(){QSort(0, Length - 1);}//堆排序void LinkList::HeapAdjust(int s, int m){RedType Temp;int j = 0;s++;memcpy(&Temp, &r[s - 1], sizeof(RedType)); for (j = 2 * s; j <= m; j *= 2){if (j < m && LT(r[j - 1].key, r[j].key))++j;if (!LT(Temp.key, r[j - 1].key))break;(ChgNum)++;memcpy(&r[s - 1], &r[j - 1], sizeof(RedType));s = j;}memcpy(&r[s - 1], &Temp, sizeof(RedType));}void LinkList::HeapSort(){int i = 0;RedType Temp;for (i = Length / 2-1; i >= 0; i--)HeapAdjust(i, Length);for (i = Length; i > 1; i--){memcpy(&Temp, &r[0], sizeof(RedType));(ChgNum)++;memcpy(&r[0], &r[i - 1], sizeof(RedType));HeapAdjust( 0, i - 1);}}//冒泡排序void LinkList::BubbleSort(){int i, j;RedType temp;for (i = 1; i <= MAXSIZE; i++){for (j = 1; j <= MAXSIZE - i; j++){if (!LT(r[j].key, r[j + 1].key)){(ChgNum)++;memcpy(&temp, &r[j], sizeof(RedType));memcpy(&r[j], &r[j + 1], sizeof(RedType));memcpy(&r[j + 1], &temp, sizeof(RedType));}}}}//选择排序int LinkList::SelectMinKey( int i){int Min = i;for (int k=i; k < Length; k++){if (!LT(r[Min].key, r[k].key))Min = k;}return Min;}void LinkList::SelSort(){int i, j;RedType temp;for (i = 0; i < Length; i++){j = SelectMinKey( i);if (i != j){(ChgNum)++;memcpy(&temp, &r[i], sizeof(RedType));memcpy(&r[i], &r[j], sizeof(RedType));memcpy(&r[j], &temp, sizeof(RedType));}}}4.3.3 排序算法的选择void LinkList::SelectSort(){cout<<"1. 插入排序"<<endl;cout<<"2. 希尔排序"<<endl;cout<<"3. 快速排序"<<endl;cout<<"4. 堆排序"<<endl;cout<<"5. 冒泡排序"<<endl;cout<<"6. 选择排序"<<endl;cout<<"7. 以上各种排序"<<endl;cout<<"8. 退出程序"<<endl;cout<<"请选择需要进行的操作:"<<endl;}void LinkList::AllAbove(){int TempTime;int SpendTime;cout<<endl;LinkList();cout<<"插入排序:"<<endl;TempTime = (int)GetTickCount();Insert( 1);SpendTime = (int)GetTickCount() - TempTime;cout<<endl;cout<<"pareNumber="<<CmpNum<<" "<<"ChageNumber="<<ChgNum<<" "<<"TimeSpent="<<SpendTime<<"ms"<<endl;LinkList();//随机数列复位cout<<endl;cout<<"希尔排序:"<<endl;TempTime = (int)GetTickCount();ShellSort();SpendTime = (int)GetTickCount() - TempTime;cout<<endl;cout<<"pareNumber="<<CmpNum<<" "<<"ChageNumber="<<ChgNum<<" "<<"TimeSpent="<<SpendTime<<"ms"<<endl;LinkList(); //随机数列复位cout<<endl;cout<<"快速排序:"<<endl;TempTime = (int)GetTickCount();QuickSort();SpendTime = (int)GetTickCount() - TempTime;cout<<endl;cout<<"pareNumber="<<CmpNum<<" "<<"ChageNumber="<<ChgNum<<" "<<"TimeSpent="<<SpendTime<<"ms"<<endl;LinkList(); //随机数列复位cout<<endl;cout<<"堆排序:"<<endl;TempTime = (int)GetTickCount();HeapSort();SpendTime = (int)GetTickCount() - TempTime;cout<<endl;cout<<"pareNumber="<<CmpNum<<" "<<"ChageNumber="<<ChgNum<<" "<<"TimeSpent="<<SpendTime<<"ms"<<endl;LinkList(); //随机数列复位cout<<endl;cout<<"冒泡排序:"<<endl;TempTime = (int)GetTickCount();BubbleSort();SpendTime = (int)GetTickCount() - TempTime;cout<<endl;cout<<"pareNumber="<<CmpNum<<" "<<"ChageNumber="<<ChgNum<<" "<<"TimeSpent="<<SpendTime<<"ms"<<endl;LinkList(); //随机数列复位cout<<endl;cout<<"选择排序:"<<endl;TempTime = (int)GetTickCount();SelSort();SpendTime = (int)GetTickCount() - TempTime;cout<<endl;cout<<"pareNumber="<<CmpNum<<" "<<"ChageNumber="<<ChgNum<<" "<<"TimeSpent="<<SpendTime<<"ms"<<endl;}4.3.4主函数程序代码void main(){int i,j;int select = 0;int SpendTime = 0;int TempTime;do{LinkList L;L.SelectSort();cin>>select;switch (select){case 1:cout<<"插入排序前:"<<endl;L.Display();cout<<"插入排序后:"<<endl;TempTime = (int)GetTickCount();L.Insert(1);SpendTime = (int)GetTickCount() - TempTime;L.Display();cout<<endl;cout<<"比较次数="<<L.CmpNum<<" "<<"关键字移动次数="<<L.ChgNum<<" "<<"所需时间="<<SpendTime<<"ms"<<endl;break;case 2:cout<<"希尔排序前:"<<endl;L.Display();cout<<"希尔排序后:"<<endl;cout<<endl;TempTime = (int)GetTickCount();L.ShellSort();SpendTime = (int)GetTickCount() - TempTime;L.Display();cout<<endl;cout<<"比较次数="<<L.CmpNum<<" "<<"关键字移动次数="<<L.ChgNum<<" "<<"所需时间="<<SpendTime<<"ms"<<endl;break;case 3:cout<<"快速排序前:"<<endl;L.Display();cout<<"快速排序后:"<<endl;TempTime = (int)GetTickCount();L.QuickSort();SpendTime = (int)GetTickCount() - TempTime;L.Display();cout<<endl;cout<<"比较次数="<<L.CmpNum<<" "<<"关键字移动次数="<<L.ChgNum<<" "<<"所需时间="<<SpendTime<<"ms"<<endl;break;case 4:cout<<"堆排序前:"<<endl;L.Display();cout<<"堆排序后:"<<endl;TempTime = (int)GetTickCount();L.HeapSort();SpendTime = (int)GetTickCount() - TempTime;L.Display();cout<<endl;cout<<"比较次数="<<L.CmpNum<<" "<<"关键字移动次数="<<L.ChgNum<<" "<<"所需时间="<<SpendTime<<"ms"<<endl;break;case 5:cout<<"冒泡排序前:"<<endl;L.Display();cout<<"冒泡排序后:"<<endl;TempTime = (int)GetTickCount();L.BubbleSort();SpendTime = (int)GetTickCount() - TempTime;L.Display();cout<<endl;cout<<"比较次数="<<L.CmpNum<<" "<<"关键字移动次数="<<L.ChgNum<<" "<<"所需时间="<<SpendTime<<"ms"<<endl;break;case 6:cout<<"选择排序前:"<<endl;L.Display();cout<<"选择排序后:"<<endl;TempTime = (int)GetTickCount();L.SelSort();SpendTime = (int)GetTickCount() - TempTime;L.Display();cout<<endl;cout<<"比较次数="<<L.CmpNum<<" "<<"关键字移动次数="<<L.ChgNum<<" "<<"所需时间="<<SpendTime<<"ms"<<endl;break;case 7:L.AllAbove();break;default:cout<<"please input numbers again"<<endl;break;}}while(select!=8);}4运行结果4.1调试分析1．对正序、逆序和若干不同程度随机打乱的可排序表，进行各种排序方法的比较测试，得到的测试数据具有较好的典型性和可比较性。