完整版数据结构毕业课程设计排序算法比较完整版.docx

完整版数据结构毕业课程设计排序算法比较完整版.docx

《完整版数据结构毕业课程设计排序算法比较完整版.docx》由会员分享，可在线阅读，更多相关《完整版数据结构毕业课程设计排序算法比较完整版.docx（23页珍藏版）》请在冰豆网上搜索。

完整版数据结构毕业课程设计排序算法比较完整版

XXXXXX大学

《数据结构》课程设计报告

目录

排序算法比较

1、需求分析

2、程序的主要功能

3、程序运行平台

4、数据结构

5、算法及时间复杂度

6、测试用例

7、程序源代码

二感想体会与总结

排序算法比较

一、需求分析

利用随机函数产生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.OK;

}

输入随机数并显示在界面上

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,ERROR;

}

for（i=2;i<=L.length;i++）

{

L.r[0]=L.r[i];将L.r[i]暂存在L.r[0]

low=1;

OK;

}

********************************************************************************

希尔排序

*********************************************************************************

参考书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,intlow;

}Partition函数

voidQsort（Sqlist&L,intlow,int（L,low,ERROR;

}

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（i

i++;

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.length2;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,*>0）将每个元素分配至各个链队

{

for（j=0;j<10;j++）初始化各链队首、尾指针

{

=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█████████████████████████████████████\n"）;

printf（"\n"）;

printf（"算法排序比较系统\n"）;

printf（"\n"）;

printf（"█████████████████████████████████████\n"）;

printf（"以下是各个排序算法的代号：

\n\n"）;

printf（"1、直接插入排序\n"）;

printf（"2、折半插入排序\n"）;

printf（"3、起泡排序\n"）;

printf（"4、快速排序\n"）;

printf（"5、选择排序\n"）;

printf（"6、堆排序\n"）;

printf（"7、基数排序\n"）;

printf（"8、退出该系统\n\n"）;

ScanfSqlist（m,L0）;

printf（"\n"）;

printf（"1、直接插入排序\n"）;

printf（"2、折半插入排序\n"）;

printf（"3、起泡排序\n"）;

printf（"4、快速排序\n"）;

printf（"5、选择排序\n"）;

printf（"6、堆排序\n"）;

printf（"7、基数排序\n"）;

printf（"8、退出该系统\n\n"）;

printf（"\n请选择排序的方式,数字1-7:

"）;

scanf（"%d",&choice）;选择排序方式赋值choice，用于后面的函数选择

while（choice<1||choice>8）

{

printf（"输入方式有误。

\n请输入1-7选择排序方式，或者选择8退出系统"）;

scanf（"%d",&choice）;

}

while（choice!

=8）

{

for（i=1;i<=L0.length;i++）

L.r[i]=L0.r[i];

L.length=L0.length;

switch（choice）

{

case1:

直接插入排序

start=clock（）;

InsertSort（L）;

finish=clock（）;

break;

case2:

折半插入排序

start=clock（）;

BInsertSort（L）;

finish=clock（）;

break;

case3:

起泡排序

start=clock（）;

BubbleSort（L）;

finish=clock（）;

break;

case4:

快速排序

start=clock（）;

QuickSort（L）;

finish=clock（）;

break;

case5:

选择排序

start=clock（）;

ChooseSort（L）;

finish=clock（）;

break;

case6:

堆排序

start=clock（）;

HeapSort（L）;

finish=clock（）;

break;

case7:

基数排序

start=clock（）;

RadixSort（L）;

finish=clock（）;

break;

case8:

直接退出

break;

}

PrintfSqlist（m,L）;输出数据和L的长度

duration=（double）（finish-start）CLOCKS_PER_SEC;输出算术时间

printf（"\n本次排序运算所用的时间是：

%lfseconds\n",duration）;

printf（"本次排序结束。

\n"）;

printf（"___________________________________________________________________\n"）;

printf（"继续本系统吗？

\n\n"）;

printf（"以下是各个排序算法的代号：

\n"）;

printf（"1、直接插入排序\n"）;

printf（"2、折半插入排序\n"）;

printf（"3、起泡排序\n"）;

printf（"4、快速排序\n"）;

printf（"5、选择排序\n"）;

printf（"6、堆排序\n"）;

printf（"7、基数排序\n"）;

printf（"8、退出该系统\n"）;

printf（"\n请请输入1-7选择排序方式，或者选择8退出系统:

"）;

scanf（"%d",&choice）;

while（choice<1||choice>8）

{

printf（"输入方式有误。

\n请输入1-7选择排序方式，或者选择8退出系统"）;

scanf（"%d",&choice）;

}

}

}

感想体会与总结

好的算法＋编程技巧＋高效率＝好的程序。

1、做什么都需要耐心，做设计写程序更需要耐心。

一开始的时候，我写函数写的很快，可是等最后调试的时候发现错误很隐蔽，就很费时间了。

后来我先在纸上构思出函数的功能和参数，考虑好接口之后才动手编，这样就比较容易成功了。

2、做任何事情我决定都应该有个总体规划。

之后的工作按照规划逐步展开完成。

对于一个完整的程序设计，首先需要总体规划写程序的步骤，分块写分函数写，然后写完一部分马上纠错调试。

而不是像我第一个程序，一口气写完，然后再花几倍的时间调试。

一步步来，走好一步再走下一步。