湖州师范学院数据结构DS大作业.docx

湖州师范学院数据结构DS大作业.docx

《湖州师范学院数据结构DS大作业.docx》由会员分享，可在线阅读，更多相关《湖州师范学院数据结构DS大作业.docx（13页珍藏版）》请在冰豆网上搜索。

湖州师范学院数据结构DS大作业

求真学院

数据结构课程设计大作业

20142832班

题目：

排序效率的比较

专业：

计算机科学与技术

学生姓名：

学号

指导教师

邵斌

完成日期：

湖州师院求真学院信息工程系

目录

一、实验内容概述1

二、实验目的概述1

三、解题思路的描述1

四、源程序清单1

五、程序调试及测试结果8

六、结论9

七、参考文献10

【内容摘要】

【关键字】XXXX，XXXXX，XXXXX，XXXXX（3到5个）

数据结构是计算机存储、组织数据的方式。

数据结构是指相互之间存在一种或多种特定关系的数据元素和集合。

通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率，处理各种问题。

该程序是用C语言编写的，它充分体现数据结构的理念与算法的魅力。

该程序植入多种排序方法，这些排序方法的算法各具有特色，利用多种算法达到同一效果，正所谓“条条大路通罗马”。

并且，该程序还收集各算法的运行时间，通过对耗时的比较，为用户挑选出两种最优化的排序方法。

关键字：

排序逻辑运算数据结构时间复杂度

【Abstract】

【Keywords】XXXXX，XXXXX，XXXXX，XXXXX

Datastructureisthewayofcomputerstorageandorganizationdata.Adatastructureisadataelementandasetofdataelementsthathaveoneormorespecificrelationshipsbetweeneachother.Typically,carefullyselecteddatastructurescanbebroughttoahigherrunningorstorageefficiency,processingavarietyofproblems.该程序是用C语言编写的，它充分体现数据结构的理念与算法的魅力。

该程序植入多种排序方法，这些排序方法的算法各具有特色，利用多种算法达到同一效果，正所谓“条条大路通罗马”。

并且，该程序还收集各算法的运行时间，通过对耗时的比较，为用户挑选出两种最优化的排序方法。

TheprogramiswritteninClanguage,itfullyreflectstheconceptofdatastructureandalgorithmcharm.Theprogramisimplantedinavarietyofsortingmethods,thesesortingalgorithmshavethecharacteristicsofeachalgorithm,theuseofavarietyofalgorithmstoachievethesameeffect,istheso-called"allroadsleadtoRome".And,theprogramalsocollectstherunningtimeofeachalgorithm,throughthetimeofthecomparison,fortheusertopickouttwokindsofoptimizationofthesortingmethod.关键字：

排序逻辑运算数据结构时间复杂度

Keywords:

sortinglogicoperationdatastructuretimecomplexity

一、实验内容概述

对于直接插入排序、选择排序、冒泡排序、Shell排序、快速排序和堆排序等几种常见的排序算法进行练习，并且比较各算法在不同长度数据下的优劣。

要求：

（１）被排序的对象由计算机随机生成，长度分别取２０，１００，５００三种。

（２）程序中要有对各种排序算法的比较，具体为比较次数和移动次数的统计。

（３）对课设的结果做比较分析

二、实验目的概述

1.巩固和加深学生对数据结构算法的理解，提高综合运用所学课程知识的能力；

2.通过各个排序算法的实现，练习包括文件的读写、动态内存的申请、函数的应用、指针的应用等多种最基本的C语言操作；

3.锻炼学生的动手能力与培养其独立思考的能力。

三、解题思路的描述

这是一个算法性能评价的程序，重点在于算法的性能评价上。

实现排序功能可以有多种方法，判断一个算法性能好坏的标准主要有时间复杂度和空间复杂度。

在当今系统资源相对充足的计算机系统中，时间复杂度便成为最主要的评价标准。

对于每一个排序算法，都应当有两个返回值：

比较次数和移动次数。

这里采用指针传递地址的方式，通过修改形参的地址从而可以改变实参的值。

每个排序算法中除了含被排序对象指针外，还有两个整型变量指针，用于传递算法执行过程中的比较次数和移动次数。

取定一种排序对象的长度，由计算机产生一定量的伪随机数后，主函数调用各个排序子函数，但由于排序对象也是指向一维数组的指针，在调用一次一种排序算法后，通过形参对指针的改变，被排序对象已经是有序的了。

当再次调用其他函数时有可能使比较和移动次数达到最大或最小，就失去了比较的意义。

因此，本程序中采用了子函数另开辟空间，参数只起到一个复制值的作用，在每个子函数结束前用delete（）来释放申请排序对象的指针，避免程序出现内存耗尽的情况。

四、源程序清单

主要包括：

#include  

#include

#include

inta[501],b[501];

intlen;//数组长度

