数据结构课程设计_排序算法比较【完整版】

合集下载

数据结构课程设计—内部排序算法比较

数据结构课程设计—内部排序算法比较

数据结构课程设计—内部排序算法比较在计算机科学领域中,数据的排序是一项非常基础且重要的操作。

内部排序算法作为其中的关键部分,对于提高程序的运行效率和数据处理能力起着至关重要的作用。

本次课程设计将对几种常见的内部排序算法进行比较和分析,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。

冒泡排序是一种简单直观的排序算法。

它通过重复地走访要排序的数列,一次比较两个数据元素,如果顺序不对则进行交换,并一直重复这样的走访操作,直到没有要交换的数据元素为止。

这种算法的优点是易于理解和实现,但其效率较低,在处理大规模数据时性能不佳。

因为它在最坏情况下的时间复杂度为 O(n²),平均时间复杂度也为O(n²)。

插入排序的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入,直到整个序列有序。

插入排序在数据量较小时表现较好,其平均时间复杂度和最坏情况时间复杂度也都是 O(n²),但在某些情况下,它的性能可能会优于冒泡排序。

选择排序则是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(或最大)元素,然后放到已排序序列的末尾。

以此类推,直到全部待排序的数据元素排完。

选择排序的时间复杂度同样为O(n²),但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。

快速排序是一种分治的排序算法。

它首先选择一个基准元素,将数列分成两部分,一部分的元素都比基准小,另一部分的元素都比基准大,然后对这两部分分别进行快速排序。

快速排序在平均情况下的时间复杂度为 O(nlogn),最坏情况下的时间复杂度为 O(n²)。

然而,在实际应用中,快速排序通常表现出色,是一种非常高效的排序算法。

归并排序也是一种分治算法,它将待排序序列分成若干个子序列,每个子序列有序,然后将子序列合并成一个有序序列。

数据结构课程设计实践报告

数据结构课程设计实践报告

数据结构实验报告本文是范文,仅供参考写作,禁止抄袭本文内容上传提交,违者取消写作资格,成绩不合格!实验名称:排序算法比较提交文档学生姓名:提交文档学生学号:同组成员名单:指导教师姓名:排序算法比较一、实验目的和要求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]的位置。

《数据结构排序》课件

《数据结构排序》课件

根据实际需求选择时间复杂度和空间 复杂度最优的排序算法,例如快速排 序在平均情况下具有较好的性能,但 最坏情况下其时间复杂度为O(n^2)。
排序算法的适用场景问题
适用场景考虑因素
选择排序算法时需要考虑实际应 用场景的特点,如数据量大小、 数据类型、是否需要稳定排序等 因素。
不同场景适用不同
算法
例如,对于小规模数据,插入排 序可能更合适;对于大规模数据 ,快速排序或归并排序可能更优 。
排序的算法复杂度
时间复杂度
衡量排序算法执行时间随数据量增长而增长的速率。时间复杂度越低,算法效 率越高。常见的时间复杂度有O(n^2)、O(nlogn)、O(n)等。
空间复杂度
衡量排序算法所需额外空间的大小。空间复杂度越低,算法所需额外空间越少 。常见的空间复杂度有O(1)、O(logn)、O(n)等。
在数据库查询中,经常需要对结果进行排序,以便用户能够快速找到所需信息。排序算 法的效率直接影响到查询的响应时间。
索引与排序
数据库索引能够提高查询效率,但同时也需要考虑到排序的需求。合理地设计索引结构 ,可以加速排序操作。
搜索引擎中的排序
相关性排序
搜索引擎的核心功能是根据用户输入的 关键词,返回最相关的网页。排序算法 需要综合考虑网页内容、关键词密度、 链接关系等因素。
VS
广告与排序
搜索引擎中的广告通常会根据关键词的竞 价和相关性进行排序,以达到最佳的广告 效果。
程序中的排序应用
数组排序
在程序中处理数组时,经常需要对其进行排 序。不同的排序算法适用于不同类型的数据 和场景,如快速排序、归并排序等。
数据可视化中的排序
在数据可视化中,需要对数据进行排序以生 成图表。例如,柱状图、饼图等都需要对数 据进行排序处理。

数据结构的常用算法

数据结构的常用算法

数据结构的常用算法一、排序算法排序算法是数据结构中最基本、最常用的算法之一。

常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。

1. 冒泡排序冒泡排序是一种简单的排序算法,它重复地比较相邻的两个元素,如果它们的顺序错误就将它们交换过来。

