实验7 内部排序算法比较.docx
《实验7 内部排序算法比较.docx》由会员分享，可在线阅读，更多相关《实验7 内部排序算法比较.docx（13页珍藏版）》请在冰豆网上搜索。
实验7内部排序算法比较
实验7：
内部排序算法比较
一、问题描述
程序对以下4种内部排序（冒泡排序、直接插入排序、简单选择排序、快速排序）算法进行实测比较,测试各种算法在对同样的数据排序时的比较次数和移动次数.
二、输入与输出
输入：
根据用户需要输入待排表的表长（100至1000）和不同测试数据的组数
（8至18），不输入则按照默认值进行测试
输出：
每次测试完毕，列表显示各种比较指标值：
比较次数和移动次数
二、需求分析
1.本演示程序对以下4种常见的内部排序算法进行实测比较：
冒泡排序、直接插入排序、简单选择排序、快速排序
2.待排序表的元素的关键字为整数。
用正序、逆序和不同乱序程度的不同数据做测试比较。
比较的指标为由关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）
3.演示程序以用户和计算机的对话方式执行，即在计算机终端上菜单,根据用户需要输入待排表的表长（100至1000）和不同测试数据的组数（8至18），不输入则按照默认值进行测试。
四、开发工具与环境
硬件设备:
微型计算机系统
软件环境：
操作系统Windows，开发工具Devc++
五、功能分析
存储结构
typedefintTypekey;
typedefstruct｛
Typekeykey;
｝Type；
typedefstruct{
Typer[MAXSIZE+1］；//顺序表
intlength；
｝PList;//排序表
函数一览表
intOneTimeSqCreate（PList&L）
/*手动输入创建排序序列函数＊/
intManyTimeSqCreate（PList&L，intm）
/＊自动生成排序序列函数*/
voidBubbleSort（PList&L）
/*冒泡排序＊/
voidInsertSort（PList＆L）
/*插入排序＊/
voidSelectSort（PList&L）
/＊简单选择排序*/
intPartition（PList＆L，intlow，inthigh）
/＊一次快速排序*/
voidQSort（PList＆L,intlow,inthigh）
/＊递归形式的快速排序算法＊/
voidQuickSort（PList＆L）
/*快速排序*/
六、程序代码
＃include
#include〈malloc.h〉
＃include〈stdlib.h〉
#include〈time。
h〉
#defineMAXSIZE10000
usingnamespacestd;
typedefintTypekey;
intcompCount；//关键字的比较次数
intshiftCount;//关键字的移动次数
typedefstruct{
Typekeykey;
}Type；
typedefstruct｛
Typer［MAXSIZE+1］；//顺序表
intlength;
｝PList；//排序表
intOneTimeSqCreate（PList＆L）{//手动输入创建排序序列函数
intx，h；
for（x=1；1;x++）
{
cin>>h;
L.r［x].key=h；
if（getchar（）=='\n'）｛//只读入一行，换行则终止
break;
｝
｝
L.length=x；
｝
intManyTimeSqCreate（PList＆L,intm）｛//自动生成排序序列函数
L。
length=m;
for（intx=1；x<=m;x++）
｛
L.r［x］。
key=rand（）％m;//随机数的取值范围为0~k
｝
return1;
｝
voidBubbleSort（PList&L）｛//冒泡排序
inti，j，l,m=0，n=0；
for（i=1;i<=L。
length-1；++i）｛//只需要比较length-1次
for（j=1；j〈=L。
length-i；++j）｛//内层循环所谓的冒泡，将最大值放到末尾
++m；//比较次数
if（L.r［j］.key>L.r［j+1].key）{
l=L.r［j］。
key;
L。
r[j］。
key=L.r［j+1］.key；
L。
r［j+1]。
key=l；
n+=3；//关键字移动次数
｝
｝
}
cout〈”；
cout〈<"比较次数:
”〈cout<〈"交换次数:
”〈〈n<〈endl；
}
voidInsertSort（PList＆L）{//插入排序
inti,j,m=0,n=0；//m是比较次数,n是交换次数
cout<for（i=2；i〈=L。
length；++i）
if（L。
r［i].keyr［i—1].key）｛
++m；//比较次数加1
n+=3;//移动次数加3，按实验报告要求一次交换代表3次移动
L.r[0］=L.r［i］；//设置哨兵
L。
r[i］=L。
r［i—1];//后移一位
for（j=i—2；L.r［0].key〈L.r［j].key;--j）//一直找到该插入的位置
｛
++m；//
L。
r［j+1]=L.r[j]；//后移元素
｝
L.r［j+1]=L。
r［0］；//将哨兵也就是原来的L[i]插入序列
}
cout〈〈"直接插入排序：
”；
cout<<”比较次数:
"<〈m;
cout<<”交换次数:
”<〈n〈〈endl；
｝
voidSelectSort（PList&L）{//简单选择排序
intl，i,j,m=0,n=0;//m是比较次数，n是移动次数
cout〈〈endl；
for（i=1；ilength；++i）｛
L.r[0］=L。
r［i］;
j=i+1；//从j开始寻找最小元素
l=i;//l是最小元素的位置
for（j;j〈=L.length;++j）{
++m;//比较次数加1
if（L.r［0］.key>L.r[j］.key）｛//表明j处key值更小
l=j；//记录下j的值
L。
r［0]=L。
r[j]；
｝
}
if（l！
=i）｛//需要交换位置
n+=3；//移动次数加3,按实验报告要求一次交换代表3次移动
L。
r[l]=L.r［i]；
L。
r[i]=L.r［0];
｝
｝
cout〈<"简单选择排序:
";
cout<<"比较次数:
”〈〈m;
cout〈〈”交换次数:
”〈｝
intPartition（PList＆L，intlow,inthigh）{//一次快速排序
intpivotkey；//中间轴
L。
r[0］=L。
r[low];//记录轴元素
pivotkey=L。
r[low]。
key;//轴取low
while（low〈high）{
while（lowr[high］。
key>=pivotkey）｛
++compCount；//比较次数加1
—-high;//high左移
｝
shiftCount+=3;//移动次数加3，按实验报告要求一次交换代表3次移动
L。
r[low］=L.r［high］；//此时应当交换位置
while（low〈high＆&L.r［low].key〈=pivotkey）{
++compCount；//比较次数加1
++low;
}
shiftCount+=3;//移动次数加3,按实验报告要求一次交换代表3次移动
L。
r［high]=L.r[low];
｝
L.r［low］=L。
r[0］；//找到位置插入轴元素
returnlow；//返回位置
｝
voidQSort（PList&L，intlow，inthigh）｛//递归形式的快速排序算法
intPiv；//轴元素位置
if（lowPiv=Partition（L，low,high）;
QSort（L，low,Piv—1）;//左递归
QSort（L，Piv+1,high）；//右递归
}
｝
voidQuickSort（PList＆L）｛//快速排序
inti;
QSort（L,1，L。
length）；
cout<<"快速排序:
”；
cout〈<”比较次数：
”〈〈compCount；
cout<〈"交换次数：
"<〈shiftCount〈〈endl〈〈endl；
compCount=0；
shiftCount=0；
}
intmain（）{
inti，k，h,n，m；
PListL，alist,blist,clist，dlist；
cout〈<”-——————-排序模式选择——————--"〈〈endl；
cout<<”1。
手动输入待排序序列2.系统自动生成待排序序列:
";
cin>〉h;
if（h==1）｛//手动输入模式
OneTimeSqCreate（L）；
alist=blist=clist=dlist=L;
BubbleSort（L）;
InsertSort（alist）;
SelectSort（blist）；
QuickSort（clist）;
cout<〈”排序后序列：
"；
for（i=1；i<=L。
length;i++）
cout<<”"〈r［i］.key；
}
else{//自动生成模式
cout〈<”输入想要排序的测试组数n和表长m，程序会帮你生成随机序列：
"；
cin>〉n>>m；
k=1；
while（k++<=n）｛
cout〈〈endl〈〈"—-——-—第"〈〈k-1〈<”次排序——————"<〈endl；
ManyTimeSqCreate（L，m）；
alist=blist=clist=dlist=L;
BubbleSort（L）;
InsertSort（alist）;
SelectSort（blist）；
QuickSort（clist）；
｝
｝
return0；
｝
七、运行测试
1、手动输入递增序列123456789
1、手动输入递减序列987654321
3.生成随机序列8组,每一个测试序列的表长度为100
得到测试结果如下表所示
组数
1
2
3
4
排序算法
比较次数
交换次数
比较次数
交换次数
比较次数
交换次数
比较次数
交换次数
冒泡排序
4950
7827
4950
7623
4950
6930
4950
7407
直接插入排序
2609
273
2541
276
2310
270
2469
285
简单选择排序
4950
282
4950
282
4950
285
4950
291
快速排序
587
984
660
948
669
930
675
930
组数
5
6
7
8
排序算法
比较次数
交换次数
比较次数
交换次数
比较次数
交换次数
比较次数
交换次数
冒泡排序
4950
7467
4950
6654
4950
7194
4950
7479
直接插入排序
2489
291
2218
279
2398
288
2493
285
简单选择排序
4950
273
4950
273
4950
285
4950
273
快速排序
596
924
623
918
630
978
677
954
可以得到4种排序算法的平均比较和移动次数如下表
排序算法
平均比较次数
关键字平均移动次数
冒泡排序
4950
7216
直接插入排序
2398
282
简单选择排序
4950
279
快速排序
633
936
可以看出快速排序的平均比较次数最少，而直接插入排序和简单选择排序的平均移动次数最少，综合看来对于一般的无序序列，快速排序是这4种算法里面性能最优的一种.
八、实验总结
排序算法各有其适用的情况，应该具体问题具体分析.
冒泡排序重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来.选择排序的主要思想：
首先找到数组中最小的那个元素，其次,将它和第一个元素交换。
接下来找第二小和第二个交换.运行时间和输入无关，数据移动最少。
当数据量较小的时候适用。
直接插入排序时间复杂度为O（n^2），数据量小时使用.并且大部分已经被排序。
快速排序是最快的通用排序算法，在大多数实际情况中,快速排序是最佳选择.
升级会员 