voidnumber（）

{

srand（time（0））;//srand函数是初始化随机数的种子

inti,t;

printf（"随机数长度：

\n"）;

printf（"1.长度为20\n"）;

printf（"2.长度为100\n"）;

printf（"3.长度为500\n"）;

printf（"输入序号选择长度:

"）;

scanf（"%d",&t）;

switch（t）{

case1:

n=20;

for（i=1;i<=n;i++）{

a[i]=rand（）%1000+1;//1-1000的随机数

}break;

case2:

n=100;

for（i=1;i<=len;i++）{

a[i]=rand（）%1000+1;

}break;

case3:

n=500;

for（i=1;i<=len;i++）{

a[i]=rand（）%1000+1;

}break;

}

for（i=1;i<=len;i++）

b[i]=a[i];

printf（"随机生成的%d个数如下：

\n",len）;

for（i=1;i<=len;i++）{

printf（"%d",a[i]）;

}

printf（"\n"）;

}

typedef  struct{      

int key;                                                    //关键字 

}RecordNode;                                                   //排序结点类型 

typedef struct{  RecordNode *record;              

int n;                                                    //排序对象的大小 

}ElemType;                                                 //排序对象的类型

直接排序

void InsertSort （ ElemType A[], int n ）

{  int i, j; 

ElemType  x; 

for （ i=1; i

x = A[i];        //准备插入第i个元素                            

 for （ j=i-1; j>=0; j-- ） {  //从第i-1个开始往前找插入点  

 if （ x.stn < A[j].stn ） 

 A[j+1]=A[j];  

 else   

break;  

} 

A[j+1]=x;       //插入  

} 

for（i=1;i<=n;i++）{

printf（"%d",a[i]）;

}

printf（"\n"）;

printf（"\n"）;

printf（"比较次数：

%d次\n",i）;

printf（"移动次数：

%d次\n",j）;

}

直接选择排序

void SelectSort（ElemType A[], int n） 

{   

int  i,  j,  k;   

ElemType x; 

for （ i=0;  i<=n-2;  i++ ）   {   //每一趟选择最小元素并与A[i]交换              

k=i;                  

for （j=i+1;  j<=n-1;  j++）      //查找最小元素的下标     

if （A[j].stn 

if （k!

=i）   {    //交换     

x=A[i];    A[i]=A[k];   A[k]=x; 

} 

}

for（i=1;i<=n;i++）{

printf（"%d",a[i]）;

}

printf（"\n"）;

printf（"\n"）;

printf（"比较次数：

%d次\n",i）;

printf（"移动次数：

%d次\n",j）;

}

}

冒泡排序

void BubbleSort（ ElemType A[],  int n ）

{  

int i,  j,  flag;    //flag为交换标记  

ElemType x; 

 for （i=1; i<=n-1;  i++）  {    // 最多n-1趟排序    

flag=0;       //假设本次没有交换    

for （j=n-1;  j>=i;  j--）  //第i 趟   

if （ A[j].stn < A[j-1].stn ）  {  

flag=1;      //出现交换 

x=A[j];   A[j]=A[j-1];   A[j-1]=x; 

}                     

if （flag==0）  return; 

}

for（i=1;i<=n;i++）{

printf（"%d",a[i]）;

}

printf（"\n"）;

printf（"\n"）;

printf（"比较次数：

%d次\n",i）;

printf（"移动次数：

%d次\n",j）;

}

}

Shell排序

voidShellSort（ElemType A[ ],int n,int dk）

{

int i,j,temp;

ElemType x; 

for（i=dk;i

{

temp=array[i];

for（j=i-dk;（j>=i%dk）&&array[j]>temp;j-=dk）//比较与记录后移同时进行

A[j+dk]=A[j];

if（j!

=i-dk）

A[j+dk]=temp;//插入

}

for（i=1;i<=n;i++）{

printf（"%d",a[i]）;

}

printf（"\n"）;

printf（"\n"）;

printf（"比较次数：

%d次\n",i）;

printf（"移动次数：

%d次\n",j）;

}

}

快速排序

void QuickSort（ElemType A[ ], int s, int t） 

{          //递归算法，对区间 A[s] ～A[t] 进行快速排序  

int i=s+1,   j=t; 

 ElemType  temp,   x = A[s];     //第一个为基准元素  

while （ i<=j ）  {    

while （ i<=j && A[i].stn <= x.stn ）   i++;   //从左到右 

 while （ i<=j && A[j].stn >= x.stn ）   j--;     //从右到左     

 if （ i < j ） { 

 temp=A[i];  A[i]=A[j];  A[j]=temp;   

  i++;    j--; 

 } 

for（i=1;i<=n;i++）{

printf（"%d",a[i]）;

}

printf（"\n"）;

printf（"\n"）;

printf（"比较次数：

%d次\n",i）;

printf（"移动次数：

%d次\n",j）;

}

} 