通过多次的比较和交换,最大(或最小)的元素会逐渐“浮”到数列的顶端,从而实现排序。

2. 选择排序选择排序是一种简单直观的排序算法,它每次从待排序的数据中选择最小(或最大)的元素,放到已排序序列的末尾,直到全部元素排序完毕。

3. 插入排序插入排序是一种简单直观的排序算法,它将待排序的数据分为已排序区和未排序区,每次从未排序区中取出一个元素,插入到已排序区的合适位置,直到全部元素排序完毕。

4. 快速排序快速排序是一种常用的排序算法,它采用分治的思想,通过一趟排序将待排序的数据分割成独立的两部分,其中一部分的所有数据都比另一部分小,然后再按此方法对这两部分数据进行快速排序,递归地进行,最终实现整个序列有序。

5. 归并排序归并排序是一种稳定的排序算法,它采用分治的思想,将待排序的数据分成若干个子序列,分别进行排序,然后将排好序的子序列合并成更大的有序序列,直到最终整个序列有序。

二、查找算法查找算法是在数据结构中根据给定的某个值,在数据集合中找出目标元素的算法。

常见的查找算法有线性查找、二分查找、哈希查找等。

1. 线性查找线性查找是一种简单直观的查找算法,它从数据集合的第一个元素开始,依次比较每个元素,直到找到目标元素或遍历完整个数据集合。

2. 二分查找二分查找是一种高效的查找算法,它要求数据集合必须是有序的。

通过不断地将数据集合分成两半,将目标元素与中间元素比较,从而缩小查找范围,最终找到目标元素或确定目标元素不存在。

3. 哈希查找哈希查找是一种基于哈希表的查找算法,它通过利用哈希函数将目标元素映射到哈希表中的某个位置,从而快速地找到目标元素。

三、图算法图算法是解决图结构中相关问题的算法。

排序算法分析和比较

排序算法分析和比较

一、设计思想排序是数据处理中使用频率很高的一种操作,是数据查询之前需要进行的一项基础操作。

它是将任意序列的数据元素(或记录)按关键字有序(升序或降序)重新排列的过程。

排序的过程中有两种基本操作:一是比较两个关键字的值;二是根据比较结果移动记录位置。

排序的算法有很多种,这里仅对插入排序、选择排序、希尔排序、归并排序和快速排序作了比较。

直接插入排序算法基本思路:直接插入排序时将一个元素插入已排好的有序数组中,从而得到一个元素个数增加1的新的有序数组。

其具体实现过程是,将第i个元素与已经排好序的i-1个元素依次进行比较,再将所有大于第i个元素的元素后移一个位置,直到遇到小于或等于第i个元素,此时该元素的后面一个位置为空,将i元素插入此空位即可。

选择排序算法基本思路:定义两个数组sela[]和temp[],sela[]用来存放待排序数组,temp[]用来存放排好序的数组。

第一趟,将sela[]数组中n个元素进行比较,找出其中最小的元素放入temp[]的第一个位置,同时将sela[]中将该元素位置设置为无穷大。

第二趟,将sela[]数组中n个元素进行比较,找出其中最小的元素放入temp[]的第二个位置,同时将sela[]中将该元素位置设置为无穷大。

以此类推,n趟后将sela[]中所有元素都已排好序放入temp[]数组中。

希尔排序算法基本思路:希尔排序又称为变长步径排序,它也是一种基于插入排序的思想。

其基本思路是,定义一个步长数组gaps[1,5,13,43……],先选取合适的大步长gap将整个待排序的元素按步长gap分成若干子序列,第一个子序列的元素为a[0]、a[0+gap]、a[0+2gap]……a[0+k*gap];第二列为a[1]、a[1+gap]、a[1+2gap]……a[1+k*gap];……。

然后,对这些子序列分别进行插入排序,然后将gap按gaps[]数组中的步长缩小,按缩小后的步长再进行子序列划分排序,再减小步长直到步长为1为止。

数据结构(C语言版)实验报告 (内部排序算法比较)

