各种内排序算法的实现及性能比较.docx
《各种内排序算法的实现及性能比较.docx》由会员分享，可在线阅读，更多相关《各种内排序算法的实现及性能比较.docx（29页珍藏版）》请在冰豆网上搜索。
各种内排序算法的实现及性能比较
实验报告
（/学年第一学期）
课程名称
数据结构A
实验名称
各种内排序算法的实现及性能比较
实验时间
年
月
日
指导单位
指导教师
学生姓名
班级学号
学院（系）
专业
实验名称
各种内排序算法的实现及性能比较
指导教师
实验类型
上机
实验学时
2
实验时间
一、实验目的和要求
实验目的：
1、理解和掌握各种排序算法。
2、学会比较排序方法的性能。
内容和要求：
1、验证教材中的各种排序算法。
2、分析各种排序算法的时间复杂度。
3、改进教材中的快速排序算法，使得当子集合小于10个元素时改用直接插入排序。
4、使用随机数发生器产生大数据集合，运行上述各排序算法，使用系统时钟测量各算法所需的实际时间，并进行比较。
二、实验环境（实验设备）
硬件：
PC
软件：
Code:
:
Blocks（C++）
三、实验原理及内容
1、核心算法及思路
改进后的快速排序算法：
思路：
在原来快速排序算法的基础上加上一个if语句，当子集集合小于10个元素时改用直接插入排序，即（right-left+1）<10时改用直接插入排序。
代码：
template
voidInsertSort_2（TA[],intleft,intright）//用于改进快速排序的直接插入排序
{
for（inti=left+1;i{
intj=i;
Ttemp=A[i];
while（j>0&&temp{
A[j]=A[j-1];
j--;
}
A[j]=temp;
}
}
template
voidQSort_2（TA[],intleft,intright）
{
if（left{
if（（right-left+1）>=10）
{
inti,j;
i=left;
j=right+1;
do
{
do{i++;}while（A[i]do{j--;}while（A[j]>A[left]）;
if（i{
Swap（A[i],A[j]）;
}
}while（iSwap（A[left],A[j]）;
QSort_2（A,left,j-1）;
QSort_2（A,j+1,right）;
}
else
{
InsertSort_2（A,left,right）;
}
}
}
template
voidQuickSort_2（TA[],intn）//改进后的快速排序
{
QSort_2（A,0,n-1）;
}
生成数组的函数：
思路：
为了方便检验各个排序的性能，设置生成三种数组——顺序、逆序和随机数组，在生成随机数组中用rand函数来实现。
代码：
template
T*Produce（intchoose）//生成数组（顺序、逆序、随机）
{
T*p=newT[N];
switch（choose）
{
case1:
for（inti=0;i{
p[i]=i;
}break;
case2:
for（inti=0;i{
p[i]=N-1-i;
}break;
case3:
srand（time（NULL））;
for（inti=0;i{
p[i]=rand（）%N;
}break;
default:
cout<<"error!
"<}
returnp;
}
计算各个排序的时间的函数（以计算简单选择排序的时间为例）
思路：
设计计算的时间是数组元素个数为2000、重复进行100次的时间，用clock函数记录时间，time=（double）（finish-start）/CLOCKS_PER_SEC，以此得出时间间隔。
代码：
template
doubleSelectSort_time（intchoose）//计算简单选择排序的时间
{
T*A;
srand（time（NULL））;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
SelectSort（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
2、程序流程图：
3、完整代码：
#include
#include
#include
#include
usingnamespacestd;
constintN=20;
template
voidSwap（T&a,T&b）
{
Ttemp=a;
a=b;
b=temp;
}
template
voidSelectSort（TA[],intn）//简单选择排序
{
ints;
for（inti=0;i{
s=i;
for（intj=i+1;j{
if（A[j]{
s=j;
}
}
Swap（A[i],A[s]）;
}
}
template
voidInsertSort（TA[],intn）//直接插入排序
{
for（inti=1;i{
intj=i;
Ttemp=A[i];
while（j>0&&temp{
A[j]=A[j-1];
j--;
}
A[j]=temp;
}
}
template
voidBubbleSort（TA[],intn）//冒泡排序
{
inti,j,last;
i=n-1;
while（i>0）
{
last=0;
for（j=0;j{
if（A[j+1]{
Swap（A[j],A[j+1]）;
last=j;
}
}
i=last;
}
}
template
voidQSort（TA[],intleft,intright）
{
inti,j;
if（left{
i=left;
j=right+1;
do
{
do{i++;}while（A[i]do{j--;}while（A[j]>A[left]）;
if（i{
Swap（A[i],A[j]）;
}
}while（iSwap（A[left],A[j]）;
QSort（A,left,j-1）;
QSort（A,j+1,right）;
}
}
template
voidQuickSort（TA[],intn）//快速排序
{
QSort（A,0,n-1）;
}
template
voidInsertSort_2（TA[],intleft,intright）//用于改进快速排序的直接插入排序
{
for（inti=left+1;i{
intj=i;
Ttemp=A[i];
while（j>0&&temp{
A[j]=A[j-1];
j--;
}
A[j]=temp;
}
}
template
voidQSort_2（TA[],intleft,intright）
{
if（left{
if（（right-left+1）>=10）
{
inti,j;
i=left;
j=right+1;
do
{
do{i++;}while（A[i]do{j--;}while（A[j]>A[left]）;
if（i{
Swap（A[i],A[j]）;
}
}while（iSwap（A[left],A[j]）;
QSort_2（A,left,j-1）;
QSort_2（A,j+1,right）;
}
else
{
InsertSort_2（A,left,right）;
}
}
}
template
voidQuickSort_2（TA[],intn）//改进后的快速排序
{
QSort_2（A,0,n-1）;
}
template
voidMerge（TA[],inti1,intj1,inti2,intj2）//两路合并排序
{
T*Temp=newT[j2-i1+1];
inti=i1,j=i2,k=0;
while（i<=j1&&j<=j2）
{
if（A[i]<=A[j]）
{
Temp[k++]=A[i++];
}
else
{
Temp[k++]=A[j++];
}
}
while（i<=j1）
{
Temp[k++]=A[i++];
}
while（j<=j2）
{
Temp[k++]=A[j++];
}
for（i=0;i{
A[i1++]=Temp[i];
}
delete[]Temp;
}
template
voidMergeSort（TA[],intn）
{
inti1,j1,i2,j2;
intsize=1;
while（size{
i1=0;
while（i1+size{
i2=i1+size;
j1=i2-1;
if（i2+size-1>n-1）
{
j2=n-1;
}
else
{
j2=i2+size-1;
}
Merge（A,i1,j1,i2,j2）;
i1=j2+1;
}
size*=2;
}
}
template
voidAdjustDown（TA[],intr,intj）
{
intchild=2*r+1;
Ttemp=A[r];
while（child<=j）
{
if（（child{
child++;
}
if（temp>=A[child]）
{
break;
}
A[（child-1）/2]=A[child];
child=2*child+1;
}
A[（child-1）/2]=temp;
}
template
voidHeapSort（TA[],intn）//堆排序
{
for（inti=（n-2）/2;i>-1;i--）
{
AdjustDown（A,i,n-1）;
}
for（inti=n-1;i>0;i--）
{
Swap（A[0],A[i]）;
AdjustDown（A,0,i-1）;
}
}
template
T*Produce（intchoose）//生成数组（顺序、逆序、随机）
{
T*p=newT[N];
switch（choose）
{
case1:
for（inti=0;i{
p[i]=i;
}break;
case2:
for（inti=0;i{
p[i]=N-1-i;
}break;
case3:
srand（time（NULL））;
for（inti=0;i{
p[i]=rand（）%N;
}break;
default:
cout<<"error!
"<}
returnp;
}
template
doubleSelectSort_time（intchoose）//计算简单选择排序的时间
{
T*A;
srand（time（NULL））;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
SelectSort（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
template
doubleInsertSort_time（intchoose）//计算直接插入排序的时间
{
T*A;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
InsertSort（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
template
doubleBubbleSort_time（intchoose）//计算冒泡排序的时间
{
T*A;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
BubbleSort（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
template
doubleQuickSort_time（intchoose）//计算快速排序的时间
{
T*A;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
QuickSort（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
template
doubleQuickSort_2_time（intchoose）//计算改进后的快速排序的时间
{
T*A;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
QuickSort_2（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
template
doubleMergeSort_time（intchoose）//计算两路合并排序的时间
{
T*A;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
MergeSort（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
template
doubleHeapSort_time（intchoose）//计算堆排序的时间
{
T*A;
doubletime;
clock_tstart,finish;
start=clock（）;
for（inti=0;i<100;i++）
{
A=Produce（choose）;
HeapSort（A,N）;
delete[]A;
}
finish=clock（）;
time=（double）（finish-start）/CLOCKS_PER_SEC;
returntime;
}
template
voidPrint（T*A）//输出数组的函数
{
for（inti=0;i{
cout<}
cout<}
voidmenu_1（）
{
cout<<"欢迎使用内排序算法的实现及性能比较系统！
"<cout<<"1、简单选择排序"<cout<<"2、直接插入排序"<cout<<"3、冒泡排序"<cout<<"4、快速排序"<cout<<"5、改进后的快速排序"<cout<<"6、两路合并排序"<cout<<"7、堆排序"<}
voidmenu_2（）
{
cout<<"您想检验什么？
"<cout<<"1、各个排序是否可行"<";
}
voidchildmenu_1（）
{
cout<<"1、最好的情况（顺序数组）"<cout<<"2、最差的情况（逆序数组）"<cout<<"3、平均的情况（随机数组）"<cout<";
}
intmain（）
{
charflag='Y';
while（flag=='Y'||flag=='y'）
{
system（"cls"）;
menu_1（）;
intchoose;
menu_2（）;
cin>>choose;
if（choose==1）
{
intnumber;
cout<";
cin>>number;
int*A=Produce（3）;
cout<<"排序前：
";
Print（A）;
switch（number）
{
case1:
SelectSort（A,N）;break;
case2:
InsertSort（A,N）;break;
case3:
BubbleSort（A,N）;break;
case4:
QuickSort（A,N）;break;
case5:
QuickSort_2（A,N）;break;
case6:
MergeSort（A,N）;break;
case7:
HeapSort（A,N）;break;
}
cout<";
Print（A）;
}
elseif（choose==2）
{
system（"cls"）;
menu_1（）;
intfirst,second;
doubletime;
cout<<"请输入想要检验的排序的编号：
";
cin>>first;
cout<childmenu_1（）;
cin>>second;
switch（first）
{
case1:
time=SelectSort_time（second）;
cout<<"用时：
"<case2:
time=InsertSort_time（second）;
cout<<"用时：
"<case3:
time=BubbleSort_time（second）;
cout<<"用时：
"<case4:
time=QuickSort_time（second）;
cout<<"用时：
"<case5:
time=QuickSort_2_time（second）;
cout<<"用时：
"<case6:
time=MergeSort_time（second）;
cout<<"用时：
"<case7:
time=HeapSort_time（second）;
cout<<"用时：
"<default:
cout<<"输入有误！
"<}
}
else
{
cout<<"输入有误！
"<}
cout<<"是否继续使用？
（Y/N）";
cin>>flag;
}
}
4、测试用例和结果：
1、将N改为20检验各个排序算法的可行性（以改进后的快速排序为例）：
2、将N改为2000检验用各个排序排随机数组的性能
四、实验小结（包括问题和解决方法、
升级会员 