if （s!

=j）  {       //交换基准元素                    

A[s]=A[j];    A[j]=x;      } 

if （s

if （j+1

 }

堆排序 

void CreatHeap（ElemType A[], int n）       

{ 

int  i;  

for（ i = （n–2）/2;  i >= 0; i--） 

 Sift（A, n, i）;             //调整A[i..n-1]使之为一个堆      

 } 

void  Sift（ElemType A[],  int  n,  int  i） 

{    // 调整A[i..n-1]成为一个堆（它的左右子树已是一个堆） 

 ElemType  x=A[i];  

int  j = 2 * i + 1;       //  j为i的左孩子       

while  （j <= n-1）  {     // i有左子树          

if （ j +1 < n && A[j].stn < A[j+1].stn ） 

 j++;         // 使j指向左右孩子中排序码大的孩子           

if （ x.stn <  A[j].stn）  {    //使j指向左右孩子中排序码大的孩子         

A[i]=A[j];   i=j;   j=2*i+1;            

}            

else                     

 break;      

}     

 A[i]=x; 

}  

void HeapSort（ElemType A[],  int n）

{     //A为待排序表， n为表的长度       int  i; 

 ElemType x；   

 CreatHeap（A, n）;      // 把A建成一个堆       

for （i = n - 1; i >= 1; i- -）  { 

 x = A[0];      //第0个元素与第i个元素交换           

 A[0] = A[i];           

 A[i] = x;     

Sift（A, i, 0）;    //调整A[0..i-1]使之为一个堆      

} 

for（i=1;i<=n;i++）{

printf（"%d",a[i]）;

}

printf（"\n"）;

printf（"\n"）;

printf（"比较次数：

%d次\n",i）;

printf（"移动次数：

%d次\n",j）;

}

}

Voidmain（）

{ 

inti,j,n,N=20; 

cout<<"各排序方法选择结果：

\n";  

ElemType A[20]; 

for（j=0;j

cin>>A[j]; 

cout<<"排序前为：

"<

cout<

cout<<"直接插入排序:

"<

InsertSort （A,  N ）;   

for（i=0;i

cout<

cout<<"选择排序:

"<

SelectSort（A, N）;   

for（i=0;i

cout<

cout<<"冒泡排序:

"<

BubbleSort（A,  N）;        

for（i=0;i

cout<

cout<<"Shell排序:

"<

ShellSort（A,  N）;        

for（i=0;i

cout<

cout<<"快速排序:

"<

QuickSort（A,0,1）;         

for（i=0;i

cout<

cout<<"堆排序:

"<

for（i=0;i

cout<

}

算法的时间复杂度是什么？

算法的空间复杂度是什么？

为什么？

插入排序：

稳定，时间复杂度O（n^2）O（n2）

选择排序：

不稳定，时间复杂度O（n^2）O（n2）

冒泡排序：

稳定，时间复杂度O（n^2）O（n2）

希尔排序：

不稳定，时间复杂度平均时间O（nlogn）最差时间O（n^s）1

快速排序：

不稳定，时间复杂度最理想O（nlogn）最差时间O（n^2）O（Nlogn）

堆排序：

不稳定，时间复杂度O（nlogn）O（Nlogn）

五、程序调试及测试结果

主要包括：

选择长度为20的随机数，六种方法排序的结果。

从比较次数和移动次数可大致看出各排序方法的效率高低，后三种明显优于前三种

六、结论

主要包括：

随机数产生方法：

srand（time（0））就是给这个算法一个启动种子，也就是算法的随机种子数，有这个数以后才可以产生随机数,用1970.1.1至今的秒数，初始化随机数种子。

Srand是种下随机种子数，你每回种下的种子不一样，用Rand得到的随机数就不一样。

为了每回种下一个不一样的种子，所以就选用Time（0），Time（0）是得到当前时时间值（因为每时每刻时间是不一样的了）。

进行函数的参数传递时，如果传入一个地址，比传入一个struct效率要高，因为少了一个拷贝过程。

待改进的地方：

很多步骤有重复用到，如把数组b赋值给a，定义Ccnt，Rcnt等，可以做个初始化的函数调用，省去重复的代码。

可以增加其他排序方法进行效率比较。

七、参考文献

[1]唐国民,王国钧.数据结构[M].北京:

清华大学出版社,2013:

213-238

[2]张乃孝.算法与数据结构——C语言描述[M].北京:

高等教育出版社,2002

[3]唐国民，王智群.C语言程序设计[M].北京:

清华大学出版社,2009:

107-115

[4]唐国民,王国钧.数据结构实验教程[M].北京:

清华大学出版社,2013:

195-207

说明：

标为M的是书籍

标为D的为学位论文

标为J的为期刊

标为C的为会议论文