数据结构(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.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中,我曾多次修改代码,并根据调试显示的界面一次次调整代码。

数据结构排序算法实验报告

数据结构排序算法实验报告
t=i; } e=list[t]; countsm++; list[t]=list[j]; countsm++; list[j]=e; countsm++; } cout<<"选择排序比较次数:"<<countsc<<" "<<"选择排序移动次数:"<<countsm<<endl; } //快速排序 void QSort(Element *list,int m,int n) { int i,j,k,temp; if(m<n) { i=m; j=n+1; k=list[m].GetKey(); while(i<j) {
移动次数 735219 247071 2997 7296 22836 4233
乱序 2 比较次数 496238 255211 499500 12927 14868 3788
移动次数 762636 256210 2997 7449 22 242989 499500 12951 14845 3818
希尔排序:void ShellSort(Element *list,int n) 记录移动和比较次数的变量:int countlm=0,countlc=0 希尔排序是将文件分组,然后进行插入排序,因此 countlm,countlc 的增量方式与直 接插入排序相同。
堆排序:void HeapSort(Element *list,const int n) 记录移动和比较次数的变量:int countrm=0,countrc=0 首先进行初始建堆 void Restore(Element *tree,const int root,const int n),将待排序文 件保存在完全二叉树中,从最后一个非叶节点开始,将其孩子结点与其进行比较, 每比较一次 countrc 加 1,若孩子结点比其大,二者交换 countrm 加 3,直到任意结 点的关键词大于等于它的两个孩子结点。在进行堆排序,将根节点与最后一个叶节 点交换,countrm 加 3,再进行初始建堆,直至完全排好序。

数据结构内部排序算法比较

数据结构内部排序算法比较

内部排序算法比较第一章问题描述排序是数据结构中重要的一个部分,也是在实际开发中易遇到的问题,所以研究各种排算法的时间消耗对于在实际应用当中很有必要通过分析实际结合算法的特性进行选择和使用哪种算法可以使实际问题得到更好更充分的解决!该系统通过对各种内部排序算法如直接插入排序,冒泡排序,简单选择排序,快速排序,希尔排序,堆排序、二路归并排序等,以关键码的比较次数和移动次数分析其特点,并进行比较,估算每种算法的时间消耗,从而比较各种算法的优劣和使用情况!排序表的数据是多种不同的情况,如随机产生数据、极端的数据如已是正序或逆序数据。

比较的结果用一个直方图表示。

第二章系统分析界面的设计如图所示:|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|请选择操作方式:如上图所示该系统的功能有:(1):选择 1 时系统由客户输入要进行测试的元素个数由电脑随机选取数字进行各种排序结果得到准确的比较和移动次数并打印出结果。

(2)选择 2 时系统由客户自己输入要进行测试的元素进行各种排序结果得到准确的比较和移动次数并打印出结果。

(3)选择0 打印“谢谢使用!!”退出系统的使用!!第三章系统设计(I)友好的人机界面设计:(如图3.1所示)|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|(3.1)(II)方便快捷的操作:用户只需要根据不同的需要在界面上输入系统提醒的操作形式直接进行相应的操作方式即可!如图(3.2所示)|******************************||-------欢迎使用---------||-----(1)随机取数-------||-----(2)自行输入-------||-----(0)退出使用-------||******************************|请选择操作方式:(用户在此输入操作方式)(3.2)(III)系统采用定义结构体数组来存储数据。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

课程设计报告数据结构课程设计题目:各种排序*******专业:网络工程班级:10211302学号:**********指导教师:姜林王志波2012年6 月27 日目录排序算法比较一、程序要求分析二、程序主要功能三、程序运行平台四、程序数据结构五、算法及时间复杂度六、程序源代码七、自我总结各种排序一、需求分析任务:用程序实现插入法排序、起泡法、选择法、快速法、合并法排序;输入的数据形式为任何一个正整数,大小不限。

输出的形式:数字大小逐个递增的数列。

要求给出多组不同元素个数的输入数据,并用列表打印出每种排序下的各趟排序结果。

每个排序法结束时应打印出其元素比较的次数和交换的次数。

此程序需将结果用列表打印,一定要将其打印结果排列好。

二、程序的主要功能1.用户输入任意个数,产生相应数量的随机数2.用户可以自己选择排序方式(直接插入排序,冒泡排序、快速排序、选择排序、二路归并排序五种排序方法)的一种3.程序给出原始数据、排序后从小到大的数据,并给出排序所用的时间,比较的总次数和交换的总次数。

