数据结构课程设计排序算法比较完整版Word下载.docx
《数据结构课程设计排序算法比较完整版Word下载.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计排序算法比较完整版Word下载.docx（25页珍藏版）》请在冰豆网上搜索。
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（n*log2n）
不稳定
选择排序
堆排序
基数排序
O（n*log2n）
稳定
10000个数据的时间比较：
算法名称
用时
直接插入排序
0.25
折半插入排序
0.219
起泡排序
0.704
0.016
0.39
0.0001
六、测试用例
1、首先选择需要排序的数字个数，比如输入5000。
2、系统显示出随机产生的随机数。
用户选择排序方式，比如选择1.直接插入排序
3、系统将随机数排序后整齐的显示出来。
4、用户可以选择继续排序或者退出系统。
七、程序源代码
/**********************************************************************************************
第六题：
设计要求：
利用随机函数产生N个随机整数（N=500，1000，1500，2000，2500，…,30000），
利用直接插入排序、折半插入排序，起泡排序、快速排序、||选择排序、堆排序，基数排序七种排序方法
（可添加其它排序方法）进行排序（结果为由小到大的顺序），并统计每一种排序所耗费的时间（统计
为图表坐标形式）。
************************************************************************************************/
#include"
stdio.h"
stdlib.h"
time.h"
//计时
#defineERROR0
#defineOK1
#defineOVERFLOW-2
#defineMAXSIZE//用户自己规定排序的数字的长度
typedefintStatus;
//r[0]闲置
//构造一个空线性表
//分配存储空间
//输入随机数并显示在界面上
StatusScanfSqlist（int&
N,Sqlist&
L）
inti;
printf（"
请输入要排序的元素个数N:
"
scanf（"
%d"
&
N）;
for（i=1;
i<
=N;
i++）
L.r[i]=rand（）;
//随机产生样本整数
\n\n"
随机产生了%d个随机数，它们是：
\n"
N）;
%7.2d"
L.r[i]）;
}
L.length=N;
//存储线性表的长度
//输出排序之后的数据
StatusPrintfSqlist（intN,SqlistL）
数据个数：
//输出数据个数
%d\n"
L.length）;
排序后的数据：
（从左向右依次增大）\n"
//输出数据
//***************************************************************
//直接插入排序
StatusInsertSort（Sqlist&
L）//参考书P265算法10.1
inti,j;
if（L.length==0）
要排序的数据为空！
returnERROR;
for（i=2;
=L.length;
if（L.r[i]<
L.r[i-1]）//将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];
j--）
{
L.r[j+1]=L.r[j];
//记录后移
}
L.r[j+1]=L.r[0];
//插入到正确位置
}
//折半插入排序
StatusBInsertSort（Sqlist&
L）//参考书P267算法10.2
inti,j,mid,low,high;
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]<
L.r[mid]）//插入点在低半区
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
/********************************************************************************
希尔排序
*********************************************************************************/
//参考书P272算法10.4及10.5
/*StatusShellInsert（Sqlist&
L,intdk）//希尔插入排序
{
//前后位置的增量是dk
for（i=dk+1;
i++）//r[0]只是暂存单元，不是哨兵，
{
L.r[i-dk]）//将L.r[i]插入有序增量子表
//暂存L.r[0]
for（j=i-dk;
0&
&
L.r[0]<
j-=dk）
L.r[j+dk]=L.r[j];
//记录后移,查找插入位置
L.r[j+dk]=L.r[0];
//插入
StatusShellSort（Sqlist&
L,intdlta[5],intt）//希尔排序
{
for（i=0;
t;
ShellInsert（L,dlta[i]）;
//一趟增量为dlta[k]的插入排序
*/
//**************************************************************
//起泡排序
StatusBubbleSort（Sqlist&
L）
inti,j,t;
=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]=t;
//将元素交换
//****************************************************
//快速排序
intPartition（Sqlist&
L,intlow,inthigh）//交换顺序表中子表L.r[low..high]的记录，使得枢轴记录到位，并返回其所在位置，此时在它之前（后）的记录均不大于它
intpivotkey;
//记录关键字
L.r[0]=L.r[low];
//用子表的第一个纪录作枢轴纪录
pivotkey=L.r[low];
//用枢轴纪录关键字
while（low<
high）
high&
L.r[high]>
=pivotkey）
high--;
L.r[low]=L.r[high];
//将比枢轴记录小的记录移到低端
L.r[low]<
low++;
L.r[high]=L.r[low];
//将比枢轴记录大的数移到高端
L.r[low]=L.r[0];
//枢轴记录到位
returnlow;
}//Partition函数
voidQsort（Sqlist&
L,intlow,inthigh）
intpivotloc;
if（low<
high）//长度大于1，可以进行
pivotloc=Partition（L,low,high）;
Qsort（L,low,pivotloc-1）;
//对低子表递归排序，pivotloc是枢轴位置
Qsort（L,pivotloc+1,high）;
//对高子表递归排序
}//Qsort函数
StatusQuickSort（Sqlist&
L）
Qsort（L,1,L.length）;
}//QuickSort
//**********************************************
//选择排序
StatusChooseSort（Sqlist&
L）
inti,j,k,t;
没有数据！
i++）//排序的趟数
k=i;
for（j=i+1;
j++）//比较第i个元素以及其后的数据中最小的
if（L.r[j]<
L.r[k]）
k=j;
if（i!
=j）//将最小数据赋值给L.r[i]
t=L.r[i];
L.r[i]=L.r[k];
L.r[k]=t;
//****************************************
//堆排序
StatusHeapAdjust（Sqlist&
L,ints,intm）//调整L.r[s]的关键字,使L.r[s~m]成大顶堆
L.r[0]=L.r[s];
for（i=2*s;
i+1<
=m;
i*=2）//沿数据较大的孩子结点向下筛选
if（i<
m&
L.r[i]<
L.r[i+1]）//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];
//插入新数据
StatusHeapSort（Sqlist&
L）//堆排序
inti,t;
for（i=L.length/2;
i>
0;
i--）
HeapAdjust（L,i,L.length）;
for（i=L.length;
1;
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]重新调整为大顶堆
//**************************************************
//基数排序
typedefstructnode{
intkey;
node*next;
}RecType;
StatusRadixSort（SqlistL）
{
intt,i,j,k,d,n=1,m;
RecType*p,*s,*q,*head[10],*tail[10];
//定义各链队的首尾指针
i++）//将顺序表转化为链表
{
s=（RecType*）malloc（sizeof（RecType））;
s->
key=L.r[i];
if（i==1）//当为第一个元素时
{
q=s;
p=s;
t++;
}
else
q->
next=s;
//将链表连接起来
q->
next=NULL;
}
d=1;
while（n>
0）//将每个元素分配至各个链队
for（j=0;
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;
}
tail[k]->
next=p;
p=p->
next;
//取下一个待排序的元素
p=NULL;
//用于收集第一个元素时的判断
j++）//对每一个链队循环，搜集每一个元素
if（head[j]!
=NULL）//进行搜集
if（p==NULL）
{
p=head[j];
q=tail[j];
}
else
q->
next=head[j];
//最后一个结点的next置为空
d=d*10;
n=0;
m=1;
while（m<
=L.length）//判断当L中的元素都除d后是不是都为零了
if（（L.r[m]/d）!
=0）
n++;
m++;
else
i=1;
while（p!
=NULL）//将链表转换为顺序表
L.r[i]=p->
key;
i++;
p=p->
//**************************************
//主函数
voidmain（）
SqlistL;
SqlistL0;
InitSqlist（L）;
//初始化L
InitSqlist（L0）;
intm,i;
charchoice='
z'
;
clock_tstart,finish;
/
升级会员 