内部排序比较 (实验报告+源程序)C++
快速排序算法c语言实验报告
快速排序算法c语言实验报告冒泡法和选择法排序C程序实验报告实验六:冒泡法排序物理学416班赵增月F12 2011412194日期:2013年10月31日一·实验目的 1.熟练掌握程序编写步骤;2.学习使用冒泡法和选择法排序;3.熟练掌握数组的定义和输入输出方法。
二·实验器材1.电子计算机;2.VC6.0三·实验内容与流程1.流程图(1)冒泡法(2)选择法 2.输入程序如下:(1)冒泡法#includestdio.h void main() { int a[10]; int i,j,t; printf(请输入10个数字:\n); for(i=0;i10;i++)scanf(%d,&a[i]); printf(\n); for(j=0;j9;j++)for(i=0;i9-j;i++) if(a[i]a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } printf(排序后如下:\n); for(i=0;i10;i++) printf(%d,a[i]); printf(\n); }(2)选择法#includestdio.h void main() { int a[10]; int i,j,t,k; printf(请输入10个数字:\n); for(i=0;i10;i++)scanf(%d,&a[i]);printf(\n); for(i=0;i9;i++) {k=i;for(j=i+1;j10;j++) if (a[k]a[j])k=j;t=a[i];a[i]=a[k];a[k]=t; }printf(排序后如下:\n); for(i=0;i10;i++)printf(%d,a[i]); printf(\n); }四.输出结果(1冒泡法)请输入10个数字:135****2468排序后如下:12345678910 (2)选择法输出结果请输入10个数字:135****6810排序后如下:12345678910五.实验反思与总结1.冒泡法和选择法是一种数组排序的方法,包含两层循环,写循环时,要注意循环变量的变化范围。
数据结构实验排序
数据结构实验报告排序一、实习目的熟悉几种典型的排序方法,并对各种算法的特点、使用范围和效率有进一步的了解。
二、实例排序是计算机科学中非常基本且使用频繁的运算,在计算机系统软件和应用软件中都有广泛的应用。
下面给出的是冒泡排序、快速排序的实现与比较。
/* 源程序的头文件sort.h */void getra ndat(Data ary[],i nt cou nt) /* 产生一批随机数,准备排序*/{ long int a=100001;int i;for(i=0;i<cou nt;i++){ a=(a*125)%2796203;ary[i].key=(i nt)a;}} /* getra ndat */void prdata(Data ary[],i nt count) I*输出数据的函数*/{ int i; char ch;printf( n“);for(i=0;i<count;i++) printf( “ %6c”,ary[i].key);printf( n“);printf( "\n\n 打回车键,结束显示。
“);ch=getch();} I* prdata *I[两种排序方法的比较源程序]I* sortcmp.c *I#in clude <stdio.h>#in clude <stdlib.h>#define MAX 1000 I*数组最大界限*Itypedef int ElemType; I* 关键字的类型*Itypedef struct{ ElemType key;int shu;}Data;Data ar[MAX],br[MAX];typedef struct{ int lo,hi;}Selem;typedef struct{ Selem elem[MAX];int top;}SqStack;SqStack s1;/* 函数声明*/void bubble(Data ary[],int n);void getrandat(Data ary[],int count) ; void qksort(Data ary[],int n);void hoare(Data ary[],int l,int h); void init_s(SqStack *s);void push(SqStack *s,Selem e); Selem pop(SqStack *s);void prdata(Data ary[],int count); int empty(SqStack s);/* 主函数*//* 其它属性域*//* 一个纪录的结构体类型*//* 栈的元素结构体类型*//* 一维数组子域*//* 栈顶指针子域*//* 栈的顺序结构体类型*//* 产生一批随机数,准备排序*//* 进栈一个元素*/ /* 输出数据的函数*/void main(){ int k,n,j; j; char ch;do { printf("\n\n\n");printf("\n\n 1. 产生一批随机数准备排序");printf("\n\n 2. 一般情况的起泡排序");printf("\n\n 3. 有序情况的起泡排序");printf("\n\n 4. 一般情况的快速排序");printf("\n\n 5. 有序情况的快速排序");printf("\n================== printf("\n 请输入您的选择 scanf("%d",&k); switch(k){ case 1:{ printf("the number ofdatas:"); /*scanf("%d",&n);getrandat(ar,n); for(j=0;j<n;j++)br[j]=ar[j]; prdata(ar,n); } break;case 2:{ for(j=0;j<n;j++) ar[j]=br[j];bubble(ar,n); prdata(ar,n); } break;case 3: { bubble( ar,n); prdata(ar,n);} break;=================="); (1,2,3,4,5,6)");输入数据个数 *//*产生 n 个随机数 *//* 保留复原始数据 *//* 恢复原始数据 */ /* 对 n 个数据起泡排序 *//* 排序后输出 *//* 有序情况的起泡排序 */ 恢复原始数据*//* 对 n 个数据快速排序 *//* 排序后输出 *//* 有序情况的快速排序 */case 4:{ for(j=0;j<n;j++) ar[j]=br[j]; /*qksort(ar,n); prdata(ar,n);} break;case 5:{ qksort(ar,n);prdata(ar,n);} break;case 6: exit(0);} /* switch */printf("\n --------------- ");}while(k>=1 && k<6);printf("\n 打回车键,返回。
数据结构实验指导书(新版)
《数据结构和算法》实验指导书实验及学时数分配序号实验名称学时数(小时)1 实验一线性表 42 实验二树和二叉树 23 实验三图 24 实验四查找 25 实验五内部排序 2合计12几点要求:一、上机前:认真预习相关实验内容,提前编写算法程序,上机时检查(未提前编写程序者,扣除平时成绩中实验相关分数)。
二、上机中:在Turbo C或VC6.0环境中,认真调试程序,记录调试过程中的问题、解决方法以及运行结果。
上机时签到;下机时验收签字。
三、下机后:按要求完成实验报告,并及时提交(实验后1周内)。
实验一线性表【实验目的】1、掌握用Turbo c上机调试线性表的基本方法;2、掌握线性表的基本操作,插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算;3、运用线性表解决线性结构问题。
【实验学时】4 学时【实验类型】设计型【实验内容】1、顺序表的插入、删除操作的实现;2、单链表的插入、删除操作的实现;3、两个线性表合并算法的实现。
(选做)【实验原理】1、当我们在线性表的顺序存储结构上的第i个位置上插入一个元素时,必须先将线性表中第i个元素之后的所有元素依次后移一个位置,以便腾出一个位置,再把新元素插入到该位置。
若是欲删除第i个元素时,也必须把第i个元素之后的所有元素前移一个位置;2、当我们在线性表的链式存储结构上的第i个位置上插入一个元素时,只需先确定第i个元素前一个元素位置,然后修改相应指针将新元素插入即可。
若是欲删除第i个元素时,也必须先确定第i个元素前一个元素位置,然后修改相应指针将该元素删除即可;3、详细原理请参考教材。
【实验步骤】一、用C语言编程实现建立一个顺序表,并在此表中插入一个元素和删除一个元素。
1、通过键盘读取元素建立线性表;(从键盘接受元素个数n以及n个整形数;按一定格式显示所建立的线性表)2、指定一个元素,在此元素之前插入一个新元素;(从键盘接受插入位置i,和要插入的元素值;实现插入;显示插入后的线性表)3、指定一个元素,删除此元素。
排序实验报告
2014-2015学年第一学期实验报告
课程名称:算法与数据结构
实验名称:排序
日期:2015 年 1 月 5 日
目录
一、实验目的 (3)
二、实验内容 (3)
三、实验环境 (3)
四、实验结果 (3)
五、附录 (6)
5.1附录 (6)
5.1 问题分析 (6)
5.2 设计方案 (6)
5.3 算法 (6)
5.4仿真结果 (6)
5.5 调试心得 (6)
一、实验目的
练习排序的使用,进而对排序有个更深的理解。
二、实验内容
对8 种常用的内部排序算法进行比较:直接插入排序;折半插入排序;希尔排序;起泡排序;快速排序;简单选择排序;堆排序;归并排序。
三、实验环境
VS2010 、win8.1
四、实验结果
重新生成排序:
五、附录
5.1附录
5.1 问题分析
该实验的主要工作是设法在程序中适当的地方插入计数操作。
比较的指标为有关键字参加的比较次数和关键字移动次数。
5.2 设计方案
该程序大致分为以下几个模块:
5.3 算法
无重要算法。
5.4仿真结果
见四、实验结果。
5.5 调试心得
通过这次试验,对直接插入排序,折半排序,希尔排序,简单选择排序,堆排序,归并排序,冒泡排序等八种排序算法的思想有了进一步的认识,同时对八种算法有了更进一步的掌握。
实验五-查找和排序实验报告 查找及排序实验
并对调试过程中的问题进行分析,对执
输入你晏査找的关键字:阴
第1页共1页
2S 査我旗 I 加
本文格式为 Word 版,下载可任意编辑,页眉双击删除即可。
通过本次排序和查找的练习,初步把握了其基本概念和操作。
冃次查找?(Y/W :
查找的基本概念: 查找表: 是由同一类型的数据元素〔或记录〕构
输入像要查戏的关键字:4
else low=mid +1 ;
return i; }
}
(3)写出源程序清单(加适当的注释)。
return 0;
;//建立一个二叉树,元素从键盘输入,
}//Serch_B in;
直到回车为止
2.顺序查找算法描述如下: typedef struct {
void insert(BiTree *bt,BiTree s){// 在二叉树中插
else return select (bt-rchild,key);
(1 )
-
请输入要一列整数,以空格隔开,回车结束.
-修改 -
12 刖 55 23 55 78 121 31
(4)
非序后:
(4)调试说明。包括上机调试的状况、调试所遇到的问题是如何解决的, 12239134 FE E5 78 121
第1页共1页
in sert(((*bt)-lchild),s);
本文格式为 Word 版,下载可任意编辑,页眉双击删除即可。
while(1)
s-dt=key;
prin tf(%5d,bt-dt);
else if (s-dt(*bt)-dt)
{
s-lchild=s-rchild=NULL;
ZXBL (bt-rchild);
形考作业四及答案
形考作业四及答案(本部分作业覆盖教材第8-9章的内容)一、单项选择题1、顺序查找方法适合于存储结构为()的线性表。
A.散列存储B.索引存储C.散列存储或索引存储D.顺序存储或链接存储2、对线性表进行二分查找时,要求线性表必须()。
A.以顺序存储方式B.以链接存储方式C.以顺序存储方式,且数据元素有序D.以链接存储方式,且数据元素有序3、对于一个线性表,若要求既能进行较快地插入和删除,又要求存储结构能够反映数据元素之间的逻辑关系,则应该()。
A.以顺序存储方式B.以链接存储方式C.以索引存储方式D.以散列存储方式4、采用顺序查找方法查找长度为n的线性表时,每个元素的平均查找长度为()。
A.n B.n/2C.(n+1)/2 D.(n-1)/25、哈希函数有一个共同的性质,即函数值应当以()取其值域的每个值。
A.最大概率B.最小概率C.平均概率D.同等概率6、有一个长度为10的有序表,按折半查找对该表进行查找,在等概率情况下查找成功的平均比较次数为()。
A.29/10 B.31/10 C.26/10 D.29/97、已知一个有序表为{11,22,33,44,55,66,77,88,99},则顺序查找元素55需要比较()次。
A.3 B.4 C.5 D.68、顺序查找法与二分查找法对存储结构的要求是()。
A.顺序查找与二分查找均只是适用于顺序表B.顺序查找与二分查找均既适用于顺序表,也适用于链表C.顺序查找只是适用于顺序表D.二分查找适用于顺序表9、有数据{53,30,37,12,45,24,96},从空二叉树开始逐个插入数据来形成二叉排序树,若希望高度最小,应该选择的序列是()。
A.45,24,53,12,37,96,30 B.37,24,12,30,53,45,96C.12,24,30,37,45,53,96 D.30,24,12,37,45,96,5310、对有18个元素的有序表作二分(折半)查找,则查找A[3]的比较序列的下标可能为()。
数据结构(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].num<=RandArray[i]; L->Length<=i;}BOOL LT(int i, int j,int* CmpNum){(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;}void Display(LinkList* L){FILE* f; //定义一个文件指针f int i;若打开文件的指令不为空则//通过文件指针f打开文件为条件判断{ //是否应该打开文件输出“can't open file”;exit(0); }for (i=0; i小于L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);通过文件指针f关闭文件;三、调试分析1.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中,我曾多次修改代码,并根据调试显示的界面一次次调整代码。
数据结构实验指导书(新版)
《数据结构与算法》实验指导书实验及学时数分配几点要求:一、上机前:认真预习相关实验内容,提前编写算法程序,上机时检查(未提前编写程序者,扣除平时成绩中实验相关分数)。
二、上机中:在Turbo C或VC6.0环境中,认真调试程序,记录调试过程中的问题、解决方法以及运行结果。
上机时签到;下机时验收签字。
三、下机后:按要求完成实验报告,并及时提交(实验后1周内)。
实验一线性表【实验目的】1、掌握用Turbo c上机调试线性表的基本方法;2、掌握线性表的基本操作,插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算;3、运用线性表解决线性结构问题。
【实验学时】4 学时【实验类型】设计型【实验内容】1、顺序表的插入、删除操作的实现;2、单链表的插入、删除操作的实现;3、两个线性表合并算法的实现。
(选做)【实验原理】1、当我们在线性表的顺序存储结构上的第i个位置上插入一个元素时,必须先将线性表中第i个元素之后的所有元素依次后移一个位置,以便腾出一个位置,再把新元素插入到该位置。
若是欲删除第i个元素时,也必须把第i个元素之后的所有元素前移一个位置;2、当我们在线性表的链式存储结构上的第i个位置上插入一个元素时,只需先确定第i个元素前一个元素位置,然后修改相应指针将新元素插入即可。
若是欲删除第i个元素时,也必须先确定第i个元素前一个元素位置,然后修改相应指针将该元素删除即可;3、详细原理请参考教材。
【实验步骤】一、用C语言编程实现建立一个顺序表,并在此表中插入一个元素和删除一个元素。
1、通过键盘读取元素建立线性表;(从键盘接受元素个数n以及n个整形数;按一定格式显示所建立的线性表)2、指定一个元素,在此元素之前插入一个新元素;(从键盘接受插入位置i,和要插入的元素值;实现插入;显示插入后的线性表)3、指定一个元素,删除此元素。
(从键盘接受删除元素位置i,实现删除;显示删除后的线性表)二、用C语言编程实现建立一个单链表,并在此表中插入一个元素和删除一个元素。
DS_上机实验的目的、要求和评分标准
上机实验的目的、要求和评分标准一、实验目的上机实践是各位对本门课程所学知识的一种全面、综合的能力训练,是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节,也是对课堂教学与实践教学效果的一种检验。
通常,实验题中的问题比平时的习题复杂得多,也更接近实际。
实验着眼于原理与应用的结合,使你们学会如何把书上学到的知识运用于解决实际问题的过程中去,培养从事软件开发设计工作所必需的基本技能;另一方面,能使书上的知识变“活”,起到深化理解和灵活掌握教学内容的目的。
平时的练习较偏重于如何编写功能单一的“小”算法,而实验题是软件设计的综合训练,包括问题分析(需求分析)、总体结构设计和用户界面设计(概要设计)、程序设计基本技能和技巧等,即一整套软件工程规范的训练和科学作风的培养。
此外,还有很重要的一点是:机器是比任何教师都严厉的主考者。
为了达到上述目的,本课程共安排了10个实验单元,各单元的训练重点在于基本的数据结构,而不强调面面俱到。
各实验单元与教科书的各章具有紧密的对应关系。
二、要求:⒈做好每一次上机前的准备以提高上机效率:①预先认真阅读相关实验内容,做到心中有明确的目的要求和任务,要有备而来,应该自己独立的思考和设计你的算法和程序,并争取在规定的时间内如期完成上机工作任务。
对于个别目前基础较差的同学,实在是没法完成任务的建议你先参考其他同学的算法,勤学好问,最终自己独立完成,以增强你的感性认识,强化你的实践基础,提高你的实践能力。
②按照实验内容规定的习题题目,事先在实验预习报告上编写好源程序及运行程序所需的典型数据,并经人工静态检查认为无误;手编程序应书写整齐,应在每个题目之间留出一定的空间,以备记录上机调试情况和运行结果等;对程序中自己有疑问的地方,应作出记号,以便上机时给以注意。
③将想要上机验证的问题草拟提纲;制定一个简捷的程序调试计划。
⒉上机时输入和调式自己所编写的程序。
对“出错信息”,应善于自己分析判断,并充分利用开发工具提供的错误信息和调试手段解决出现的问题,及时修改与完善算法、源程序,随时记录有价值的内容。
排序算法实验报告
数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的C语言程序,要求包含直接插入排序、希尔排序、简单项选择择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。
二、实验步骤各种内部排序算法的比较:1.八种排序算法的复杂度分析〔时间与空间〕。
2.八种排序算法的C语言编程实现。
3.八种排序算法的比较,包括比较次数、移动次数。
三、稳定性,时间复杂度和空间复杂度分析比较时间复杂度函数的情况:时间复杂度函数O(n)的增长情况所以对n较大的排序记录。
一般的选择都是时间复杂度为O(nlog2n)的排序方法。
时间复杂度来说:(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序;(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序;(3)O(n1+§))排序,§是介于0和1之间的常数。
希尔排序(4)线性阶(O(n))排序基数排序,此外还有桶、箱排序。
说明:当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数,时间复杂度可降至O〔n〕;而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为O〔n2〕;原表是否有序,对简单项选择择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性:排序算法的稳定性:假设待排序的序列中,存在多个具有相同关键字的记录,经过排序,这些记录的相对次序保持不变,则称该算法是稳定的;假设经排序后,记录的相对次序发生了改变,则称该算法是不稳定的。
稳定性的好处:排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。
另外,如果排序算法稳定,可以防止多余的比较;稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。
数据结构课程设计报告
}
通过查阅资料,希尔排序的复杂度应该为O( )。
通过运行程序,获得其运行时间、比较次数、交换次数和数组规模关系如下:
起泡排序
起泡排序基本思路是遍历未排序的数组,将相邻两个元素中较小的移向后方。多次遍历数组未排序部分后完成排序。
对于堆排序,他的平均时间复杂度为O(n*logn)。
算法实现如下:
voidHeapAdjust(intarray[],inti,intnLength){
intnChild;
intnTemp;
for(;2*i+1<nLength;i=nChild){
nChild=2*i+1;
if(nChild<nLength-1&&array[nChild+1]>array[nChild])++nChild;
inttemp,j;
for(inti= 0;i<len; ++i){
temp= a[i];
j =i- 1;
while(temp > a[j] && j > -1) {
a[j + 1] = a[j];
j -= 1;
}
a[j + 1] = temp;
}//end for
}//endInsert_Sort()
简单选择排序
简单选择排序通过遍历未排序数组,从中选出最小的元素并置于有序数组的第一个,其时间复杂度为O( ),而且这种排序算法是一种稳定的排序算法。
算法实现如下:
voidSelection_Sort(int*a,intlen){
软件技术基础实验指导书(1)
软件技术基础实验指导书2014年9月1日目录实验一斐波那契数列的实现算法及分析 (3)实验二顺序表的实现与应用 (5)实验三链表的实现和应用 (7)实验四栈的实现和应用 (9)实验五队列 (11)实验六二叉树的创建和遍历 (12)实验七图 (15)实验八哈夫曼树及哈夫曼编码 (16)实验九查找算法的实现 (19)实验十内部排序算法的实现 (26)实验十一迷宫问题 (29)实验十二 B+树程序设计 (30)实验十三四叉树程序设计 (31)实验十四修路方案问题 (32)实验一斐波那契数列的实现算法及分析实验目的:1.掌握分别用递归和非递归方法计算斐波那契(Fibonacci)数列。
2.掌握算法性能测试的方法,并能进行算法分析和比较。
实验环境(硬/软件要求):Windows 2000, VisualC++ 6.0实验内容:二阶Fibonacci数列的定义如下:F0=1,F1=1, F2=2,F3=3,F4=5,。
,Fi=F(i-1)=F(i-2) (i>=1).试用递归法和非递归法两种方法写出计算Fn的函数。
实验要求:1.完成计算Fn的递归函数Fib-rec.2.完成计算Fn的非递归数列Fib-ite.3.当n=10,15,20,25,30,35,40,45时测试以上两种算法执行的时间,并把测试结果填写在附表1-1中。
附表1-1 测试表注:表格中填写的是测试时间,单位μm.4.试解释两种算法在执行时间上的不同,并对两种算法进行算法分析。
【C语言源程序】#include <stdio.h>#include <time.h>Long Fib-rec(int n){if(n==0||n==1)return(1);else return(Fib-rec(n-1) + Fib-rec(n-2) );}long Fib-ite(int n){long fib1,fib2,fib;int i;fib1=1;fib2=1;for (i=3;i<=n,i + + ){fib=fib1+fib2;fib1=fib2;fib2=fib;}return fib;}void main ( ){clock-t us1, us2;int n;printf(“请输入n:\n”);scanf(“%d,&n);us1=clock( );printf(“递归函数计算结果:%1d\n”,Fib-rec(n) ); us2=clock( );printf(“递归函数执行时间%1d毫秒\n”,us2-us1);us1=clock( );printf(“非递归函数计算结果:%1d\n”,Fib-ite(n) ); us2=clock( );printf(非递归函数执行时间%1d毫秒\n”,us2-us1);}实验二顺序表的实现与应用实验目的:1.掌握线性表的概念。
内部排序C程序
1.简单插入排序截图:2.折半插入排序截图:3.快速排序截图:4.直接选择排序截图:5.堆排序截图:源程序清单如下:/*类型的定义*/#define MAXSIZE 20#define LT(a,b) ((a)<(b))#include <stdio.h>#include <conio.h>typedef int KeyType;typedef int InfoType;typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;void InsertSort(SqList *L){ /*简单插入排序*/ int i,j;for(i=2;i<=L->length;++i){if(LT(L->r[i].key,L->r[i-1].key)){L->r[0]=L->r[i];for(j=i-1;LT(L->r[0].key,L->r[j].key);j--){L->r[j+1]=L->r[j];}L->r[j+1]=L->r[0];}}}void BInsertSort(SqList *L){ /*折半插入排序*/int i,j;int low,high,m;for(i=2;i<=L->length;++i){L->r[0]=L->r[i]; /*将R[i]暂存到R[0]*/low=1;high=i-1;while(low<=high){ /*在R[low..high]中折半查找插入的位置*/ m=(low+high)/2;if(LT(L->r[0].key,L->r[m].key)){high=m-1; /*插入点在低半区*/}else{low=m+1; /*插入点在高半区*/}}for(j=i-1;j>=high+1;--j){ /*记录后移*/L->r[j+1]=L->r[j];}L->r[high+1]=L->r[0]; /*插入*/}}int Partition(SqList *L,int low,int high){ /*快速排序*/int pivotkey;L->r[0]=L->r[low]; /*用子表的第一个记录作枢轴记录*/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){int pivotloc;if(low<high){pivotloc=Partition(L,low,high); /*将L.r[low..high]一分为二*/QSort(L,low,pivotloc-1); /*对低子表递归排序,pivotloc是枢轴位置*/QSort(L,pivotloc+1,high); /*对高子表递归排序*/}}void QuickSort(SqList *L){ /*对记录序列进行快速排序*/ QSort(L,1,L->length);}int SelectMinKey(SqList L,int i){ /*简单选择排序*/int k;int j;k=i;for(j=i;j<L.length+1;j++){if(L.r[k].key>L.r[j].key){k=j;}}return k;}void SelectSort(SqList *L){ /*简单选择排序*/RedType t;int i,j;for(i=1;i<L->length;++i){ /*选择第i小的记录,并交换到位*/j=SelectMinKey(*L,i); /*在R[i..n]中选择key最小的记录*/if(i!=j){t=L->r[i];L->r[i]=L->r[j];L->r[j]=t;} /*与第i个记录交换*/}}typedef SqList HeapType;void HeapAdjust(HeapType *H,int s,int m){ /*堆排序*/RedType rc;int j;rc=H->r[s];for(j=2*s;j<=m;j*=2){ /*沿key较大的孩子结点向下筛选*/if(j<m&<(H->r[j].key,H->r[j+1].key)){++j; /*j为key较大的记录的下标*/}if(!LT(rc.key,H->r[j].key)){break; /*rc应插入在位置s上*/}H->r[s]=H->r[j];s=j;}H->r[s]=rc; /*插入*/}void HeapSort(HeapType *H){RedType t;int i;for(i=H->length/2;i>0;--i){ /*把R[1..n]建成大顶堆*/HeapAdjust(H,i,H->length);}for(i=H->length;i>1;--i){/*将堆顶记录和当前未经排序子序列R[1..i]中最后一个记录相互交换*/t=H->r[1];H->r[1]=H->r[i];H->r[i]=t;HeapAdjust(H,1,i-1); /*将R[1..i-1]重新调整为大顶堆*/}}void main(){int i,k,num;SqList s;printf("请输入待排序序列的个数:\n");scanf("%d",&num);printf("请输入序列中的元素:\n");for(i=1;i<=num;i++){scanf("%d",&s.r[i].key);}s.length=i-1;printf("\n\t1,简单插入排序\n\t2,折半插入排序\n\t3,快速排序\n\t4,直接选择排序\n");printf("\t5,堆排序\n\t按1,5选择操作\n");scanf("%d",&k);switch(k){case 1: InsertSort(&s);break;case 2: BInsertSort(&s);break;case 3: QuickSort(&s);break;case 4: SelectSort(&s);break;case 5: HeapSort(&s);break;default: printf("您没有选择一个操作。
AT89C51实验报告
实验一MCS-51指令系统实验一一数据排序一、实验目的熟悉MCS-51指令系统,掌握程序设计方法:加深对内部存储器读写的认识;熟悉仿真开发环境,学会源程序的编写、汇编/编译、调试:熟悉单片机硬件实验系统以及良好的实验习惯培养等;学会检查结果的正确性。
二、实验内容将程序存储器的一个列表中的10个单字节无符号数据传送到内部RAM,然后用冒泡法对其按从小到大的次序重新排列,并送到外部RAM以8000H开始的地址单元内。
三、实验说明有序的数列更有利于查找。
本程序用的是“冒泡排序”法,算法是将一个数与后面的数相比较,如果比后面的数大,则交换,如此将所有的数比较一遍后,最大的数就会在数列的最后面。
再进行下一轮比较,找出第二大数据,直到全部数据有序。
四、程序流程图五、调试程序:第一步:将程序存储器的一个列表中的10个单字节无符号数据传送到内部RAM40H〜49H单元中。
ORG OOOOHLJMP S7ART1ORG0030HSTART1: MOV R0,#40H;设置RO为内部RAM首地址MOV R1,#10;设出为计数器MOV DPTR,#TAB1L00P1: CLR A;累加器清零MOVC A,A+DPTR;外部数据送累加器A中MOV RO,A;送内部RAMINC RO;调整内部RAM指针,指向下一个数据INC DPTR;调整外部RAM指针DJNZ R1,L00P1;未完继续:第二步:排序.把片内RAM40H 〜49H 单元中的10个无符号数逐一比较,并按从小到大的顺序依次 排列在这片单元中•:第三步:将内部数据RAM 中40H 〜49H 单元的内容传送到外部数据存储器以8000H 开始的连续单元 中去。
需传送10次数据•将RI 作为循环计数器。
具体程序如下。
START3: MOV R0,#40HMOV DPTR,#8000HMOV R1,#10LOOP: MOV A,ROMOVX DPTR,AINC ROINC DPTRDJNZ R1,L00PSJMP$ TAB1: DB 09H,04H,02H,08H,00H ;数 0・9 表DB 00H,06H,07H,07H,0FH END六、收获与体会第一次用汇编语言在伟福6000环境下运行,感觉和VC6.0稍有不同,伟福6000调试界而非常丰 富,有片内RAM一一DATE :片外RAM ——XDATE :代码寄存器——CODE ;特殊功能寄存器——SFR ; 并且可以单步调试,自己所编的程序一目了然:伟福6000果然是好东西;冒泡法存在的不足及改进方法:START2: CLR F0MOV R3,#9MOV R0,#40HMOV A, ROL2: INC ROMOV R2,ASUBB A,ROMOV A,R2JC L1SETB F0XCH A,RODEC ROXCH A, ROINC ROL1: MOV A, RODJNZ R3,L2 JBF0,START2;清除交换标志位FO ;10个数据循环次数 ;数据存放区首址 ;取前数 ;保存前数 ;前数减后数 ;恢复前数 ;顺序则继续比较 ;逆序则建立标志位 ;前数与后数交换 ;指向前数单元 ;仍指向后数单元 ;取下一个数 ;依次重复比较 ;交换后重新比较:40H 〜49H 共计10个单元,;设置RO 为内部RAM 首地址 ;设置外部RAM 首地址 ;设Rl 为计数器 ;取内部RAM 数 ;送外部RAM ;调整内部RAM 指针,指向下一个数据 ;调整外部RAM 指针 ;未完继续;暂停第一,在排序过程中,执行完最后的排序后,虽然数据已全部排序完备,但程序无法判断是否完成排序,为了解决这一不足,可设置一个标志单元flag,将其设置为OFF,表示被排序的表示是一个无序的表。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
实验1:顺序表的基本操作实验2:单链表的基本操作实验3:查找实验4:排序实验1代码及结果:#include <iostream>using namespace std;template <class T>class sq_LList{private:int mm;int nn;T *v;public:sq_LList(){mm=0;nn=0;return;}sq_LList(int);void prt_sq_LList();int flag_sq_LList();void ins_sq_LList(int,T);void del_sq_LList(int);};//建立空顺序表template <class T>sq_LList<T>::sq_LList(int m){mm=m;v=new T[mm];nn=0;return;}//顺序输出顺序表中的元素与顺序表长度template <class T>void sq_LList<T>::prt_sq_LList(){int i;cout<<"nn="<<nn<<endl;for(i=0;i<nn;i++)cout<<v[i]<<endl; return;}//检测顺序表的状态template <class T>int sq_LList<T>::flag_sq_LList(){if(nn=mn)return(-1);if(nn=0)return(0);return (1);}//在表的指定元素前插入新元素template<class T>void sq_LList<T>::ins_sq_LList(int i,T b){int k;if(nn==mm){cout<<"overflow"<<endl;return;}if(i>nn)i=nn+1;if(i<1)i=1;for(k=nn;k>=i;k--)v[k]=v[k-1];v[i-1]=b;nn=nn+1;return ;}//在顺序表中删除指定元素template<class T>void sq_LList<T>::del_sq_LList(int i){int k;if(nn==0){cout<<"underflow!"<<endl;return;}for(k=i;k<nn;k++)v[k-1]=v[k];nn=nn-1;return ;}int main(){sq_LList<double>s1(100);cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();s1.ins_sq_LList(0,1.5);s1.ins_sq_LList(1,2.5);s1.ins_sq_LList(4,3.5);cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();s1.del_sq_LList(0);s1.del_sq_LList(2);cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();return 0;}运行及结果:实验2代码#include<iostream>#include<iomanip>using namespace std;struct node{float data;node *next;};node *create(){ //建立单链表node *head,*p,*s;head=new node;p=head;p->data=0;p->next=0; //表头创建完成float newnum=0;cin>>newnum;if(newnum<0){cout<<"未输入数据...\n";//输入负数则结束system("pause");}while(newnum>=0 ){ //??如何用字符型作为结束标志s=new node; //创建表中数据s->data=newnum;p->next=s;p=s;cin>>newnum;}p->next=NULL; //最后元素指针return(head); //返回空表头}//插入一个结点x,将成为第i个节点void insertnode(node *head,int i,float x){node *s,*p;int j;s=new node;s->data=x;p=head;j=1; //查找第i个结点,由p指向while(p!=NULL && j<i){j++;p=p->next;}s->next=p->next;p->next=s;}//删除结点xvoid deletenode(node *head,float x){node *p,*s;if(head->next==NULL)cout<<"这是空链表,不能执行删除操作\n"; else{s=head;p=head->next;while(p!=NULL && p->data!=x)if(p->data!=x){s=p;p=p->next;}if(p!=NULL){s->next=p->next;delete(p);}else cout<<"未找到!\n";}}//存取链表某节点Kvoid read(node*head,int k){while(head->next!=0&&k>0){head=head->next;k--;}cout<<"该处数据为"<<head->data<<".\n\n"; }int main( ) {node *linktable=0;int choice=1;cout<<"1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"请输入您的选择:";cin>>choice;while(1){switch (choice){case 0: exit(0);case 1:{cout<<"输入正数数据,并以负数作为结束标记\n";linktable=create();break;}case 2:{cout<<"链表长度为"<<length(linktable)<<",详细信息:\n";printlist(linktable);break;}case 3:{cout<<"要删除的数据为?\n";float del;cin>>del;deletenode(linktable,del);break;}case 4:{if(linktable->next==0)cout<<"链表为空,不能查找\n";else{cout<<"要查找数据为?";float search;cin>>search;find(linktable,search);} break;}case 5:{cout<<"存储数据为?";int des;float it;cin>>it;cout<<"想让该数据存储为第几个节点?";cin>>des;if((des>(length(linktable)+1)||des<1))cout<<"输入错误\n";elseinsertnode(linktable,des,it);break;}case 6:{cout<<"想读取第几个节点?";int c;cin>>c;if(c<1||c>length(linktable))cout<<"位置不合法\n";elseread(linktable,c);break;}default :cout<<"输入错误!\n";}system("pause");system("cls");cout<<"当前信息:\n";printlist(linktable);cout<<"\n1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"继续选择:\n";cin>>choice;}return 0;}实验三查找实验名称:实验3 查找实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序树和哈希表的构造和查找方法。
c语言实验报告心得总结(精选14篇)
c语言实验报告心得总结(精选14篇)(经典版)编制人:__________________审核人:__________________审批人:__________________编制单位:__________________编制时间:____年____月____日序言下载提示:该文档是本店铺精心编制而成的,希望大家下载后,能够帮助大家解决实际问题。
文档下载后可定制修改,请根据实际需要进行调整和使用,谢谢!并且,本店铺为大家提供各种类型的经典范文,如工作报告、合同协议、心得体会、演讲致辞、规章制度、岗位职责、操作规程、计划书、祝福语、其他范文等等,想了解不同范文格式和写法,敬请关注!Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!Moreover, our store provides various types of classic sample texts, such as work reports, contract agreements, insights, speeches, rules and regulations, job responsibilities, operating procedures, plans, blessings, and other sample texts. If you want to learn about different sample formats and writing methods, please pay attention!c语言实验报告心得总结(精选14篇)【第1篇】c语言实验报告心得总结900字在初学c语言的一个学期后,我们进行了c语言实训阶段,尝试编写一个比较复杂的程序系统。
内部排序实验报告总结
内部排序实验报告总结引言内部排序是指对内存中的数据进行排序的过程。
在计算机科学中,排序是一项基础且重要的任务。
通过对大量数据进行排序,可以提高数据的查找和处理效率。
本次实验旨在比较和分析不同的内部排序算法的性能和效果。
实验目的•熟悉常见的内部排序算法•掌握内部排序算法的实现方法•比较和分析不同内部排序算法的性能和效果实验过程数据准备首先,我们需要准备一组待排序的数据。
在本次实验中,我们选择了随机生成的10000个整数作为待排序的数据。
冒泡排序冒泡排序是一种简单但效率较低的排序算法。
它的基本思想是通过不断交换相邻的元素,将最大的元素逐渐“冒泡”到数组的末尾。
冒泡排序的实现代码如下:def bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]插入排序插入排序是一种简单且高效的排序算法。
它的基本思想是将待排序的元素逐个插入到已排序的部分中,直到所有元素都插入完毕。
插入排序的实现代码如下:def insertion_sort(arr):n = len(arr)for i in range(1, n):key = arr[i]j = i - 1while j >= 0 and arr[j] > key:arr[j+1] = arr[j]j -= 1arr[j+1] = key快速排序快速排序是一种高效的排序算法。
它的基本思想是通过选择一个基准元素,将数组分割成两个子数组,其中一个子数组的所有元素都小于基准元素,另一个子数组的所有元素都大于基准元素。
然后对这两个子数组分别进行快速排序。
快速排序的实现代码如下:def quick_sort(arr, low, high):if low < high:pi = partition(arr, low, high)quick_sort(arr, low, pi-1)quick_sort(arr, pi+1, high)def partition(arr, low, high):i = low - 1pivot = arr[high]for j in range(low, high):if arr[j] < pivot:i += 1arr[i], arr[j] = arr[j], arr[i]arr[i+1], arr[high] = arr[high], arr[i+1]return i+1归并排序归并排序是一种稳定的排序算法。
数据结构程序设计题目共29题
目录题目1:设计一元多项式简单计算 (1)题目2:链表应用1 (1)题目3:链表应用2 (1)题目4:通讯录 (2)题目5:停车场管理系统................................................ 错误!未定义书签。
题目6:约瑟夫环 (3)题目7:运动会分数统计 (3)题目8:文学研究助手问题 (3)题目9:银行业务模拟与离散事件模拟 (4)题目10:学生信息管理系统任务(用顺序表/链表)....... 错误!未定义书签。
题目11:文章编辑功能 ................................................. 错误!未定义书签。
题目12:实验室管理..................................................... 错误!未定义书签。
题目13:二叉树的基本操作(建立、求二叉树树深度、遍历).. (4)题目14:纸牌游戏任务 (5)题目15:算术表达式求值 (5)题目16:内部排序算法比较 (5)题目17:哈夫曼树的构造和哈夫曼编码/译码 (6)题目18:构造可以使n个城市连接的最小生成树 (7)题目19:交通咨询系统中的最短路径 (7)题目20:集合的交、并、差运算 ................................... 错误!未定义书签。
题目21:长整数四则运算 (7)题目22:机订票系统..................................................... 错误!未定义书签。
题目23:图书管理系统 (8)题目24:哈希表应用 (8)题目25:模拟旅馆管理系统的一个功能——床位的分配与回收 (9)题目26:地图着色问题 (9)题目27:俄罗斯套娃问题 (10)题目28:扫雷 (11)题目29:用C语言设计一个日历系统 (11)题目1:设计一元多项式计算【任务要求】(1)能够按照指数降序排列建立并输出多项式;(2)能够完成两个多项式的相加、相减,并将结果输入;实现提示:可选择带头结点的单向循环链表或单链表存储多项式,头结点可存放多项式的参数,如项数等。
内部排序比较(实验报告源程序)c
实验报告3实验名称:数据结构与软件设计实习题目:内部排序算法比较专业:生物信息学班级:01 姓名:学号:实验日期:2010.07.24一、实验目的:比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序;二、实验要求:待排序长度不小于100,数据可有随机函数产生,用五组不同输入数据做比较,比较的指标为关键字参加比较的次数和关键字移动的次数;对结果做简单的分析,包括各组数据得出结果的解释;设计程序用顺序存储。
三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受,包括关键字比较次数和关键字移动次数。
将排序算法进行合编在一起,可考虑用顺序执行各种排序算法来执行,最后输出所有结果。
四、实验编程结果或过程:1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下,代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果,运行结果无误,如下图语速个数为20元素个数为100错误调试无。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告3实验名称:数据结构与软件设计实习题目:内部排序算法比较专业:生物信息学班级:01 姓名:学号:实验日期:2010.07.24一、实验目的:比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序;二、实验要求:待排序长度不小于100,数据可有随机函数产生,用五组不同输入数据做比较,比较的指标为关键字参加比较的次数和关键字移动的次数;对结果做简单的分析,包括各组数据得出结果的解释;设计程序用顺序存储。
三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受,包括关键字比较次数和关键字移动次数。
将排序算法进行合编在一起,可考虑用顺序执行各种排序算法来执行,最后输出所有结果。
四、实验编程结果或过程:1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下,代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果,运行结果无误,如下图语速个数为20元素个数为100错误调试无。
调试分析:时间复杂度与空间复杂度:理论分析可以得出各种排序算法的时间复杂度和空间复杂度,如下表所示(图6):排序方法平均情况最好情况最坏情况辅助空间直接插入排序O(n2)O(n)O(n2)O(1)起泡排序O(n2)O (n) O(n2)O(1)快速排序O(n log2n)O(n log2n)O(n2)O(log2n) ~O(n)简单选择排序O(n2)O(n2)O(n2)O(1)希尔排序O(n1..3)O(1)◆待排序的记录数目n 的大小。
◆记录本身数据量的大小,也就是记录中除关键字外的其他信息量的大小。
◆关键字的结构及其分布情况。
◆对排序稳定性的要求从结果中还可看出:对于一般的排序,比较次数多,而交换次数相对较少;而快速排序比较次数和交换次数都较少,两者相差不如前者大。
其中冒泡排序比较和交换次数都很大。
五、实验总结:(1)实验中的存在问题和提高存在问题:程序有待增强。
提高:界面处理简洁。
(2)收获与体会随机数的生成附录源程序#include <iostream.h>#include <malloc.h>#include <stdlib.h>#include <time.h>#define LS(a,b) ((a)<(b))#define LL(a,b) ((a)>(b))#define MAXSIZE 10000typedef int KeyType;typedef struct {KeyType key;}RedType;typedef struct {RedType r[MAXSIZE+1];int length;}SqList;int compare=0;int change=0;int Create_Sq(SqList &L){int k;cout<<"元素个数:";cin>>k;L.length=k;srand(time(NULL));for (int x=1; x<=k; x++){L.r[x].key= rand() % k;//随机域为0~k }return 1;}void Bubble_sort(SqList &L)//冒泡排序for(i=1;i<=L.length-1;++i){for(j=1;j<=k-1;++j){++m;if(LL(L.r[j].key,L.r[j+1].key)){l=L.r[j].key;L.r[j].key=L.r[j+1].key;L.r[j+1].key=l;++n;}}--k;}cout<<endl<<"-----冒泡排序后的序列-----"<<endl; for(i=1;i<=L.length;i++)cout<<" "<<L.r[i].key;cout<<endl;cout<<"冒泡排序的比较次数:";cout<<m<<endl;cout<<"冒泡排序的交换次数:";cout<<n<<endl;}void InsertSort(SqList &L)//插入排序{int i,j,m=0,n=0;cout<<endl;for(i=2;i<=L.length;++i)if(LS(L.r[i].key,L.r[i-1].key)){++m;++n;L.r[0]=L.r[i];L.r[i]=L.r[i-1];for(j=i-2;LS(L.r[0].key,L.r[j].key);--j){++m;L.r[j+1]=L.r[j];}L.r[j+1]=L.r[0];}cout<<"-----直接插入排序后的序列-----"<<endl; for(i=1;i<=L.length;i++)cout<<"直接插入排序的比较次数:";cout<<m<<endl;cout<<"直接插入排序的交换次数:";cout<<n<<endl;}void SelectSort(SqList &L) //简单选择排序{int l,i,j,m=0,n=0;cout<<endl;for(i=1;i<L.length;++i){L.r[0]=L.r[i];j=i+1;l=i;for(j;j<=L.length;++j){++m;if(LL(L.r[0].key,L.r[j].key)){l=j;L.r[0]=L.r[j];}}if(l!=i){++n;L.r[l]=L.r[i];L.r[i]=L.r[0];}}cout<<"-----简单选择排序后的序列-----"<<endl; for(i=1;i<=L.length;i++)cout<<" "<<L.r[i].key;cout<<endl;cout<<"简单选择排序的比较次数:";cout<<m<<endl;cout<<"简单选择排序的交换次数:";cout<<n<<endl;}int Partition(SqList &L,int low,int high){int pivotkey;L.r[0]=L.r[low];pivotkey=L.r[low].key;while(low<high){while(low<high&&L.r[high].key>=pivotkey){ ++compare;--high;}while(low<high&&L.r[low].key<=pivotkey){++compare;++low;}++change;L.r[high]=L.r[low];}L.r[low]=L.r[0];return low;}void QSort(SqList &L,int low,int high)//递归形式的快速排序算法{int pivotloc;if(low<high){pivotloc=Partition(L,low,high);QSort(L,low,pivotloc-1);QSort(L,pivotloc+1,high);}}void QuickSort(SqList &L){int i;QSort(L,1,L.length);cout<<"-----快速排序后的序列为-----"<<endl;for(i=1;i<=L.length;i++)cout<<" "<<L.r[i].key;cout<<endl;cout<<"快速排序的比较次数:";cout<<compare<<endl;cout<<"快速排序的交换次数:";cout<<change<<endl;compare=0;change=0;}void ShellInsert(SqList &L,int dk)//希尔排序{int i;int j;for(i=dk+1;i<=L.length;++i)if(LS(L.r[i].key,L.r[i-dk].key)){++compare;L.r[0]=L.r[i];for(j=i-dk;j>0&&LS(L.r[0].key,L.r[j].key);j-=dk){++compare;}L.r[j+dk]=L.r[0];}}void ShellSort(SqList &L,int dlta[])//希尔排序{int k,j=L.length/2,t=0;while(j>=0){++t;j-=2;}j=L.length/2;for(k=0;k<t;++k)//计算每次的增量值{if(j==0)j=1;//定义最后一趟排序的增量dlta[k]=j;j-=2;}for(k=0;k<t;++k)ShellInsert(L,dlta[k]);cout<<"-----希尔排序后的序列为-----"<<endl; for(k=1;k<=L.length;k++)cout<<" "<<L.r[k].key;cout<<endl;cout<<"希尔排序的比较次数:";cout<<compare<<endl;cout<<"希尔排序的交换次数:";cout<<change<<endl;compare=0;change=0;}void main(){int i;int dlta[MAXSIZE];SqList L,a,b,c,d;Create_Sq(L);a=b=c=d=L;Bubble_sort(L); InsertSort(a); SelectSort(b); QuickSort(c); ShellSort(d,dlta); }。