三、程序运行平台Visual C++ 6.0版本四、数据结构1.类:NuovSort{public:void Myface();void choose();void insertsort(int R[],int n); //直接插入排序法void Bubblesort(int R[],int n); //冒泡排序算法实现void quicksort(int R[],int left,int right); //快速排序算法实现void selectsort(int R[],int n); //直接选择排序算法实现void merge(int R[],int A[],int s,int m,int t);//二路归并排序算法实现void mergepass(int R[],int A[],int n,int c);void mergesort(int R[],int n);};2.主界面:Myface() //界面{cout<<"\t -->各种排序算法实现<--"<<endl;cout<<"#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^#"<<endl;cout<<"# 1.直接插入排序#"<<endl;cout<<"# 2.冒泡排序#"<<endl;cout<<"# 3.快速排序#"<<endl;cout<<"# 4.直接选择排序#"<<endl;cout<<"# 5.二路归并排序#"<<endl;cout<<"#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^#"<<endl;cout<<"enter your choose:";}3.选择界面:choose(){int i,x,n,s,t;time_t t1,t2;double tt1,tt2,tt3,tt4,tt5;cout<<"\t\t\t 欢迎您使用高扬的排序程序"<<endl;cout<<"请问,需要几个被排序数字?"<<endl;do{cout<<"请输入个数(范围在1~500 之间): ";cin>>n;}while((n<1)||(n>500));int left=0,right=n-1;for(i=0;i<n;i++)R[i]=rand()%888+1; //产生随机数cout<<"被排序的数字随机产生如下:"<<endl;for(i=0;i<n;i++)cout<<R[i]<<" ";cout<<endl;cout<<endl;Myface();int m=0;cin>>m;switch(m){case 1:t1=time(NULL);insertsort(R,n);t2=time(NULL);tt1=difftime(t2,t1);cout<<"排序所需时间为:"<<tt1<<endl;break; //直接插入排序算法实现case 2:t1=time(NULL);Bubblesort(R,n);t2=time(NULL);tt2=difftime(t2,t1);cout<<"排序所需时间为:"<<tt2<<endl;break; //冒泡排序算法实现case 3:t1=time(NULL);cout<<"Before the sort,your answer is:";for(x=0;x<n;x++){cout.width(4);cout<<R[x]<<" ";}cout<<endl;quicksort(R,left,right);cout<<"排序的结果是:";for(x=0;x<n;x++)cout<<R[x]<<" ";cout<<endl;cout<<endl;cout<<"元素比较次数为"<<comN3<<"次"<<endl;cout<<"元素交换次数为"<<chaN3<<"次"<<endl;t2=time(NULL);tt3=difftime(t2,t1);cout<<"排序所需时间为:"<<tt3<<endl;break; //快速排序算法实现case 4:t1=time(NULL);selectsort(R,n);t2=time(NULL);tt4=difftime(t2,t1);cout<<"排序所需时间为:"<<tt4<<endl;break; //直接选择排序算法实现case 5:t1=time(NULL);mergesort(R,n);cout<<endl;cout<<"元素比较次数为"<<comN5<<"次"<<endl;cout<<"元素交换次数为"<<chaN5<<"次"<<endl;t2=time(NULL);tt5=difftime(t2,t1);cout<<"排序所需时间为:"<<tt5<<endl;break; //二路归并排序算法实现default:cout<<"input error "<<endl;choose();}}五、算法及时间复杂度(一)各个排序的算法思想:(1)直接插入排序算法思想:将一个记录插入到已排好的有序表中,从而得到一个新的,记录数增加1的有序表。

(2)起泡排序算法思想:首先将第一个记录的关键字和第二个记录的关键字进行比较,若为逆序,则将两个记录交换,然后比较第二个记录和第三个记录的关键字。

依此类推,直到第N-1和第N个记录的关键字进行过比较为止。

上述为第一趟排序,其结果使得关键字的最大纪录被安排到最后一个记录的位置上。

然后进行第二趟起泡排序,对前N-1个记录进行同样操作。

一共要进行N-1趟起泡排序。

(3)快速排序算法思想:通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,已达到整个序列有序。

(4)选择排序算法思想:通过N-I次关键字间的比较,从N-I+1个记录中选出关键字最小的记录,并和第I(1<=I<=N)个记录交换。

(5)二路归并排序算法思想:先将每个数确定为一个空间,然后两两比较,把排序后的结果放在新数组中,然后再两两比较,以此类推,最终把所有的子区间合并为一个区间。

(二)时间复杂度分析六、程序源代码/**********************************************************************************************设计要求:利用随机函数产生N个随机整数(N = 1到500),利用直接插入排序,冒泡排序、快速排序、选择排序、二路归并排序五种排序方法(可添加其它排序方法)进行排序(结果为由小到大的顺序),并统计每一种排序所耗费的时间,比较的总次数和交换的总次数。

#include<ctime>#include<math.h>#include<stdlib.h>#include<iostream>#include<time.h>using namespace std;const int maxsize=500;int R[maxsize];int A[maxsize];int i,n,right,left;int comN1=0,chaN1=0; //直接插入排序中元素比较的次数和交换的次数int comN2=0,chaN2=0; //冒泡排序中元素比较的次数和交换的次数int comN3=0,chaN3=0; //快速排序中元素比较的次数和交换的次数int comN4=0,chaN4=0; //直接选择排序中元素比较的次数和交换的次数int comN5=0,chaN5=0; //合并排序中元素比较的次数和交换的次数class NuovSort{public:void Myface();void choose();void insertsort(int R[],int n); //直接插入排序法void Bubblesort(int R[],int n); //冒泡排序算法实现void quicksort(int R[],int left,int right); //快速排序算法实现void selectsort(int R[],int n); //直接选择排序算法实现void merge(int R[],int A[],int s,int m,int t);//二路归并排序算法实现void mergepass(int R[],int A[],int n,int c);void mergesort(int R[],int n);};void NuovSort::Myface() //界面{cout<<"\t -->各种排序算法实现<--"<<endl;cout<<"#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^#"<<endl;cout<<"# 1.直接插入排序#"<<endl;cout<<"# 2.冒泡排序#"<<endl;cout<<"# 3.快速排序#"<<endl;cout<<"# 4.直接选择排序#"<<endl;cout<<"# 5.二路归并排序#"<<endl;cout<<"#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^#"<<endl;cout<<"enter your choose:";}void Display(int R[], int n){for(int i=0;i<n;i++){cout.width(4);cout<<R[i];}cout<<endl<<endl;}void NuovSort::choose(){int i,x,n,s,t;time_t t1,t2;double tt1,tt2,tt3,tt4,tt5;cout<<"\t\t\t 欢迎您使用高扬的排序程序"<<endl;cout<<"请问,需要几个被排序数字?"<<endl;do{cout<<"请输入个数(范围在1~500 之间): ";cin>>n;}while((n<1)||(n>500));int left=0,right=n-1;for(i=0;i<n;i++)R[i]=rand()%888+1; //产生随机数cout<<"被排序的数字随机产生如下:"<<endl;for(i=0;i<n;i++)cout<<R[i]<<" ";cout<<endl;cout<<endl;Myface();int m=0;cin>>m;switch(m){case 1:t1=time(NULL);insertsort(R,n);t2=time(NULL);tt1=difftime(t2,t1);cout<<"排序所需时间为:"<<tt1<<endl;break; //直接插入排序算法实现case 2:t1=time(NULL);Bubblesort(R,n);t2=time(NULL);tt2=difftime(t2,t1);cout<<"排序所需时间为:"<<tt2<<endl;break; //冒泡排序算法实现case 3:t1=time(NULL);cout<<"Before the sort,your answer is:";for(x=0;x<n;x++){cout.width(4);cout<<R[x]<<" ";}cout<<endl;quicksort(R,left,right);cout<<"排序的结果是:";for(x=0;x<n;x++)cout<<R[x]<<" ";cout<<endl;cout<<endl;cout<<"元素比较次数为"<<comN3<<"次"<<endl;cout<<"元素交换次数为"<<chaN3<<"次"<<endl;t2=time(NULL);tt3=difftime(t2,t1);cout<<"排序所需时间为:"<<tt3<<endl;break; //快速排序算法实现case 4:t1=time(NULL);selectsort(R,n);t2=time(NULL);tt4=difftime(t2,t1);cout<<"排序所需时间为:"<<tt4<<endl;break; //直接选择排序算法实现case 5:t1=time(NULL);mergesort(R,n);cout<<endl;cout<<"元素比较次数为"<<comN5<<"次"<<endl;cout<<"元素交换次数为"<<chaN5<<"次"<<endl;t2=time(NULL);tt5=difftime(t2,t1);cout<<"排序所需时间为:"<<tt5<<endl;break; //二路归并排序算法实现default:cout<<"input error "<<endl;choose();}}//直接插入排序算法实现void NuovSort::insertsort(int R[],int n){int p,x=1;for(int i=1;i<n;i++){int temp=R[i];int j=i-1;while((j>=0)&&(temp<R[j])){comN1++;R[j+1]=R[j];j--;}comN1++;R[j+1]=temp;chaN1++;cout<<"第"<<x++<<"趟被排序的数字如下:"<<endl;for(p=0;p<n;p++){cout.width(4);cout<<R[p]<<" ";}cout<<endl;}cout<<endl;cout<<"元素比较次数为"<<comN1<<"次"<<endl;cout<<"元素交换次数为"<<chaN1<<"次"<<endl;}//冒泡排序算法实现void NuovSort::Bubblesort(int R[],int n){int flag=1;int x=1; //当flag为0时则停止排序for(int i=1;i<n;i++){for(int i=1;i<n;i++){//i表示趟数,最多n-1趟flag=0;for(int j=n-1;j>=i;j--){comN2++;if(R[j]<R[j-1]){//发生逆序int t=R[j];R[j]=R[j-1];R[j-1]=t;flag=1;//交换,并标记发生了变化chaN2++;}}cout<<"第"<<x++<<"趟被排序的数字如下:"<<endl;for(i=0;i<n;i++){cout.width(4);cout<<R[i];}cout<<endl;}if(flag==0)break;}cout<<endl;cout<<"元素比较次数为"<<comN2<<"次"<<endl;cout<<"元素交换次数为"<<chaN2<<"次"<<endl;}//快速排序算法实现void NuovSort::quicksort(int R[],int left,int right) {int k=left,j=right;int n=right;int t,temp=R[k];while(k<j){while((R[j]>temp)&&(j>k)){comN3++;j--;}if(k<j){t=R[k];R[k]=R[j];R[j]=t;chaN3++;k++;}while((R[k]<temp)&&(k<j)){comN3++;k++;}if(k<j){t=R[k];R[k]=R[j];R[j]=t;chaN3++;j--;}}//一次划分得到基准值的正确位置R[k]=temp;if(left<k-1)quicksort(R,left,k-1);if(k+1<right)quicksort(R,k+1,right);}//直接选择排序算法实现void NuovSort::selectsort(int R[],int n){int i,j,m,p;int t;for(i=0;i<n-1;i++){m=i;for(j=i+1;j<n;j++)if(R[j]<R[m]){comN4++;m=j;}if(m!=i){t=R[i];R[i]=R[m];R[m]=t;chaN4++;}cout<<"第"<<i+1<<"趟被排序的数字如下:"<<endl;for(p=0;p<n;p++){cout.width(4);cout<<R[p]<<" ";}cout<<endl;}cout<<endl;cout<<"元素比较次数为"<<comN4<<"次"<<endl;cout<<"元素交换次数为"<<chaN4<<"次"<<endl;}//二路归并排序算法实现void NuovSort::merge(int R[],int A[],int s,int m,int t)//将两个子区间R[s]~R[m]和R[m+1]~R[t]合并,结果存储在A中{int i,j,temp;i=s;j=m+1;while((i<=m)&&(j<=t)){comN5++;if(R[i]>=R[j]){chaN5++;temp=R[j];for(int k=j-1;k>=i;k--){R[k+1]=R[k];}R[i]=temp;j++;}else{i++;}}for(int l=s;l<=t;l++)A[l]=R[l];}void NuovSort::mergepass(int R[],int A[],int n,int c)//对R数组做一趟排序归并,结果存入A数组中,n为元素个数,c为区间长度{int i,j;i=0;while(i+2*c-1<=n-1)//长度均为c的两个区间合并成一个区间{merge(R,A,i,i+c-1,i+2*c-1);i+=2*c;}if(i+c-1<n) //长度不等的两个区间合并成一个区间merge(R,A,i,i+c-1,n-1);else //仅剩一个区间时直接复制到A中for(j=i;j<=n-1;j++)A[j]=R[j];}void NuovSort::mergesort(int R[],int n){int c=1,i=0,k=1;int A[maxsize];cout<<"二路归并排序的每一次的结果如下:"<<endl<<endl;cout<<"初始状态:";Display(R,n);while(c<n){mergepass(R,A,n,c); //一次合并且结果存入A中i=i+1;cout<<"第"<<k<<"趟: ";k++;Display(R,n);c*=2;mergepass(A,R,n,c); //再次合并且结果存入R中i=i+1;cout<<"第"<<k<<"趟: ";k++;Display(R,n);c*=2;}}//函数的实现int main(){NuovSort v;char ch;cout<<"\t\t\t -->各种排序算法实现<--"<<endl;do{v.choose();cout<<endl;cout<<"\t\t\t --> 继续操作按'Y;,退出按'N' <-"<<endl;cin>>ch;while(ch!='Y'&&ch!='N'){cout<<"请根据提示操作!## 继续操作按'Y;,退出按'N' ##"<<endl;cin>>ch;}}while(ch!='N');return 0;}七、自我总结经过三天的努力,终于做完了这份程序。

相关文档
最新文档