实验报告内部排序算法比较
内部排序实验报告总结
内部排序实验报告总结内部排序实验报告总结一、引言内部排序是指对一个存储在计算机内存中的数据集合进行排序的过程。
在本次实验中，我们对常见的内部排序算法进行了实验比较，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。
通过比较这些算法的执行时间和空间复杂度，我们可以评估它们在不同数据集上的性能。
二、实验目的1. 比较不同内部排序算法在不同数据集上的性能差异；2. 了解各种内部排序算法的实现原理；3. 掌握如何分析和评估算法的时间复杂度和空间复杂度。
三、实验方法1. 实验环境：使用具有相同硬件配置和操作系统版本的计算机进行测试。
2. 实验数据：选择多个不同大小和特征的数据集进行测试，包括随机数列、有序数列和逆序数列。
3. 实验步骤：3.1 实现各个内部排序算法；3.2 对每个数据集分别运行各个算法，并记录执行时间；3.3 分析结果并比较各个算法之间的性能差异。
四、实验结果与分析1. 冒泡排序：冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，并按照大小交换它们的位置。
经过多次遍历，最大（或最小）的元素会逐渐移动到数列的末尾。
冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
在本次实验中，冒泡排序在随机数列上表现良好，但在有序数列和逆序数列上性能较差。
这是因为冒泡排序需要进行多次交换操作，而有序数列和逆序数列中元素已经接近或完全有序，交换操作并不频繁。
2. 选择排序：选择排序是一种简单直观的排序算法，它每次从待排序的数据中选择最小（或最大）的元素，并将其放到已排好序的部分末尾。
选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
实验结果显示，选择排序在各种数据集上都表现稳定。
这是因为选择排序每次只需进行一次交换操作，相对于冒泡排序来说更加高效。
3. 插入排序：插入排序是一种简单直观且稳定的内部排序算法，它将待排序的数据分为已排序和未排序两部分，每次从未排序部分取出一个元素，插入到已排序部分的适当位置。
内部排序比较 (实验报告+源程序)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. 分析不同排序算法在实际应用中的适用场景。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 数据集：随机生成的10000个整数三、实验内容本次实验主要比较以下排序算法：1. 冒泡排序（Bubble Sort）2. 选择排序（Selection Sort）3. 插入排序（Insertion Sort）4. 快速排序（Quick Sort）5. 归并排序（Merge Sort）四、实验步骤1. 定义排序算法函数。
2. 生成随机整数数据集。
3. 对每个排序算法进行多次测试，记录其时间消耗。
4. 比较不同排序算法的时间复杂度和空间复杂度。
5. 分析不同排序算法在实际应用中的适用场景。
五、实验结果与分析1. 冒泡排序空间复杂度：O(1)冒泡排序是一种简单的排序算法，其基本思想是通过两两比较相邻元素的大小，将较大的元素交换到后面，直到排序完成。
实验结果显示，冒泡排序的时间消耗较高，不适合处理大数据集。
2. 选择排序时间复杂度：O(n^2)空间复杂度：O(1)选择排序的基本思想是每次从待排序的序列中找到最小（或最大）元素，将其放到序列的起始位置，然后继续对剩余未排序的序列进行同样的操作。
实验结果显示，选择排序的时间消耗与冒泡排序相近，同样不适合处理大数据集。
3. 插入排序时间复杂度：O(n^2)空间复杂度：O(1)插入排序的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
实验结果显示，插入排序的时间消耗与冒泡排序和选择排序相近，同样不适合处理大数据集。
4. 快速排序时间复杂度：O(nlogn)空间复杂度：O(logn)快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，再分别对这两部分记录继续进行排序，以达到整个序列有序。
数据结构课程设计—内部排序算法比较
数据结构课程设计—内部排序算法比较在计算机科学领域中，数据的排序是一项非常基础且重要的操作。
内部排序算法作为其中的关键部分，对于提高程序的运行效率和数据处理能力起着至关重要的作用。
本次课程设计将对几种常见的内部排序算法进行比较和分析，包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
冒泡排序是一种简单直观的排序算法。
它通过重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
这种算法的优点是易于理解和实现，但其效率较低，在处理大规模数据时性能不佳。
因为它在最坏情况下的时间复杂度为 O(n²)，平均时间复杂度也为O(n²)。
插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个序列有序。
插入排序在数据量较小时表现较好，其平均时间复杂度和最坏情况时间复杂度也都是 O(n²)，但在某些情况下，它的性能可能会优于冒泡排序。
选择排序则是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。
以此类推，直到全部待排序的数据元素排完。
选择排序的时间复杂度同样为O(n²)，但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。
快速排序是一种分治的排序算法。
它首先选择一个基准元素，将数列分成两部分，一部分的元素都比基准小，另一部分的元素都比基准大，然后对这两部分分别进行快速排序。
快速排序在平均情况下的时间复杂度为 O(nlogn)，最坏情况下的时间复杂度为 O(n²)。
然而，在实际应用中，快速排序通常表现出色，是一种非常高效的排序算法。
归并排序也是一种分治算法，它将待排序序列分成若干个子序列，每个子序列有序，然后将子序列合并成一个有序序列。
数据结构实验--各种排序算法的比较
实验题目：各种查找及排序算法比较实验内容：内部排序算法——插入排序（直接插入排序、折半插入排序）、交换排序（冒泡、快速排序）、选择排序（直接选择排序、堆排序）和归并排序（2-路归并排序）的具体实现。
目的与要求：掌握各种内部排序算法的特点，并对一整型数组排序，比较不同算法的速度。
实验算法：1）、数据结构描述：主函数中的a数组保存需要排序数组，将数组作为自变量输入到各种排序算法的函数中，各个函数返回值为排序之后的数组，在主函数中以一个循环体输出。
2）、函数和算法描述：主函数main先用循环体保存数组a，然后输出菜单，通过switch语句调用排序函数，将数组排序后输出。
InsertSort为直接插入排序对应的函数，并附有插入元素到数组的功能，函数主体是从数组第二个元素开始与其前的元素一一比较大小，并且插入到合适位置使得该元素的大小位于相邻元素之间。
BinsertSort为折半插入排序对应的函数，函数主体是在如上所述进行插入时，先比较待插入元素与其前的有序列的中心元素的大小关系，以此循环来判断插入位置。
BubbleSort为冒泡排序对应的函数，为二重循环结构，外循环每循环一次，决定出待排序部分的最大值并置于待排部分的末端，内循环对相邻两个元素大小作比较，进行调换。
Partition QuickSort为快速排序对应的函数，建有两个指针，从待排部分两端进行扫描，一次循环之后，将极大值和极小值各置于一端。
SelectMinKey SSSort为选择排序对应的函数，每循环一次，直接选出待排序部分中最小的元素并置于已排序部分之后，直至待排部分长度为0。
Merge MSort MergeSort为归并排序对应的函数，先将数组元素每两个一组并在组内排序，再将每两组和为一组进行排序，依次循环，直至分组长度与数组长度相同。
HeapAdjust HeapSort为堆排序对应的函数，通过循环，将数组调整为大顶堆形式，输出一次即可得到有序序列。
数据结构(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*/四．实验小结（包括问题解和解决方法、心得体会、意见与建议等）通过本次实验对教材上的各种内排序算法进行了逐一验证。
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个记录。
实验报告内部排序算法比较
实验报告内部排序算法比较题目：内部排序算法比较排序算法是数据结构学科经典的内容，其中内部排序现有的算法有很多种，究竟各有什么特点呢？本文力图设计实现常用内部排序算法并进行比较。
分别为起泡排序，直接插入排序，简单选择排序，快速排序，堆排序，针对关键字的比较次数和移动次数进行测试比较．一.问题分析和总体设计ADT OrderableList{数据对象：D={ai| ai∈IntegerSet,i=1,2,…,n,n≥0}数据关系：R1={〈ai-1，ai〉|ai-1, ai∈D, i=1,2,…,n}基本操作：InitList(n)操作结果：构造一个长度为n，元素值依次为1，2，…，n的有序表。
Randomizel(d,isInverseOrser)操作结果：随机打乱BubbleSort( )操作结果：进行起泡排序InserSort( )操作结果：进行插入排序SelectSort( )操作结果：进行选择排序QuickSort( )操作结果：进行快速排序HeapSort( )操作结果：进行堆排序ListTraverse(visit( ))操作结果：依次对L种的每个元素调用函数visit( )}ADT OrderableList待排序表的元素的关键字为整数.用正序,逆序和不同乱序程度的不同数据做测试比较,对关键字的比较次数和移动次数(关键字交换计为3次移动)进行测试比较.要求显示提示信息,用户由键盘输入待排序表的表长(100-1000)和不同测试数据的组数(8-18).每次测试完毕,要求列表现是比较结果.要求对结果进行分析.二.详细设计1、起泡排序bubblesort(struct rec r[],int n){int i,j;struct rec w;unsigned long int compare=0,move=0;for(i=1;i<=n-1;i++)for(j=n;j>=i+1;j--){if(r[j].key<r[j-1].key){w=r[j];r[j]=r[j-1];r[j-1]=w;move=move+3;}compare++;}printf("\nBubbleSort compare= %ld,move= %ld\n",compare,move); }2、直接插入排序insertsort(struct rec r[],int n){int i,j;unsigned long int compare=0,move=0;for(i=2;i<=n;i++){compare++;r[0]=r;move++;j=i-1;while(r[0].key3、简单选择排序selectsort(struct rec r[],int n){unsigned long int compare=0,move=0;int i,j,k;struct rec w;for(i=1;i<=n-1;i++){ k=i;for(j=i+1;j<=n;j++){ if(r[j].key>r[k].key) {k=j; compare++; }w=r;r=r[k];r[k]=w;move=move+3;}}printf("\nSelectSort compare= %ld,move= %ld\n",compare,move); }4、快速排序q(struct rec r[],int s,int t){int i=s,j=t;if(s<t){r[0]=r[s]; ++a; c++;do{while(j>i&&r[j].key>=r[0].key){j--;++a; }if(i<j){ r=r[j];i++;c++; }while(i<j&&r.key<=r[0].key){i++;++a; }if(i<j){ r[j]=r;j--;c++; }} while(i<j);r=r[0];c++;q(r,s,j-1);q(r,j+1,t);}}5. 堆排序sift(struct rec r[],int l,int m){int i,j;struct rec w;i=l; j=2*i;w=r;while(j<=m){if(j<m&&r[j].key<r[j+1].key) { j++; }if(w.key<r[j].key){r=r[j];i=j;j=2*i;}else j=m+1;}r=w;}heapsort(struct rec r[],int n){unsigned long int compare=-1,move=-1;struct rec w;int i;int a;for(i=n/2;i>=1;i--) a=sift(r,i,n);compare++;move++;for(i=n;i>=2;i--){w=r;r=r[1];r[1]=w;a=sift(r,1,i-1);compare+=a;move+=a;}}三.实验结果：1.实验测试结果如下：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）；原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性：排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。
稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。
另外，如果排序算法稳定，可以避免多余的比较；稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
数据结构(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.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中，我曾多次修改代码，并根据调试显示的界面一次次调整代码。
数据结构实验报告：内部排序算法比较
# 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个记录进行比较，找到第一个比起大的记录，利用循环让记录后移，把其放到第一个比起大的记录前面。
实验三内部排序算法效率的比较
实验三内部排序算法效率的比较一、实验目的：了解不同排序算法的时间效率了解先进的排序算法与简单的排序算法的差别掌握希尔排序算法掌握快速排序算法掌握堆排序算法能够根据实际问题选择合适的算法二、实验内容与要求：⏹希尔排序和直接插入排序⏹快速排序和冒泡排序⏹堆排序和直接选择排序要求：编写实验程序，对随机生成的n个整数分别采用两种排序方法进行排序，并分别统计每种排序算法中的关键字比较次数。
通过进行多组实验(m组)，统计每种算法的平均比较次数。
程序要具有灵活性。
m、n值应在运行时确定重点观察当n增大时两种算法的差别。
三、提示：实验分两步进行：步骤1．首先编写排序算法，令n=10，显示排序结果，目的是查看排序算法是否正确。
步骤2.修改教材中的排序算法，增加对“关键字比较次数”和“记录移动次数”统计的语句。
建议使用全局变量作为计数器。
比较100个、1000个数据的排序效率四、参考程序1.希尔排序和直接插入排序的比较实验程序# define maxnum 5000 /*排序记录的个数限制为5000*/# include <stdlib.h># include <math.h>typedef int KeyType; /*定义关键字为整型*/typedef struct{ KeyType key;int data; /*其他信息略*/} RecordType;long compare=0; /*shellsort关键字比较次数*/long compare1=0; /*直接插入的关键字比较次数*/ long move=0; /*shellsort记录移动次数*/long move1=0; /*直接插入记录移动次数*/void ShellInsert(RecordType r[],int n,int d){ int i,j;for (i=d+1; i<=n; i++){if ( r[i].key<r[i-d].key){ r[0].key=r[i].key; /*暂存r[i]*/for (j=i-d; j>0 && r[0].key<r[j].key; j-=d){r[j+d]=r[j]; /* 记录后移，找插入位置 */ compare++; /*记录比较次数*/}r[j+d]=r[0]; /* 插入记录 */}}}/*希尔排序过程：通过多次调用一趟插入排序实现 */void ShellSort(RecordType r[],int n,int d[],int m)/* 对数组r中记录进行排序, n为数组r的长度，d为增量序列，m为d的长度 */ { int k;for ( k=0; k<m; k++) ShellInsert(r,n,d[k]);}/*直接插入排序*/void Insertsort(RecordType r[],int n){ int i,j;for (i=2; i<=n; i++){r[0]=r[i];for (j=i-1; r[0].key<r[j].key; j--){r[j+1]=r[j];compare1++; /*记录比较次数*}r[j+1]=r[0];}}main(){RecordType r[maxnum+1],bf[maxnum+1];double shell_com=0, Ins_com=0;int i,times,m,d[10],n; /*d为希尔排序的增量序列,m为其长度*/ clrscr();printf("\n input times :"); /*实验组数，最后取平均值*/scanf("%d",×);printf("\n input number(<1000) :"); /*读入待排序的数据个数*/scanf("%d",&n);printf("\n input the len of INC_serial(<10) :");scanf("%d",&m); /*读入增量序列长度*/printf("\n input the searil :");for (i=0; i<m; i++) scanf("%d",&d[i]); /*读入增量序列值*/randomize(); /*初始化随机数发生器*/while (times>0){/*生成待排序的n个数据,注意保存初始数据*/for (i=1; i<=n; i++){ r[i].key=bf[i].key=rand()%1000;/* printf("%d ",r[i].key);*/}/*对随机生成的数据进行希尔排序，显示所进行的关键字比较次数*/compare=0; ShellSort(r,n,d,m);printf("\nshell: compare=%.0f",compare);shell_com+=compare;/*对随机生成的数据进行直接插入排序，所需关键字比较次数*/ compare1=0; Insertsort(bf,n);printf("\tInsert: compare=%.0f",compare1);Ins_com+=compare1;times--;}/*显示对times组数据排序的平均比较次数*/printf("\nShellsort comparing number=%.0f”,shell_com/m); printf("\nInsertsort comparing number=%.0f",Ins_com/m);}。
内部排序算法比较实验报告(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．基本要求：（1）对常用的内部排序算法进行比较：直接插入排序、简单选择排序、冒泡排序、快速排序、希尔排序、归并排序。
（2利用随机函数产生N（N=30000）个随机整数，作为输入数据作比较；比较的指标为关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）。
（3)对结果作出简要分析。
3．测试数据：随机函数产生。
二、需求分析1．程序所能达到的基本可能：通过随机数据产生N个随机数，作为输入数据作比较；对常用的内部排序算法：直接插入排序、简单选择排序、冒泡排序、快速排序、希尔排序、归并排序进行比较：比较的指标为关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）。
最后结果输出各种排序算法的关键字参加的比较次数和关键字的移动次数，并按从小到大排列。
2．输入的形式及输入值范围：随机函数产生的N（N=30000）个随机整数。
3．输出的形式：输出各种排序算法的关键字参加的比较次数和关键字的移动次数。
并按从小到大排列。
4．测试数据要求：随机函数产生的N（N=30000）个随机整数。
三、概要设计1. 所用到得数据结构及其ADT为了实现上述功能，应以一维数组表示集合数据类型。
int s[N];int compare[6]={0},move[6]={0},D[N]={0},RS[N]={0};基本操作：数组赋值：for(i=1;i<N;i++){s[i]=rand()%100;printf("%d\t",s[i]);}void copys(int S[],int RS[],int n)//将s[]的值赋给RS[],void SelectSort(int RS[],int n) //直接选择排序void BubbleSort(int RS[],int n)//冒泡排序void InsertSort(int RS[],int n) //直接插入排序int QuickSort(int RS[],int low,int high)//快速排序void QuickSortprint(int RS[],int n)//输出快速排序后的结果void Shellsert(int RS[],int m,int n)//一趟希尔排序，按间隔m划分子序列void Shellsort(int RS[],int n)//希尔排序void Merge(int RS[],int low,int mid,int high)//将两个有序序列归并为一个有序序列void MSort(int RS[],int low,int high)//归并排序2.主程序流程及其模块调用关系开始初始界面显示i=1i<Ns[i]=rand()%100数组赋值i++SelectSort(compare,5);SelectSort(move,5);i=1i<=5输出compare[i])的值i++i=1i<=5输出move[i])的值i++YNYYNNJ=1J=2J=3J=4J=5J=6SelectSort(RS,N-1);BubbleSort(RS,N-1);InsertSort(RS,N-1);QuickSortprint(RS,N-1);Shellsort(RS,N-1);MSort(RS,1,N-1);J=7J=8NNNNNNY YYYYY YNvoid SelectSort(int RS[],int n) //直接选择排序模块开始i=1 i<n k=i; j=i+1j<=nRS[j]<RS[k]k=j; compare[0]++;j++k!=iRS[0]=RS[k];RS[k]=RS[i];RS[i]=RS[0];move[0]+=3;i++输出排序后结果结束YNY YN N void BubbleSort(int RS[],int n)//冒泡排序模块开始i=1i<=n flag=True;j=1j<=n-iRS[j+1]<RS[j]flag=False;RS[0]=RS[j];RS[j]=RS[j+1]; RS[j+1]=RS[0];move[1]+=3; compare[1]++;j++flag==True输出排序后结果i++结束YNYYNNvoid InsertSort(int RS[],int n) //直接插入排序模块开始i=2i<=nRS[0]=RS[i]j=i-1; move[2]++;RS[0]<RS[j] compare[2]++; RS[j+1]=RS[j]; move[2]++;j--;RS[j+1]=RS[0];move[2]++;i++输出排序后结果结束YNYNint QuickSort(int RS[],int low,int high)//快速排序模块开始n=high; i=low; j=high; RS[0]=RS[i]; move[3]++;i<jRS[j]>=RS[0]&&j>ij--; compare[3]++;compare[3]++;j>iRS[i]=RS[j];move[3]++;i++;RS[i]<=RS[0]&&j>ii++;compare[3]++;compare[3]++;j>iRS[j]=RS[i];move[3]++;j--;RS[i]=RS[0];move[3]++;low<i High=i-1i<highLow=j+1输出排序后的结果结束YNNNNNN NYY YY YYvoid Shellsert(int RS[],int m,int n)//一趟希尔排序，按间隔m划分子序列开始i=mi<=n/m temp=RS[i];j=i;j>=m&&temp<RS[j-m] compare[4]++; RS[j]=RS[j-m];move[4]++;j-=m;RS[j]=temp; move[4]++;i++结束YNNYvoid Shellsort(int RS[],int n)//希尔排序模块开始m=n/2;m>=1Shellsert(RS,m,n); m=(m==2?1:(m/2));输出排序后结果结束YNvoid Merge(int RS[],int low,int mid,int high)//将两个有序序列归并为一个有序序列开始i=low;j=mid+1;k=low;i<=mid&&j<=highRS[i]<=RS[j] D[k]=RS[i];i++;k++; D[k]=RS[j];j++;k++;compare[5]++; move[5]++;i<=mid n1=k,n2=in1<=high&&n2<=midD[n1]=RS[n2];move[5]++;n1++,n2++n1=k,n2=jn1<=high&&n2<=highD[n1]=RS[n2];move[5]++;n1++,n2++mid=lowmid<=highRS[mid]=D[mid]move[5]++;mid++结束Y NNNNNYYYY模块调用void main()主函数模块void copys(int S[],int RS[],intn)将s[]的值赋给RS[],void SelectSort(int RS[],intn) //直接选择排序void BubbleSort(int RS[],intn)//冒泡排序void InsertSort(int RS[],intn) //直接插入排序void QuickSortprint(intRS[],int n)//快速排序后的结果Shellsort(RS,N-1);希尔排序MSort(RS,1,N-1);归并排序Merge(RS,low,mid,high);将两个有序序列归并为一个有序序列void Shellsert(int RS[],intm,int n)//一趟希尔排序，按间隔m划分子序列int QuickSort(int RS[],intlow,int high)//快速排序四、详细设计1. 实现每个操作的伪码，重点语句加注释1）void copys(int S[],int RS[],int n)//数组复制{int i;for(i=1;i<n;i++)RS[i]=S[i];}2）直接选择排序void SelectSort(int RS[],int n) //直接选择排序{int i,j,k;for(i=1;i<n;i++){k=i;for(j=i+1;j<=n;j++){if(RS[j]<RS[k])k=j;compare[0]++;}if(k!=i){RS[0]=RS[k];RS[k]=RS[i];RS[i]=RS[0];move[0]+=3;}}printf("直接选择排序后的结果：");for(i=1;i<=n;i++)printf("%d\t",RS[i]);printf("\n");printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[0],move[0]);printf("\n");}3）冒泡排序void BubbleSort(int RS[],int n)//冒泡排序{int i,j,flag;for(i=1;i<=n;i++){flag=True;for(j=1;j<=n-i;j++){ if(RS[j+1]<RS[j]){flag=False;RS[0]=RS[j];RS[j]=RS[j+1];RS[j+1]=RS[0];move[1]+=3;}compare[1]++;}if(flag==True)break;}printf("冒泡排序后的结果：");for(i=1;i<=n;i++)printf("%d\t",RS[i]);printf("\n");printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[1],move[1]);printf("\n");}4）直接插入排序void InsertSort(int RS[],int n) //直接插入排序{int i,j;for(i=2;i<=n;i++){RS[0]=RS[i];j=i-1;move[2]++;while(RS[0]<RS[j]){compare[2]++;RS[j+1]=RS[j];move[2]++;j--;}compare[2]++;RS[j+1]=RS[0];move[2]++;}printf("直接插入排序后的结果：");for(i=1;i<=n;i++)printf("%d\t",RS[i]);printf("\n");printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[2],move[2]);printf("\n");}5）快速排序int QuickSort(int RS[],int low,int high)//快速排序{int i,j,n;n=high;i=low;j=high;RS[0]=RS[i];move[3]++;while(i<j){while(RS[j]>=RS[0]&&j>i){j--;compare[3]++;}compare[3]++;if(j>i){RS[i]=RS[j];move[3]++;i++;}while(RS[i]<=RS[0]&&j>i){i++;compare[3]++;}compare[3]++;if(j>i){RS[j]=RS[i];move[3]++;j--;}}RS[i]=RS[0];move[3]++;if(low<i)QuickSort(RS,low,i-1);if(i<high)QuickSort(RS,j+1,high);}6）输出快速排序后的结果void QuickSortprint(int RS[],int n)//输出快速排序后的结果{ int i;QuickSort(RS,1,n);printf("快速排序后的结果：");for(i=1;i<=n;i++)printf("%d\t",RS[i]);printf("\n");printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[3],move[3]);printf("\n");}7）一趟希尔排序，按间隔m划分子序列void Shellsert(int RS[],int m,int n)//一趟希尔排序，按间隔m划分子序列{int i,j,temp;for(i=m;i<=n/m;i++){temp=RS[i];j=i;while(j>=m&&temp<RS[j-m]){compare[4]++;RS[j]=RS[j-m];move[4]++;j-=m;}RS[j]=temp;move[4]++;}}8）希尔排序void Shellsort(int RS[],int n)//希尔排序{int m,i;m=n/2;while(m>=1)//循环直到m为0{Shellsert(RS,m,n);m=(m==2?1:(m/2));//缩小增进量}printf("希尔排序后的结果：");for(i=1;i<=n;i++)printf("%d\t",RS[i]);printf("\n");printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[4],move[4]);printf("\n");}9）将两个有序序列归并为一个有序序列void Merge(int RS[],int low,int mid,int high)//将两个有序序列归并为一个有序序列{int i,j,k;int n1,n2;i=low;j=mid+1;k=low;while(i<=mid&&j<=high)//两两比较{if(RS[i]<=RS[j]){D[k]=RS[i];i++;k++;}else{D[k]=RS[j];j++;k++;}compare[5]++;move[5]++;}if(i<=mid)for(n1=k,n2=i;n1<=high&&n2<=mid;n1++,n2++){D[n1]=RS[n2];move[5]++;}elsefor(n1=k,n2=j;n1<=high&&n2<=high;n1++,n2++){D[n1]=RS[n2];move[5]++;}for(mid=low;mid<=high;mid++){RS[mid]=D[mid];move[5]++;}}10）归并排序void MSort(int RS[],int low,int high)//归并排序{int mid;if(low<high){mid=(low+high)/2;MSort(RS,low, mid);MSort(RS, mid+1,high);Merge(RS,low,mid,high);}}11）主函数void main(){int i,j,s[N];time_t rawtime;struct tm * timeinfo;time (&rawtime);timeinfo = localtime (&rawtime);printf(" 实验名称：实验四：内部排序算法的实现与比较\n");printf(" 学号：031350102\n");printf(" 姓名：王亚文\n");printf("=============================================\n");printf("程序运行开始，");printf("Current local time and date:%s",asctime(timeinfo));printf("产生的随机数为：\n");for(i=1;i<N;i++){s[i]=rand()%100;printf("%d\t",s[i]);}printf("\n");do{copys(s,RS,N);printf("请选择所需排序方法：");printf("\n");printf("1.选择法,2.冒泡法,3.插入法,4.快速法, 5.希尔排序法,6.归并排序法，7.输出比较信息，8.退出\n");scanf(" %d",&j);switch(j){case 1:SelectSort(RS,N-1);break;case 2:BubbleSort(RS,N-1);break;case 3:InsertSort(RS,N-1);break;case 4:QuickSortprint(RS,N-1);break;case 5:Shellsort(RS,N-1);case 6:MSort(RS,1,N-1);printf("归并排序后的结果：");for(i=1;i<N;i++)printf("%d\t",D[i]);printf("\n");printf("关键字参加的比较次数：%d,关键字的移动次数：%d\n",compare[5],move[5]);printf("\n");break;case 7:SelectSort(compare,5);SelectSort(move,5);printf("关键字参加的比较次数:\n");for(i=1;i<=5;i++)printf("%d\t",compare[i]);printf("\n");printf("关键字的移动次数：\n");for(i=1;i<=5;i++)printf("%d\t",move[i]);printf("\n");case 8:printf("Current local time and date:%s",asctime(timeinfo));exit(0);break;}}while(1);}五、调试分析1. 设计与调试过程中遇到的问题分析、体会调试过程：由于本次程序设计的数据和模块比较多，所以采用分块调试的方法，在编写完一个内部排序算法后，为了验证是否排序成功以及所输出的关键字比较次数和移动次数是否正确，采用先定义一个需要排序9个数字的数组，S[10]={0，1，2，3，4，5，6，7，8，9}和S[10]={0，9，8，7，6，5，4，3，2，1},用这两个数组检验程序的正确性与否。
排序算法比较实验报告
temp=j;
//ST++;
}
}
return temp;
}
long selectsort(long R[],long n)
{
long j,i,t;
long y=1;
int ST=0;
for( i=1;i<n;i++)
{
j = SelectMinKey(R,i,n);//在L.r[i..L.length]中选择关键字最小的记录
2．程序的优化是一个艰辛的过程，如果只是实现一般的功能，将变得容易很多，当加上优化，不论是效率还是结构优化，都需要精心设计。这次做优化的过程中，遇到不少阻力。因而以后要多花力气学习C++编程语言，必须要加强这方面的训练，这样才能在将编程思想和数据结构转换为代码的时候能得心应手。
3．这次课设通过在网上查阅大量资料、程序以及一些学术论文，很好的对内排序算法进行了研究，特别对数据结构这门课所学到的内容付诸于实践，加深了理解。另外，还学到了一写别的方面的知识。
排序方法
平均情况
最好情况
最坏情况
辅助空间
直接插入排序
O(n2)
O(n)
O(n2)
O(1)
起泡排序
O(n2)
O(n)
O(n2)
O(1)
快速排序
O(nlog2n)
O(nlog2n)
O(n2)
O(log2n)~O(n)
简单选择排序
O(n2)
O(n2)
O(n2)
O(1)
图6
3.4.4
影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下4点：
内部排序算法比较实验报告(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)。
实验报告内部排序算法比较
题目：内部排序算法比较
排序算法是数据结构学科经典的内容，其中内部排序现有的算法有很多种，究竟各有什么特点呢？本文力图设计实现常用内部排序算法并进行比较。
分别为起泡排序，直接插入排序，简单选择排序，快速排序，堆排序，针对关键字的比较次数和移动次数进行测试比较．一.问题分析和总体设计
ADT OrderableList{
数据对象：D={ai| ai∈IntegerSet,i=1,2,…,n,n≥0}
数据关系：R1={〈ai-1，ai〉|ai-1, ai∈D, i=1,2,…,n}
基本操作：
InitList(n)
操作结果：构造一个长度为n，元素值依次为1，2，…，n的有序表。
Randomizel(d,isInverseOrser)
操作结果：随机打乱
BubbleSort( )
操作结果：进行起泡排序
InserSort( )
操作结果：进行插入排序
SelectSort( )
操作结果：进行选择排序
QuickSort( )
操作结果：进行快速排序
HeapSort( )
操作结果：进行堆排序
ListTraverse(visit( ))
操作结果：依次对L种的每个元素调用函数visit( )
}ADT OrderableList
待排序表的元素的关键字为整数.用正序,逆序和不同乱序程度的不同数据做测试比较,
对关键字的比较次数和移动次数(关键字交换计为3次移动)进行测试比较.
要求显示提示信息,用户由键盘输入待排序表的表长(100-1000)和不同测试数据的组数(8-18).每次测试完毕,要求列表现是比较结果.
要求对结果进行分析.
二.详细设计
1、起泡排序
bubblesort(struct rec r[],int n)
{
int i,j;
struct rec w;
unsigned long int compare=0,move=0;
for(i=1;i<=n-1;i++)
for(j=n;j>=i+1;j--)
{
if(r[j].key<r[j-1].key)
{
w=r[j];
r[j]=r[j-1];
r[j-1]=w;
move=move+3;
}
compare++;
}
printf("\nBubbleSort compare= %ld,move= %ld\n",compare,move); }
2、直接插入排序
insertsort(struct rec r[],int n)
{
int i,j;
unsigned long int compare=0,move=0;
for(i=2;i<=n;i++)
{compare++;
r[0]=r;
move++;
j=i-1;
while(r[0].key
3、简单选择排序
selectsort(struct rec r[],int n)
{
unsigned long int compare=0,move=0;
int i,j,k;
struct rec w;
for(i=1;i<=n-1;i++)
{ k=i;
for(j=i+1;j<=n;j++)
{ if(r[j].key>r[k].key) {k=j; compare++; }
w=r;
r=r[k];
r[k]=w;
move=move+3;
}
}
printf("\nSelectSort compare= %ld,move= %ld\n",compare,move); }
4、快速排序
q(struct rec r[],int s,int t)
{
int i=s,j=t;
if(s<t)
{
r[0]=r[s]; ++a; c++;
do{
while(j>i&&r[j].key>=r[0].key)
{j--;
++a; }
if(i<j)
{ r=r[j];
i++;
c++; }
while(i<j&&r.key<=r[0].key)
{i++;
++a; }
if(i<j)
{ r[j]=r;
j--;
c++; }
} while(i<j);
r=r[0];
c++;
q(r,s,j-1);
q(r,j+1,t);
}
}
5. 堆排序
sift(struct rec r[],int l,int m)
{
int i,j;
struct rec w;
i=l; j=2*i;
w=r;
while(j<=m)
{
if(j<m&&r[j].key<r[j+1].key) { j++; }
if(w.key<r[j].key)
{
r=r[j];
i=j;
j=2*i;
}
else j=m+1;
}
r=w;
}
heapsort(struct rec r[],int n)
{
unsigned long int compare=-1,move=-1;
struct rec w;
int i;
int a;
for(i=n/2;i>=1;i--) a=sift(r,i,n);
compare++;
move++;
for(i=n;i>=2;i--)
{
w=r;
r=r[1];
r[1]=w;
a=sift(r,1,i-1);
compare+=a;
move+=a;
}
}
三.实验结果：
1.实验测试结果如下：
3.对排序算法的总结：
从实验结果知道：
对于比较次数：起泡排序次数最多，选择排序第二多且与数据是否基本有序无关，插入排序第三多。
对于移动次数：起泡排序次数最多，插入排序第二多，希尔排序约为快速排序的两倍。
对于时间：起泡排序花费的时间最多，插入排序第二多，选择排序第三多，快速排序，希尔排序还有堆排序这三种排序时间都花很少。
起泡排序和插入排序随着数组的混乱程度的增加，花的时间也会增加。
对于不同程度的混乱程度，选择排序的时间长短相差不大。
快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。
四、实验心得：
通过本次实验，对各种算法有了深刻的了解。
知道在什么情况下该用什么算法。
(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。