数据结构(C语言版)实验报告-(内部排序算法比较)
数据结构课程设计实践报告
数据结构实验报告本文是范文，仅供参考写作，禁止抄袭本文内容上传提交，违者取消写作资格，成绩不合格！实验名称：排序算法比较提交文档学生姓名：提交文档学生学号：同组成员名单：指导教师姓名：排序算法比较一、实验目的和要求1、设计目的1．掌握各种排序的基本思想。
2．掌握各种排序方法的算法实现。
3．掌握各种排序方法的优劣分析及花费的时间的计算。
4．掌握各种排序方法所适应的不同场合。
2、设计内容和要求利用随机函数产生30000个随机整数，利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序，并统计每一种排序上机所花费的时间二、运行环境（软、硬件环境）软件环境：Vc6.0编程软件运行平台： Win32硬件：普通个人pc机三、算法设计的思想1、冒泡排序：bubbleSort()基本思想: 设待排序的文件为r[1..n]第1趟(遍)：从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key，则交换记录r[i]和r[i+1]的位置；否则,不交换。
(i=1,2,...n-1)第1趟之后,n个关键字中最大的记录移到了r[n]的位置上。
第2趟：从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key，则交换记录r[i]和r[i+1]的位置；否则,不交换。
(i=1,2,...n-2)第2趟之后,前n-1个关键字中最大的记录移到了r[n-1]的位置上，作完n-1趟,或者不需再交换记录时为止。
2、选择排序：selSort()每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
选择排序不像冒泡排序算法那样先并不急于调换位置，第一轮（k=1）先从array[k]开始逐个检查，看哪个数最小就记下该数所在的位置于minlIndex中，等一轮扫描完毕，如果找到比array[k-1]更小的元素，则把array[minlIndex]和a[k-1]对调，这时array[k]到最后一个元素中最小的元素就换到了array[k-1]的位置。
数据结构课程设计(内部排序算法比较-C语言)
`课题：内部排序算法比较…第一章问题描述排序是数据结构中重要的一个部分，也是在实际开发中易遇到的问题，所以研究各种排算法的时间消耗对于在实际应用当中很有必要通过分析实际结合算法的特性进行选择和使用哪种算法可以使实际问题得到更好更充分的解决！该系统通过对各种内部排序算法如直接插入排序，冒泡排序，简单选择排序，快速排序，希尔排序，堆排序、二路归并排序等，以关键码的比较次数和移动次数分析其特点，并进行比较，估算每种算法的时间消耗，从而比较各种算法的优劣和使用情况！排序表的数据是多种不同的情况，如随机产生数据、极端的数据如已是正序或逆序数据。
比较的结果用一个直方图表示。
第二章系统分析界面的设计如图所示：!|******************************||-------欢迎使用---------||-----（1）随机取数-------||-----（2）自行输入-------||-----（0）退出使用-------||******************************|~请选择操作方式：如上图所示该系统的功能有：（1）：选择 1 时系统由客户输入要进行测试的元素个数由电脑随机选取数字进行各种排序结果得到准确的比较和移动次数并打印出结果。
（2）选择 2 时系统由客户自己输入要进行测试的元素进行各种排序结果得到准确的比较和移动次数并打印出结果。
（3）选择0 打印“谢谢使用！！”退出系统的使用！！、第三章系统设计（I）友好的人机界面设计：（如图所示）|******************************||-------欢迎使用---------||-----（1）随机取数-------||-----（2）自行输入-------||-----（0）退出使用-------||******************************|：（）（II）方便快捷的操作：用户只需要根据不同的需要在界面上输入系统提醒的操作形式直接进行相应的操作方式即可！如图（所示）|******************************||-------欢迎使用---------||-----（1）随机取数-------||-----（2）自行输入-------||-----（0）退出使用-------||******************************|；请选择操作方式：（用户在此输入操作方式）（）（III）系统采用定义结构体数组来存储数据。
数据结构内部算法排序实验程序与结果分析
内部算法排序实验比较算法的原理及程序实现：#define CPP C++#define MPP M++#define MP2 M+=2#define MP3 M+=3#include <fstream.h>#include <iomanip.h>#include <stdlib.h>#include <time.h>#include <math.h>const int maxsize=100000; //排序表容量typedef int datatype;typedef struct {datatype key; //关键字域//othertype other; //其它域} rectype; //记录类型typedef rectype list[maxsize+2]; //排序表类型，0号单元不用__int64 C,M; //比较和移动次数void check(list R,int n) { //检验排序结果int i;for(i=2;i<=n;i++)if(R[i].key<R[i-1].key) {cout<<"Error!\n";return;}cout<<"Correct! ";}void disp(list R,int n) { //显示排序后的结果int i;for(i=1;i<=n;i++) {cout<<setw(4)<<R[i].key;// if(i%20==0) cout<<endl;}cout<<endl;}//直接插入部分/*无序区第一记录R[i] 插入有序区R[1]~R[i-1]，找插入位置和移动记录交替进行：从有序区的后部j开始，如果该位置记录大于待插记录，则后移一位；待插记录插入到最后空出的位置上*/void InsertSort1(list R,int n) {//直接插入排序，带监视哨(并不改变关键字次数)int i,j;for(i=2;i<=n;i++) { //依次插入R[2],R[3],…,R[n]if(CPP,R[i].key>=R[i-1].key) continue;//R[i]大于有序区最后一个记录，则本趟不需插入MPP,R[0]=R[i]; //R[0]是监视哨j=i-1;do { //查找R[i]的插入位置MPP,R[j+1]=R[j];j--; //记录后移，继续向前搜索} while(CPP,R[0].key<R[j].key);MPP,R[j+1]=R[0]; //插入R[i]}}void InsertSort2(list R,int n) {//直接插入排序，无监视哨int i,j;rectype x; //x为辅助量(用R[0]代替时间变长)for(i=2;i<=n;i++) { //进行n-1次插入if(CPP,R[i].key>=R[i-1].key) continue;MPP,x=R[i]; //待排记录暂存到xj=i-1;do { //顺序比较和移动MPP,R[j+1]=R[j];j--;} while(j>=1 && (CPP,x.key<R[j].key));MPP,R[j+1]=x; //插入R[i]}}//折半插入排序void BInsertSort(rectype *R,long n){long i,j,low,m,high;for(i=2;i<=n;i++){R[0].key=R[i].key; //R[i].key暂存到R[0].keylow=1;high=i-1;while(low<=high) { //在R[low....heigh]中折半查找有序插入位置m=(low+high)/2; //折半*/if(CPP,R[0].key<R[m].key) high=m-1; //插入点在低半区else low=m+1; //插入点在高半区}for(j=i-1;j>=high+1;j--) //记录后移CPP,R[j+1].key=R[j].key;R[high+1].key=R[0].key; //插入}}//希尔排序部分/* 希尔排序又称缩小增量排序，是1959年由D.L.Shell提出来的,其中运用的直接插入排序算法简单，在n值较小时，效率比较高，在n值很大时，若序列按关键码基本有序，效率依然较高。
数据结构(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.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中，我曾多次修改代码，并根据调试显示的界面一次次调整代码。
数据结构试验报告——各种内排序算法的实现及性能比较
实验报告（2010 / 2011 学年第 2 学期）课程名称数据结构——使用C++语言描述实验名称各种内排序算法的实现及性能比较实验时间2011年5月27日指导单位计算机科学与技术系指导教师学生姓名班级学号学院(系)专业一．实验目的和要求内容：验证教材的各种内排序算法。
分析各种排序算法的时间复杂度。
要求：使用随机数产生器产生大数据集合，运行上述各种排序算法，使用系统时钟测量各算法所需的实际时间，并进行比较。
二．实验环境（实验设备）Visual C++三．实验原理及内容单选择排序"<<endl;接插入排序"<<endl;泡排序"<<endl;速排序"<<endl;路合并排序"<<endl;排序"<<endl;出"<<endl;cout<<"PS：测试用的数组元素为"<<SIZE<<"时间为重复运行"<<TIMES<<"次的时间（包括了产生数据与析构的时间）"<<endl;this->switcha();}template <class T>void Menu<T>::childmenu(){cout<<"--------------------------------------------------------"<<endl;cout<<"1.最好情况"<<endl;cout<<"2.最坏情况"<<endl;cout<<"3.平均情况"<<endl;cout<<"4.返回主菜单"<<endl;cin>>b;if(b==4)this->printmenu();}template<class T>void Menu<T>::childmenu2(){cout<<"--------------------------------------------------------"<<endl;cout<<"1.原始算法"<<endl;cout<<"2.改进算法"<<endl;cout<<"3.返回主菜单"<<endl;cin>>c;if(c==3)this->printmenu();}template <class T>void Menu<T>::switcha(){<<endl;return 0;}/*ok--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok1简单选择排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok2直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单1ok用时：0请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单2ok用时：请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单3ok用时：请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单4--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok3冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单1ok用时：请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单2ok用时：请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单3ok用时：请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单4--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok4--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单1原始快速排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单2改进的快速排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单3--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok5合并排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok6堆排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok7Press any key to continue*/四．实验小结（包括问题解和解决方法、心得体会、意见与建议等）通过本次实验对教材上的各种内排序算法进行了逐一验证。
数据结构内排序实验报告
一、实验目的1、了解内排序都是在内存中进行的。
2、为了提高数据的查找速度，需要对数据进行排序。
3、掌握内排序的方法。
二、实验内容1、设计一个程序e xp10—1.cpp实现直接插入排序算法，并输出{9,8,7,6,5,4,3,2,1,0}的排序过程。
（1）源程序如下所示：//文件名:exp10-1.cpp#include <stdio.h>#define MAXE 20//线性表中最多元素个数typedef int KeyType;typedef char InfoType[10];typedef struct //记录类型{KeyType key; //关键字项InfoType data; //其他数据项,类型为InfoType} RecType;void InsertSort(RecType R[],int n) //对R[0..n-1]按递增有序进行直接插入排序{int i,j,k;RecType temp;for (i=1;i<n;i++){temp=R[i];j=i-1; //从右向左在有序区R[0..i-1]中找R[i]的插入位置while (j>=0 && temp.key<R[j].key){R[j+1]=R[j];//将关键字大于R[i].key的记录后移j--;}R[j+1]=temp;//在j+1处插入R[i]printf("i=%d,",i);//输出每一趟的排序结果printf("插入%d,结果为: ",temp);for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");}}void main(){int i,k,n=10;KeyType a[]={9,8,7,6,5,4,3,2,1,0};RecType R[MAXE];for (i=0;i<n;i++)R[i].key=a[i];printf("初始关键字: ");//输出初始关键字序列for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");InsertSort(R,n);printf("最后结果: ");//输出初始关键字序列for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");}（2）运行的结果如下图所示：2、设计一个程序exp10—2.cpp实现希尔插入排序算法，并输出{9,8,7,6,5,4,3,2,1,0}的排序过程。
c语言排序实验报告
c语言排序实验报告C语言排序实验报告引言：排序是计算机科学中非常重要的一项基础操作，它在各个领域都有广泛的应用。
本实验旨在通过使用C语言实现不同的排序算法，对比它们的性能和效率，并对排序算法的实现原理进行深入探讨。
一、实验背景排序算法是将一组无序的数据按照特定的规则进行重新排列的过程。
在计算机科学中，常用的排序算法包括冒泡排序、选择排序、插入排序、快速排序等。
这些算法的不同之处在于其时间复杂度、空间复杂度以及稳定性等方面的差异。
二、实验目的1. 理解不同排序算法的基本原理和实现方法；2. 掌握C语言的基本语法和数组操作；3. 比较不同排序算法的性能和效率。
三、实验过程1. 冒泡排序冒泡排序是一种简单的排序算法，它通过比较相邻元素的大小并交换位置来实现排序。
具体实现过程如下：```void bubbleSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-i-1; j++) {int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```2. 选择排序选择排序是一种简单直观的排序算法，它每次从待排序的数据中选择最小（或最大）的元素放到已排序序列的末尾。
具体实现过程如下：```void selectionSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {int minIndex = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}int temp = arr[i];arr[minIndex] = temp;}}```3. 插入排序插入排序是一种简单直观的排序算法，它将待排序的数据插入到已排序序列的合适位置。
C语言内排序法实验报告
数据结构一：排序方法比较1、冒泡排序属于稳定排序，是一种借助“交换”进行排序的方法。
首先要将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则将两个记录交换之，然后比较第二个记录与第三个记录的关键字，以此类推，直至第n-1个记录与第n个记录的关键字进行比较为止，这一过程称为第一趟冒泡排序，其结果使得关键字最大的记录被安置在最后一个记录的位置上；然后进行第二趟冒泡排序，对前N-1个记录进行同样操作；以此类推，直到在一趟排序过程中没有进行过交换记录的操作为止。
2、直接插入排序属于稳定的排序，每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。
第一趟将待比较的数值与它的前一个数值进行比较，当前一数值比待比较数值大的情况下继续循环比较，依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程，结束该次循环。
3、快速排序属于不稳定排序，是对起泡排序的一种改进。
它的基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
假设待排序的序列为{R.[s],R.[s+1],…….,R.[t]},首先任意选取一个记录，然后按下述原则从新排序记录：将关键字较他小的记录都安置在他的位置之前，将所有关键字较他大的记录都安置在他的位置后面。
由此可以该“枢轴”记录最后所落的位置i作为分界线，将序列{R[s],R[s+1]…….R[t]}分割成两个子序列｛R[s],R[s+1]…..R[i-1]｝和｛R[i+1]……R[t]｝，这个过程称作一趟快速排序。
一趟快速排序的具体做法是：附设两个指针low和high，它们的初值分别指向数组第一个数据和最后一个数据，将枢轴记录暂存在R[0]的位置上排序过程中只作R[low]或R[high]的单向移动，直至一趟排序结束后再将枢轴记录移至正确位置上。
4、简单选择排序属于不稳定排序，基本思想是，每一趟在n-i+1（i=1，2，…n-1）个记录中选取关键字最小的记录作为有序序列中第i个记录。
数据结构排序算法实验报告
移动次数 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，再进行初始建堆，直至完全排好序。
排序算法实验报告
排序算法实验报告数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的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）；原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性：排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。
稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。
另外，如果排序算法稳定，可以避免多余的比较；稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
数据结构内排序实验报告
数据结构内排序实验报告数据结构内排序实验报告一、实验目的本实验旨在熟悉数据结构内排序算法的实现过程，比较各种内排序算法的效率和性能，并掌握它们的优缺点。
二、实验内容⒈实验环境搭建在实验开始前，需要搭建适当的实验环境，包括编程语言、集成开发环境（IDE）等。
⒉内排序算法实现选择合适的内排序算法，如冒泡排序、插入排序、选择排序、快速排序等，对给定的待排序数据进行实现。
⒊程序测试编写测试程序，随机生成一定量的数据，对每个内排序算法进行测试，并记录运行时间和比较次数。
⒋数据比较与分析将各个内排序算法的运行时间和比较次数进行比较，分析它们的优劣势。
⒌实验结论结合实验结果，给出对内排序算法的选择建议，并对实验过程中的问题进行总结。
三、实验步骤与介绍⒈实验环境搭建在本次实验中，我们选择使用C++编程语言，并搭建Visual Studio作为集成开发环境。
该环境提供了丰富的调试和测试工具，适合本次实验的需求。
⒉内排序算法实现我们选择了三种常见的内排序算法进行实现，包括冒泡排序、插入排序和快速排序。
a) 冒泡排序冒泡排序是一种交换排序算法，通过不断比较相邻元素并交换位置来实现排序。
具体实现步骤如下：- 从待排序数组的第一个元素开始，不断比较相邻两元素的大小。
- 如果前一个元素大于后一个元素，则交换它们的位置。
- 继续比较下一对元素，直到最后一个元素。
- 重复以上步骤，直到排序完成。
b) 插入排序插入排序是一种直接插入排序算法，通过不断将待排序元素插入已排序部分的合适位置来实现排序。
具体实现步骤如下：- 从待排序数组的第二个元素开始，依次将元素与前面已排好序的元素进行比较。
- 如果前一个元素大于待排序元素，则将前一个元素后移一位。
- 继续比较前一个元素，直到找到合适的位置插入待排序元素。
- 重复以上步骤，直到排序完成。
c) 快速排序快速排序是一种分治排序算法，通过不断地将数组分成两部分并对子数组递归进行排序来实现整体排序。
数据结构实验报告：内部排序算法比较
# define OVERFLOW -2
typedef struct
{ int * elem;
int length;
}SqList;
SqList create(int n)//建立一个顺序表
{ SqList L;
L.elem = (int *)malloc( n*sizeof(int));
T=QuickSort(T);
printf("排序后数据如下：\n");
for(int k=2;k<=n;k++)
printf("%6d",T.elem[k]);
printf("\n");
do
{ printf("如果想继续验证请输入Y或y,否则输入N或n：\n\n");
scanf("%s",&yes_no);
实验报告
课程名称：数据结构实验名称：内部排序算法比较任课教师：
专业:计网类班 级:2007级1班学号：
姓名：___________完成日期：2008年12月30日
一、实验目的：
掌握主要排序算法的基本思想，包括插入排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序及基数排序；掌握以上排序算法的实现方法；对各种算法的效率进行比较。
printf("%6d",L.elem[k]);
printf("\n");
}
} // InsertSort
void main()
{ SqList T;
int n=0,k,flag=0;
char yes_no;
数据结构课程设计实验报告-内部排序算法比较
内部排序算法比较【实验简介】1、在教科书各种内部排序算法的时间复杂度分析结果只给出了算法执行的时间的阶，或大概的执行时间，如：直接插入排序即时间复杂度为O（n*n）2、通过五组随机数据、一组正序数据与一组逆序数据比较6种常用的内部算法（起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序）的关键字比较次数和关键字移动次数，以取得直观感受；3、用五组不同的长度不小于100的数据进行测试，并对测试结果作出简单的分析，对得出结果拨动大小的进行解释；【设计模块】【对应模块算法说明】(1) 此算法程序中需要用到顺序表数据类型,数据元素的类型定义如下:typedef struct{KeyType key; //关键字项}RedType;typedef struct{RedType r[MAXSIZE+1]; //0号单元闲置或用作哨兵单元int length; //顺序表长度int info; //记录关键字移动次数int cmp; //关键字的比较次数}Sqlist;(2) 本实验用到六种排序算法，一个主函数和菜单函数,其中排序算法分别为起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序；相应时间复杂度分析如下：起泡排序：若待排序列为“正序”，则需进行一趟排序在排序过程中关键字需进行n-1次比较，无须移动纪录；若是“逆序”，则进行n-1趟排序，需n(n-1)/2次比较，并坐等数量级的移动，因此总的事件复杂度为O（n2）;直接插入排序待排序纪录是随机的，关键字间的移动次数和比较次数的平均值约为n*n/4,即时间复杂度为O（n2）;简单的选择排序虽然在排序过程中所需要的移动次数较少，最小时为0，最大时为3（n-1）；但是关键字的比较次数总是相同的，均为n(n-1)/2，因此，时间复杂度亦为O（n2）;快速排序其平均时间是kn*㏑n,其中n为待排序列中纪录的个数，k为某个常数，其时间复杂度为O（n*㏑n）；希尔排序当增序序列为dlta[k]=2t-k+1-1时，时间复杂度为O（n3/2）,其中t为排序趟数，1≤k≤t≤㏒2(n+1);堆排序此排序对于含n个元素的序列排序时，总共进行的关键字比较次数不超过4n，且在最坏的情况下，其时间复杂度为O（n*㏑n）；算法分析如下：①冒泡排序该算法的的思路是首先将第1个记录的关键字负值给L.r[0]，然后用L.r[0]与第（i+1）个记录的关键字比较,若为逆序,则交换第i与第i+1两记录的位置,然后让i加1，重复以上操作，直至i=n-1为止;依次进行第二趟、第三趟……作同样的操作，直至所有的记录按正序排列（一般需要n-1趟比较，第i趟从L.r[1]到L.r[n-i+1]依次比较，1≦ i ≦n-i，比较结果是让其中最大的记录放在L.r[n-i+1]的位置）void BubbleSort(Sqlist *L) //冒泡排序{for(i=0;i<L->length;i++){L->r[0]=L->r[1];for(j=1;j<N-i;j++)if(L->r[0].key>=L->r[j+1].key)L->r[j] L->r[j+1]; //交换两记录的位置elseL->r[0]=L->r[j+1]; //保证L->r[0]始终为较大的记录L->r[j+1]=L->r[0]; //把最大的记录放到祠堂排序的最高位置}printf(L->r[MAXSIZE]);//输出排序后数组和相关数据}②直接插入排序本算法的思路是，把L->r[0]设置为哨兵，排序时把第i个记录复制给哨兵，并于其前的i-1个记录进行比较，找到第一个比起大的记录，利用循环让记录后移，把其放到第一个比起大的记录前面。
内部排序算法比较实验报告(c语言版)
题目：编制一个演示内部排序算法比较的程序班级：姓名：学号：完成日期：一、需求分析1．本演示程序对以下6种常用的内部排序算法进行实测比较：起泡排序，直接插入排序，简单选择排序，快速排序，希尔排序，堆排序。
2．待排序表的元素的关键字为整数。
比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）。
3．演示程序以以用户和计算机的对话方式执行，在计算机终端上显示提示信息，对随机数组进行排序，并输出比较指标值。
4．最后对结果作出简单分析。
二、概要设计1．可排序表的抽象数据类型定义：ADT OrderableList{数据对象：D={ai|ai∈IntegerSet,i=1,2,…,n,n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D,i=2,…,n}基本操作：InitList(n)操作结果：构造一个长度为n，元素值依次为1，2，…,n的有序表。
RandomizeList(d,isInverseOrder)操作结果：首先根据isInverseOrder为True或False,将表置为逆序或正序，然后将表进行d(0≤d≤8)级随机打乱。
d为0时表不打乱，d越大，打乱程度越高。
RecallList()操作结果：恢复最后一次用RandomizeList随机打乱得到的可排序表。
ListLength()操作结果：返回可排序表的长度。
ListEmpty()操作结果：若可排序表为空表，则返回Ture，否则返回False。
BubbleSort( &c, &s)操作结果：进行起泡排序，返回关键字比较次数c和移动次数s。
InsertSort( &c, &s)操作结果：进行插入排序，返回关键字比较次数c和移动次数s。
SelectSort ( &c, &s)操作结果：进行选择排序，返回关键字比较次数c和移动次数s。
QuickSort(&c, &s)操作结果：进行快速排序，返回关键字比较次数c和移动次数s。
数据结构(C语言版) 实验报告
数据结构(C语言版) 实验报告数据结构(C语言版) 实验报告1：引言1.1 问题描述在本实验中，我们需要设计一个基于C语言的数据结构，用于解决特定问题。
1.2 目的本实验的目的是通过设计和实现数据结构，加深对数据结构和C语言的理解，并应用所学的知识解决实际问题。
1.3 相关工作在这一章节中，我们将介绍与本实验相关的先前工作，并分析其优缺点，为我们的设计提供参考。
2：需求分析2.1 功能需求本节将详细描述所设计的数据结构需要实现的功能。
2.2 性能需求在这一节中，我们将明确数据结构的性能需求，例如时间复杂度和空间复杂度限制。
3：数据结构设计3.1 数据结构定义在这一节中，我们将给出所设计数据结构的定义，并详细说明每个字段的含义和作用。
3.2 数据结构操作在这一节中，我们将详细描述每个数据结构操作的实现。
这些操作包括插入，删除，查找等。
4：算法设计4.1 算法描述在这一节中，我们将给出在实现数据结构过程中使用的算法的详细描述。
我们将分析算法的时间复杂度，并讨论其优缺点。
4.2 算法优化在这一节中，我们将分析并设计优化算法，以提高数据结构的性能。
5：实验结果在这一节中，我们将给出实验结果，并分析实验数据。
我们还将展示实验中所涉及的示例输入和输出。
6：结论在这一节中，我们将总结本实验的设计和实现，并讨论所得实验结果的意义和潜在的改进方向。
7：附录本文档附带以下附件：- 代码实现：包含所设计数据结构的C语言源代码。
- 实验数据文件：包含用于测试数据结构的示例输入和输出文件。
8：法律名词及注释本文档中涉及的法律名词及注释见附件。
内部排序比较(实验报告源程序)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错误调试无。
内部排序算法比较实验报告(c语言版)
题目：编制一个演示内部排序算法比较的程序班级：姓名：学号：完成日期：一、需求分析1．本演示程序对以下6种常用的内部排序算法进行实测比较：起泡排序，直接插入排序，简单选择排序，快速排序，希尔排序，堆排序。
2．待排序表的元素的关键字为整数。
比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）。
3．演示程序以以用户和计算机的对话方式执行，在计算机终端上显示提示信息，对随机数组进行排序，并输出比较指标值。
4．最后对结果作出简单分析。
二、概要设计1．可排序表的抽象数据类型定义：ADT OrderableList{数据对象：D={ai|ai∈IntegerSet,i=1,2,…,n,n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D,i=2,…,n}基本操作：InitList(n)操作结果：构造一个长度为n，元素值依次为1，2，…,n的有序表。
RandomizeList(d,isInverseOrder)操作结果：首先根据isInverseOrder为True或False,将表置为逆序或正序，然后将表进行d(0≤d≤8)级随机打乱。
d为0时表不打乱，d越大，打乱程度越高。
RecallList()操作结果：恢复最后一次用RandomizeList随机打乱得到的可排序表。
ListLength()操作结果：返回可排序表的长度。
ListEmpty()操作结果：若可排序表为空表，则返回Ture，否则返回False。
BubbleSort( &c, &s)操作结果：进行起泡排序，返回关键字比较次数c和移动次数s。
InsertSort( &c, &s)操作结果：进行插入排序，返回关键字比较次数c和移动次数s。
SelectSort ( &c, &s)操作结果：进行选择排序，返回关键字比较次数c和移动次数s。
QuickSort(&c, &s)操作结果：进行快速排序，返回关键字比较次数c和移动次数s。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构与算法》实验报告一、需求分析问题描述：在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。
试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
基本要求：（l ）对以下 6 种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。
（2 ）待排序表的表长不小于100000 ；其中的数据要用伪随机数程序产生；至少要用 5 组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为 3 次移动）。
（ 3 ）最后要对结果作简单分析，包括对各组数据得出结果波动大小的解释。
数据测试：二．概要设计1. 程序所需的抽象数据类型的定义：typedef int BOOL;typedef struct StudentData { }Data; typedef struct LinkList { Data Record[MAXSIZE]; int num; // 存放关键字int Length; // 数组长度// 用数组存放所有的随机数// 说明BOOL 是int 的别名} LinkList int RandArray[MAXSIZE]; // 定义长度为MAXSIZE 的随机数组void RandomNum() // 随机生成函数void InitLinkList(LinkList* L) // 初始化链表// 比较所有排序2 . 各程序模块之间的层次（调用）关系：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, // 快速排序voidHeapSort(LinkList*L, // 堆排序void BubbleSort(LinkList* L, // 冒泡排序void SelSort(LinkList* L, // 选择排序int* CmpNum, int* ChgNum)int* CmpNum, int* ChgNum)int* CmpNum, int* ChgNum)*CmpNum, int* ChgNum)void Compare(LinkList*L,int* CmpNum, int* ChgNum)// 希尔排序//定义标识符关键字BOOL别名为//记录数据类型//定义关键字类型//排序的记录数据类型定义typedef struct Lin kList //记录线性表详细设计typedef int BOOL;int typedef struct Stude ntData{int num;}Data;// 定义表长 // 表长记录最大值// 排序的记录线性表类型定义// 定义随机数组类型及最大值void RandomNum(){int i; srand((int)time(NULL)); for(i=0; i 小于 MAXSIZE; i++)}/*****************初始化链表 **********************/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){void Display(LinkList* L){FILE* f;// 定义一个文件指针 f int i;****************随机生成函数 ******************int Length;Data Record[MAXSIZE]; }LinkList;int RandArray[MAXSIZE];// 用伪随机数程序产生伪随机数RandArray[i]<=(int)rand();返回 ;(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;若打开文件的指令不为空则// 通过文件指针 f 打开文件为条件判断{// 是否应该打开文件输出“ can't open file ”exit(0); }for (i=0; i 小于L->Length; i++) fprintf(f,"%d\n",L->Record[i].num); 通过文件指针f 关闭文件;三、调试分析1. 调试过程中遇到的问题及经验体会在本次程序的编写和调试过程中，我曾多次修改代码，并根据调试显示的界面一次次调整代码。
在调试成功之前，我的程序因为 3 个错误而无法运行，在经过完整并且仔细的检查后，发现 3 处错误分别是没有定义变量就直接套用、忘记加指针符号、忘记在嵌套语句后加大括号，这些看似不显眼的小问题却导致整个程序无法运行，所以我认为在编程过程中要及其严谨，尽量少犯或避免犯语法错误，保证代码的完整性。
2. 算法的时空分析：1. 稳定性比较：插入排序、冒泡排序、简单选择排序及其他线形排序是稳定的；希尔排序、快速排序、堆排序是不稳定的。
插入排序、冒泡排序、选择排序的时间复杂性为2.时间复杂性比较：O(n2) ；其它非线形排序的时间复杂性为0( nlog2 n) 线形排序的时间复杂性为0(n)。
3. 辅助空间的比较：线形排序的辅助空间为0(n)，其它排序的辅助空间为0(1)。
4. 其它比较：插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。
反而在这种情况下，快速排序反而慢了：当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序；当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下，宜用归并排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。
四、用户守则1.可执行文件为：a.exe2. 为了界面更加友好特将背景颜色设计为黑色，字体为白色。
3.进入演示程序后即显示文本形式的用户界面，再按提示一步步完成:测试结果及其分析：通过本次程序的运行，得到数据：插入排序：比较的次数为25114496，交换的次数为25094525，花费的时间为1203ms ；希尔排序：比较的次数为3834939 ，交换的次数为3782098 ，花费五、测试结果交挣一旳次粧P 沖U 刖日交唤的灰数活冊站冒泡交骐的次数■抽■・所用的吋间-ltS6»所埔的时间-2M5«£比较结束，谓按回车蜒所坤的时怛卜1触U正在W.谓趟爭女帳沟农最-EW745E5 .交护覘冼駅吨了鬧相挖所粕的对间"197"5 所馬曲时问-倨即忸 肝用的时间-etas的时间为187ms ；快速排序：比较的次数为153398 ，交换的次数为62804 ，花费的时间为0ms ；堆排序：比较的次数为235273 ，交换的次数为124235 ，花费的时间为16ms ；冒泡排序：比较的次数为49995000 ，交换的次数为27537172 ，花费的时间为2969ms ；选择排序：比较的次数为50005000 ，交换的次数为9988 ，花费的时间为1656ms 。
算法效率是依据算法执行的时间来看的，从上面的数据来看，虽然插入排序的算法简洁，容易实现，但是从它执行的时间1203ms 来看它的效率并不是很高，而且比较次数和交换次数都比较多，在这六种排序中效率是很底的；希尔排序的时间复杂度较直接排序低，在六种内部排序中效率居中；分析冒泡排序的效率，容易看出，若初始序列为“正序”序列，则只进行一趟排序，在排序过程中进行n-1 次关键字的比较，反之，则需进行n-1 趟排序，总的时间复杂度为O(n2) ，在该程序中，冒泡排序所花费的时间为4360 ，是所有排序中花费最多的，可见效率是很底的。
快速排序是对冒泡排序的一种改进，它所用的时间几乎为0 ，交换的比较的次数都比较少；堆排序仅次于快速排序，花费的时间只有16ms 。
由以上讨论可知，从时间上看，快速排序的平均性能都优于其他5 种排序。
算法时间复杂度分析如下：1 、直接插入排序：当文件的初始状态不同时，直接插入排序所耗费的时间是有很大差异的。
最好情况是文件初态为正序，此时算法的时间复杂度为O(n) ，最坏情况是文件初态为反序，相应的时间复杂度为0(n2)，算法的平均时间复杂度是0(n2);2、选择排序是不稳定的，算法复杂度为0(n2);3、快速排序是不稳定的主体算法时间运算量约O(log2 n)，划分子区函数运算量约0(n)，所以总的时间复杂度为0(nlog2n)，它显然优于冒泡排序0(n2)；4、希尔排序是不稳定的，算法复杂度是n1.25~1.6* n1.25 ；5、冒泡排序是稳定的，时间复杂度为0(n2)；6、堆排序是不稳定的。
对各种表长和测试组数进行了测试，程序运行正常。
分析实测得到的数值，6种排序算法的特点小结如下：(1)若较小(如<),可采用直接插入或直接选择排序。
当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜；(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；⑶若n较大，则应采用时间复杂度为0(nign)的排序方法：快速排序、堆排序或归并排序；快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。
这两种排序都是不稳定的。
附录（源代码）#inciude<stdio.h># inciude <stdiib.h># inciude <string.h># inciude <time.h># inciude <windows.h># inciude <winbase.h># define MAXSIZE 10000 #define TRUE 1# define FALSE 0 typedef int B00L; int typedef struct StudentData{int num;}Data;// 线性表中最多元素个数// 定义标识符关键字B00L 别名为// 记录数据类型// 定义关键字类型// 排序的记录数据类型定、▲义 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];及最大值 / ******************随机生成函数 ************************************* 初始化链表 ********************** // 记录线性表 // 随机生成函数// 用伪随机数程序产生伪随机return; }// 初始化链表// 调用随机函数L->Length=i;BOOL LT(int i, int j, int* CmpNum) { (*CmpNum)++; if (i<j) return TRUE; return FALSE;}void Display(LinkList* L){FILE* f; int i;if((f=fopen("SortRes.txt","w"))==NULL) 打开文件为条件判断{printf("can't open file\n"); exit(0);}for (i=0; i<L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);fclose(f); // 通过文件指针 f 关闭文件}冒泡排序 *******************************void BubbleSort(LinkList* L, int* CmpNum, int* ChgNum) { int i,j; Data temp;// 定义一个文件指针 f// 通过文件指针 f// 是否应该打开文件***********for (i=0; i<MAXSIZE-1;i++){for(j=0;j<MAXSIZE-i-1;j++) {if(!LT(L->Record[j].num,L->Record[j+1].num,CmpNum)) {(*ChgNum)++;memcpy(&temp,&L->Record[j],sizeof(Data));memcpy(&L->Record[j],&L->Record[j+1],sizeof(Data));memcpy(&L->Record[j+1],&temp,sizeof(Data));}}}}*******选择排序******************************* int SelectMinKey(LinkList* L,int k,int* CmpNum){int Min=k;for ( k<L->Length; k++) {if(!LT(L->Record[Min].num,L->Record[k].num,CmpNum))Min=k;return Min;}void SelSort(LinkList* L, int* CmpNum, int* ChgNum) {int i, j; Data temp;for(i=0; i<L->Length; i++) {j=SelectMinKey(L,i,CmpNum);if(i!=j){(*ChgNum)++; memcpy(&temp,&L->Record[i],sizeof(Data));memcpy(&L->Record[i],&L->Record[j],sizeof(Data));memcpy(&L->Record[j],&temp,sizeof(Data));}************* 快速排序******************************int Partition (LinkList* L, int low, int high, int* CmpNum, int* ChgNum) {Data Temp;int PivotKey;memcpy(&Temp,&L->Record[low],sizeof(Data));PivotKey=L->Record[low].num;while (low < high){while (low<high && L->Record[high].num >= PivotKey) {high--;(*CmpNum)++;}(*ChgNum)++;memcpy(&L->Record[low],&L->Record[high],sizeof(Data));while (low<high && L->Record[low].num <= PivotKey){low++;(*CmpNum)++;}(*ChgNum)++;memcpy(&L->Record[high],&L->Record[low],sizeof(Data));}memcpy(&L->Record[low],&Temp,sizeof(Data));return low;}void QSort (LinkList* L, int low, int high, int* CmpNum, int*ChgNum) {int PivotLoc=0;if (low < high){PivotLoc=Partition(L,low,high,CmpNum,ChgNum);QSort(L,low,PivotLoc-1,CmpNum,ChgNum);QSort(L,PivotLoc+1,high,CmpNum,ChgNum); }void QuickSort (LinkList* L, int* CmpNum, int* ChgNum){ QSort(L,0,L->Length-1,CmpNum,ChgNum);/********************* 希尔排序*************************void ShellInsert(LinkList* L,int dk, int* CmpNum, int* ChgNum) {int i, j; Data Temp; for(i=dk; i<L->Length;i++) {if( LT(L->Record[i].num, L->Record[i-dk].num, CmpNum) ) {memcpy(&Temp,&L->Record[i],sizeof(Data));for(j=i-dk; j>=0 && LT(Temp.num, L->Record[j].num, CmpNum) j-=dk) {(*ChgNum)++;memcpy(&L->Record[j+dk],&L->Record[j],sizeof(Data));}memcpy(&L->Record[j+dk],&Temp,sizeof(Data));}}}void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum){int k; for (k=0; k<t; ShellInsert(L,dlta[k],CmpNum,ChgNum); } /************ ******************************/void HeapAdjust (LinkList* L,int s, int m, int* CmpNum, int* ChgNum){Data Temp;int j=0; s++;memcpy(&Temp,&L->Record[s-1],sizeof(Data));for (j=2*s; j<=m j*=2){if(j<mLT(L->Record[j-1].num,L->Record[j].num,CmpNum)) ++j;if(!LT(Temp.num,L->Record[j-1].num,CmpNum))break;k++) 堆排序&&(*ChgNum)++;memcpy(&L->Record[s-1],&L->Record[j-1],sizeof(Data));s=j;}memcpy(&L->Record[s-1],&Temp,sizeof(Data)); }void HeapSort (LinkList* L, int* CmpNum, int* ChgNum){int i=0;Data Temp;for (i=L->Length/2-1; i>=0; i--)HeapAdjust(L,i,L->Length,CmpNum,ChgNum);for (i=L->Length; i>1; i--){memcpy(&Temp,&L->Record[0],sizeof(Data));(*ChgNum)++;memcpy(&L->Record[0],&L->Record[i-1],sizeof(Data)); memcpy(&L->Record[i-1],&Temp,sizeof(Data)); HeapAdjust(L,0,i-1,CmpNum,ChgNum);**********************************************void Compare(LinkList* L,int* CmpNum, int* ChgNum) {int TempTime,i;int SpendTime;int dlta[3]={7,3,1};int Indata[1]={1};TempTime=(int)GetTickCount();ShellSort(L,Indata,1,&CmpNum[0],&ChgNum[0]);SpendTime=(int)GetTickCount()-TempTime;printf("\n\t====================================================="); printf("\n\n\t 插入排序:");printf("\n\t 比较的次数=%d\t 交换的次数=%d\t 所用的时间=%dms",CmpNum[0],ChgNum[0],SpendTime);for(i=0; i<MAXSIZE; i++)L->Record[i].num=RandArray[i]; // 随机数列复位TempTime=(int)GetTickCount();ShellSort(L, dlta, 3,&CmpNum[1],&ChgNum[1]);SpendTime=(int)GetTickCount()-TempTime;printf("\n\n\t 希尔排序:");printf("\n\t 比较的次数=%d\t 交换的次数=%d\t 所用的时间=%dms",CmpNum[1],ChgNum[1],SpendTime);for(i=0; i<MAXSIZE; i++)L->Record[i].num=RandArray[i]; // 随机数列复位TempTime=(int)GetTickCount();QuickSort(L,&CmpNum[2],&ChgNum[2]);SpendTime=(int)GetTickCount()-TempTime;printf("\n\n\t 快速排序:");printf("\n\t 比较的次数=%d\t 交换的次数=%d\t 所用的时间=%dms",CmpNum[2],ChgNum[2],SpendTime);for(i=0; i<MAXSIZE; i++)L->Record[i].num=RandArray[i]; // 随机数列复位TempTime=(int)GetTickCount();HeapSort(L,&CmpNum[3],&ChgNum[3]);SpendTime=(int)GetTickCount()-TempTime;printf("\n\n\t 堆排序:");printf("\n\t 比较的次数=%d\t 交换的次数=%d\t 所用的时间=%dms",CmpNum[3],ChgNum[3],SpendTime);for(i=0; i<MAXSIZE; i++) L->Record[i].num=RandArray[i]; // 随机数列复位TempTime=(int)GetTickCount();BubbleSort(L,&CmpNum[4],&ChgNum[4]);SpendTime=(int)GetTickCount()-TempTime;printf("\n\n\t 冒泡排序:");printf("\n\t 比较的次数=%d\t 交换的次数=%d\t 所用的时间=%dms",CmpNum[4],ChgNum[4],SpendTime);for(i=0; i<MAXSIZE; i++) L->Record[i].num=RandArray[i];// 随机数列复位TempTime=(int)GetTickCount();SelSort(L,&CmpNum[5],&ChgNum[5]);SpendTime=(int)GetTickCount()-TempTime;printf("\n\n\t 选择排序:");printf("\n\t 比较的次数=%d\t 交换的次数=%d\t 所用的时间=%dms",CmpNum[5],ChgNum[5],SpendTime);printf("\n\t====================================================="); }/*************** 主函数*******************************/void main() { int select=0;int dlta[3]={7,3,1}; int Indata[1]={1};int CmpNum[6],ChgNum[6]; //CnpNum 数组时比较次数，ChgNum 是交换次数int SpendTime=0;LinkList L; InitLinkList(&L);memset(CmpNum,0,sizeof(CmpNum));memset(ChgNum,0,sizeof(ChgNum));-可编辑修改--可编辑修改 -printf("\t\t 数据结构课程设计 \n\n");getchar(); system("cls.exe");Compare(&L,CmpNum,ChgNum);//Display(&L); printf("\n\n\tgetchar();getchar();printf("\n\n\t\t ****************************************** \n");printf("\t\t内部排序算法的比较 \n\n"); printf("\t\tPlese press enter to continue...\n"); printf("\t\t** ****************************************H );printf("\n\t 正在计算请稍等 ); 比较所有排序 比较结束 , 请按回车键 !\n");THANKS !!!致力为企业和个人提供合同协议，策划案计划书，学习课件等等打造全网一站式需求欢迎您的下载，资料仅供参考-可编辑修改-。