《数据结构》课程设计报告 排序算法比较 算术表达式求值.docx

《数据结构》课程设计报告 排序算法比较 算术表达式求值.docx

《《数据结构》课程设计报告 排序算法比较 算术表达式求值.docx》由会员分享，可在线阅读，更多相关《《数据结构》课程设计报告 排序算法比较 算术表达式求值.docx（45页珍藏版）》请在冰豆网上搜索。

《数据结构》课程设计报告排序算法比较算术表达式求值

XXXXX大学

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

排序算法比较

算术表达式求值

班级：

学号：

姓名：

指导老师：

一课程设计1——排序算法比较

1、需求分析

2、程序的主要功能

3、程序运行平台

4、数据结构

5、算法及时间复杂度

6、测试用例

7、程序源代码

二课程设计2——算术表达式求值

8、需求分析

9、程序的主要功能

10、程序运行平台

11、数据结构

12、算法及时间复杂度

13、测试用例

14、程序源代码

三感想体会与总结

排序算法比较

一、需求分析

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

}

//**************************************

//主函数

//*****************************