大数据结构课程设计报告排序算法比较.docx
《大数据结构课程设计报告排序算法比较.docx》由会员分享,可在线阅读,更多相关《大数据结构课程设计报告排序算法比较.docx(24页珍藏版)》请在冰豆网上搜索。
大数据结构课程设计报告排序算法比较
XXXXXX大学
《数据结构》课程设计报告
排序算法比较
一、需求分析
二、程序的主要功能
三、程序运行平台
四、数据结构
五、算法及时间复杂度
六、测试用例
七、程序源代码
二感想体会与总结
排序算法比较
一、需求分析
利用随机函数产生N个随机整数(N=500,1000,1500,2000,2500,…,30000),利用直接插入排序、折半插入排序,起泡排序、快速排序、选择排序、堆排序,基数排序七种排序方法(可添加其它排序方法)进行排序(结果为由小到大的顺序),并统计每一种排序所耗费的时间(统计为图表坐标形式)。
二、程序的主要功能
1.用户输入任意个数,产生相应的随机数
2.用户可以自己选择排序方式(直接插入排序、折半插入排序、起泡排序、快速排序、选择排序、堆排序、基数排序)的一种
3.程序给出原始数据、排序后从小到大的数据,并给出排序所用的时间。
三、程序运行平台
VisualC++6.0版本
四、数据结构
本程序的数据结构为线形表,线性顺序表、线性链表。
。
1、结构体:
typedefstruct
{
int*r;//r指向线形表的第一个结点。
r[0]闲置,不同的算法有不同的用处,如用作哨兵等。
intlength;//顺序表的总长度
}Sqlist;
2、空线性表
StatusInitSqlist(Sqlist&L)
{
L.r=(int*)malloc(MAXSIZE*sizeof(int));//分配存储空间
if(!
L.r)
{
printf("存储分配失败!
");
exit(0);
}//存储分配失败
L.length=0;//初始长度为0
returnOK;
}
五、算法及时间复杂度
(一)各个排序是算法思想:
(1)直接插入排序:
将一个记录插入到已排好的有序表中,从而得到一个新的,记录数增加1的有序表。
(2)折半插入排序:
插入排序的基本插入是在一个有序表中进行查找和插入,这个查找可利用折半查找来实现,即为折半插入排序。
(3)起泡排序:
首先将第一个记录的关键字和第二个记录的关键字进行比较,若为逆序,则将两个记录交换,然后比较第二个记录和第三个记录的关键字。
依此类推,直到第N-1和第N个记录的关键字进行过比较为止。
上述为第一趟排序,其结果使得关键字的最大纪录被安排到最后一个记录的位置上。
然后进行第二趟起泡排序,对前N-1个记录进行同样操作。
一共要进行N-1趟起泡排序。
(4)快速排序:
通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,已达到整个序列有序。
(5)选择排序:
通过N-I次关键字间的比较,从N-I+1个记录中选出关键字最小的记录,并和第I(1<=I<=N)个记录交换。
(6)堆排序:
在堆排序的算法中先建一个大顶堆,既先选得一个关键字作为最大的记录并与序列中最后一个记录交换,然后对序列中前N-1记录进行选择,重新将它调整成一个大顶堆,如此反复直到排序结束。
(7)基数排序:
按最低位优先法先对低位关键字进行排序,直到对最高位关键字排序为止,经过若干次分配和收集来实现排序
(二)时间复杂度分析
排序算法
最差时间
时间复杂度
是否稳定?
插入排序
O(n2)
O(n2)
稳定
冒泡排序
O(n2)
O(n2)
稳定
快速排序
O(n2)
O(n*log2n)
不稳定
选择排序
O(n2)
O(n2)
稳定
堆排序
O(n*log2n)
O(n*log2n)
不稳定
基数排序
O(n*log2n)
O(n2)
稳定
10000个数据的时间比较:
算法名称
用时
直接插入排序
0.25
折半插入排序
0.219
起泡排序
0.704
快速排序
0.016
选择排序
0.39
堆排序
0.0001
基数排序
0.016
六、测试用例
1、首先选择需要排序的数字个数,比如输入5000。
2、系统显示出随机产生的随机数。
用户选择排序方式,比如选择1.直接插入排序
3、系统将随机数排序后整齐的显示出来。
4、用户可以选择继续排序或者退出系统。
七、程序源代码
/**********************************************************************************************
第六题:
排序算法比较
设计要求:
利用随机函数产生N个随机整数(N=500,1000,1500,2000,2500,…,30000),
利用直接插入排序、折半插入排序,起泡排序、快速排序、||选择排序、堆排序,基数排序七种排序方法
(可添加其它排序方法)进行排序(结果为由小到大的顺序),并统计每一种排序所耗费的时间(统计
为图表坐标形式)。
************************************************************************************************/
#include"stdio.h"
#include"stdlib.h"
#include"time.h"//计时
#defineERROR0
#defineOK1
#defineOVERFLOW-2
#defineMAXSIZE100000//用户自己规定排序的数字的长度
typedefintStatus;
typedefstruct
{
int*r;//r[0]闲置
intlength;//顺序表的总长度
}Sqlist;
//构造一个空线性表
StatusInitSqlist(Sqlist&L)
{
L.r=(int*)malloc(MAXSIZE*sizeof(int));//分配存储空间
if(!
L.r)
{
printf("存储分配失败!
");
exit(0);
}//存储分配失败
L.length=0;//初始长度为0
returnOK;
}
//输入随机数并显示在界面上
StatusScanfSqlist(int&N,Sqlist&L)
{
inti;
printf("请输入要排序的元素个数N:
");
scanf("%d",&N);
for(i=1;i<=N;i++)
L.r[i]=rand();//随机产生样本整数
printf("\n\n");
printf("随机产生了%d个随机数,它们是:
\n",N);
for(i=1;i<=N;i++)
{
printf("%7.2d",L.r[i]);
}
printf("\n");
L.length=N;//存储线性表的长度
returnOK;
}
//输出排序之后的数据
StatusPrintfSqlist(intN,SqlistL)
{
inti;
printf("数据个数:
");//输出数据个数
printf("%d\n",L.length);
printf("排序后的数据:
(从左向右依次增大)\n");//输出数据
for(i=1;i<=N;i++)
printf("%7.2d",L.r[i]);
printf("\n");
returnOK;
}
//***************************************************************
//直接插入排序
//***************************************************************
StatusInsertSort(Sqlist&L)//参考书P265算法10.1
{
inti,j;
if(L.length==0)
{
printf("要排序的数据为空!
");
returnERROR;
}
for(i=2;i<=L.length;i++)
{
if(L.r[i]{
L.r[0]=L.r[i];//复制为监视哨
L.r[i]=L.r[i-1];
for(j=i-2;L.r[0]{
L.r[j+1]=L.r[j];//记录后移
}
L.r[j+1]=L.r[0];//插入到正确位置
}
}
returnOK;
}
//***************************************************************
//折半插入排序
//***************************************************************
StatusBInsertSort(Sqlist&L)//参考书P267算法10.2
{
inti,j,mid,low,high;
if(L.length==0)
{
printf("要排序的数据为空!
");
returnERROR;
}
for(i=2;i<=L.length;i++)
{
L.r[0]=L.r[i];//将L.r[i]暂存在L.r[0]
low=1;
high=i-1;
while(low<=high)//在r[low..high]中折半查找有序插入的位置
{
mid=(low+high)/2;
if(L.r[0]{
high=mid-1;
}
else
{
low=mid+1;//插入点在高半区
}
}//while
for(j=i-1;j>=high+1;j--)//插入点后的数据后移
{
L.r[j+1]=L.r[j];
}
L.r[high+1]=L.r[0];//将数据插入
}//for
returnOK;
}
/********************************************************************************
希尔排序
*********************************************************************************/
//参考书P272算法10.4及10.5
/*StatusShellInsert(Sqlist&L,intdk)//希尔插入排序
{
inti,j;//前后位置的增量是dk
for(i=dk+1;i<=L.length;i++)//r[0]只是暂存单元,不是哨兵,
{
if(L.r[i]{
L.r[0]=L.r[i];//暂存L.r[0]
for(j=i-dk;j>0&&L.r[0]{
L.r[j+dk]=L.r[j];//记录后移,查找插入位置
}
L.r[j+dk]=L.r[0];//插入
}
}
returnOK;
}
StatusShellSort(Sqlist&L,intdlta[5],intt)//希尔排序
{
inti;
if(L.length==0)
{
printf("要排序的数据为空!
");
returnERROR;
}
for(i=0;i{
ShellInsert(L,dlta[i]);//一趟增量为dlta[k]的插入排序
}
returnOK;
}
*/
//**************************************************************
//起泡排序
//**************************************************************
StatusBubbleSort(Sqlist&L)
{
inti,j,t;
if(L.length==0)
{
printf("要排序的数据为空!
");
returnERROR;
}
for(i=1;i<=L.length-1;i++)
{
for(j=1;j<=L.length-i;j++)
{
if(L.r[j]>L.r[j+1])//前面的数据>后面数据时
{
t=L.r[j+1];
L.r[j+1]=L.r[j];
L.r[j]=t;//将元素交换
}
}
}
returnOK;
}
//****************************************************
//快速排序
//****************************************************
intPartition(Sqlist&L,intlow,inthigh)//交换顺序表中子表L.r[low..high]的记录,使得枢轴记录到位,并返回其所在位置,此时在它之前(后)的记录均不大于它
{
intpivotkey;//记录关键字
L.r[0]=L.r[low];//用子表的第一个纪录作枢轴纪录
pivotkey=L.r[low];//用枢轴纪录关键字
while(low{
while(low=pivotkey)
{
high--;
}
L.r[low]=L.r[high];//将比枢轴记录小的记录移到低端
while(low{
low++;
}
L.r[high]=L.r[low];//将比枢轴记录大的数移到高端
}
L.r[low]=L.r[0];//枢轴记录到位
returnlow;
}//Partition函数
voidQsort(Sqlist&L,intlow,inthigh)
{
intpivotloc;
if(low{
pivotloc=Partition(L,low,high);
Qsort(L,low,pivotloc-1);//对低子表递归排序,pivotloc是枢轴位置
Qsort(L,pivotloc+1,high);//对高子表递归排序
}
}//Qsort函数
StatusQuickSort(Sqlist&L)
{
if(L.length==0)
{
printf("要排序的数据为空!
");
returnERROR;
}
Qsort(L,1,L.length);
returnOK;
}//QuickSort
//**********************************************
//选择排序
//**********************************************
StatusChooseSort(Sqlist&L)
{
inti,j,k,t;
if(L.length==0)
{
printf("没有数据!
");
returnERROR;
}
for(i=1;i<=L.length;i++)//排序的趟数
{
k=i;
for(j=i+1;j<=L.length;j++)//比较第i个元素以及其后的数据中最小的
{
if(L.r[j]k=j;
}
if(i!
=j)//将最小数据赋值给L.r[i]
{
t=L.r[i];
L.r[i]=L.r[k];
L.r[k]=t;
}
}
returnOK;
}
//****************************************
//堆排序
//****************************************
StatusHeapAdjust(Sqlist&L,ints,intm)//调整L.r[s]的关键字,使L.r[s~m]成大顶堆
{
inti;
L.r[0]=L.r[s];
for(i=2*s;i+1<=m;i*=2)//沿数据较大的孩子结点向下筛选
{
if(ii++;
if(L.r[0]>=L.r[i])//L.r[0]插入在S位置上
break;
L.r[s]=L.r[i];
s=i;
}
L.r[s]=L.r[0];//插入新数据
returnOK;
}
StatusHeapSort(Sqlist&L)//堆排序
{
inti,t;
if(L.length==0)
{
printf("没有数据!
");
returnERROR;
}
for(i=L.length/2;i>0;i--)
HeapAdjust(L,i,L.length);
for(i=L.length;i>1;i--)
{
t=L.r[1];//将堆顶记录和当前未经排序的子序列L.r[1..i]中最后一个记录互换
L.r[1]=L.r[i];
L.r[i]=t;
HeapAdjust(L,1,i-1);//将L.r[1..i-1]重新调整为大顶堆
}
returnOK;
}
//**************************************************
//基数排序
//**************************************************
typedefstructnode{
intkey;
node*next;
}RecType;
StatusRadixSort(SqlistL)
{
intt,i,j,k,d,n=1,m;
RecType*p,*s,*q,*head[10],*tail[10];//定义各链队的首尾指针
for(i=1;i<=L.length;i++)//将顺序表转化为链表
{
s=(RecType*)malloc(sizeof(RecType));
s->key=L.r[i];
if(i==1)//当为第一个元素时
{
q=s;
p=s;
t++;
}
else
{
q->next=s;//将链表连接起来
q=s;
t++;
}
q->next=NULL;
}
d=1;
while(n>0)//将每个元素分配至各个链队
{
for(j=0;j<10;j++)//初始化各链队首、尾指针
{
head[j]=NULL;
tail[j]=NULL;
}
while(p!
=NULL)//对于原链表中的每个结点循环
{
k=p->key/d;
k=k%10;
if(head[k]==NULL)//进行分配
{
head[k]=p;
tail[k]=p;
}
else
{
tail[k]->next=p;
tail[k]=p;
}
p=p->next;//取下一个待排序的元素
}
p=NULL;//用于收集第一个元素时的判断
for(j=0;j<10;j++)//对每一个链队循环,搜集每一个元素
{
if(head[j]!
=NULL)//进行搜集
{
if(p==NULL)
{
p=head[j];
q=tail[j];
}
else
{
q->next=head[j];
q=tail[j];
}
}
}
q->next=NULL;//最后一个结点的next置为空
d=d*10;
n=0;
m=1;
while(m<=L.length)//判断当L中的元素都除d后是不是都为零了
{
if((L.r[m]/d)!
=0)
{
n++;
m++;
}
else
m++;
}
}
i=1;
while(p!
=NULL)//将链表转换为顺序表
{
L.r[i]=p->key;
i++;
p=p->next;
}
returnOK;
}
//**************************************
//主函数
//**************************************
voidmain()
{
SqlistL;
SqlistL0;
InitSqlist(L);//初始化L
InitSqlist(L0);
intm,i;
charchoice='z';
clock_tstart,finish;//定义clock_t用于计时
doubleduration;
//向L中输入元素
printf("\n████████████