排序算法的实现与性能比较.docx
《排序算法的实现与性能比较.docx》由会员分享，可在线阅读，更多相关《排序算法的实现与性能比较.docx（28页珍藏版）》请在冰豆网上搜索。
排序算法的实现与性能比较
排序算法的实现与性能比较
一．算法原理和代码
1．快速排序
快速排序采用分区的方法，在每次调用分区函数后根据返回的分区标号将待排序数组分成了两个部分，前半部分小于分区标号上的数值，后半部分大于分区标号上的数值，然后再递规调用分区函数将前半部分分区，后半部分分区。
其基本步骤可描述为：
分区：
将数组的最后一个数值作为标准，设置两个指针，一个指向小于标准的最后一个数，另外一个从数组开头到标准的前一个位置扫描整个数组，如果小于标准，就将第一个指针加一，并交换两个数，保证第一个指针所指之前和其所指的数都小于标准，完成扫描后将交换第一个指针的下一个位置和标准，然后返回标准的位置标号。
求解：
返回后调用SORT函数根据标号将数组分成两个部分，而后递规调用分区函数和SORT函数，直到数组的末标号小于等于头标号。
返回：
从最后调用依次返回后，左右两个数组已有序。
算法代码：
/*快速排序*/
#include
#include
voidquicksort（float*p,longf,longn）
{longq;
longpartition（float*,long,long）;
if（f{q=partition（p,f,n）;
quicksort（p,f,q-1）;
quicksort（p,q+1,n）;
}
return;
}
longpartition（float*p,longf,longn）
{floattemp,t=p[n];
longb,a=f-1;
for（b=f;b{if（p[b]<=t）
{a++;
temp=p[b];
p[b]=p[a];
p[a]=temp;
}
}
temp=p[a+1];
p[a+1]=p[n];
p[n]=temp;
returna+1;
}
2．冒泡排序
将数组垂直放置，设置两个指针a,b，a作用为指示比较次数，b扫描数组。
开始时a指向数组首位置，知道末位置的前一位置，因为只要比较N-1次，N为数组元素的个数，b从数组末尾前一个位置从下往上扫描，将大的数外下沉，小的数往上浮起，知道b所指位置等于a的。
算法代码：
/*冒泡排序*/
#include
#include
voidbubbleway（float*p,longn）
{floatt;
longi,j;
for（i=0;i{for（j=n-2;j>=i;j--）
{if（p[j]>p[j+1]）
{t=p[j];
p[j]=p[j+1];
p[j+1]=t;
}
}
}
return;
}
3．桶排序算法
根据待排序的数值，创建0－10的11个桶空间，并且依次编号为1，2…10号桶，每个桶空间的大小设定为100000，设置指针a从头到尾扫描整个数组，并且依次将各个元素加入到对应的桶中，在根据桶标号对各个桶进行排序，而后将排序结果根据桶标号进行联接。
算法代码：
/*桶排序*/
#ifndefBARREL_H
#defineBARREL_H
typedefstructbarrel
{
float*key;
longcount;
}barr;
voidbarrelway（float*p,longn）;
voidinitbar（barr*bar,intn）;
#endif
longSIZE=10;
#include
#include
#include"d:
\p1\barrel.h"
voidbarrelway（float*p,longn）
{
longi;
longj;
longd;
intid;
barrbar[11];
initbar（bar,11）;
for（i=0;i{id=（int）（10*p[i]）;
j=bar[id].count++;
bar[id].key[j]=p[i];
}
for（i=0;i<11;i++）
{if（bar[i].count!
=0）
{quicksort（bar[i].key,0,bar[i].count-1）;}
}
for（i=0,d=0;i<11;i++）
{longk=0;
while（bar[i].count&&k{p[d++]=bar[i].key[k++];
}
}
}
voidinitbar（barr*bar,intn）
{inti;
for（i=0;i{bar[i].key=calloc（SIZE,sizeof（float））;
bar[i].count=0;
}
return;
}
4．插入排序
设置指针a指向已排序的末位置，a初始指向数组第一个位置，设置指针b初始指向数组的第二个位置，比较指针b所指的数与指针a所指的数的大小，大于则两者同时加一，小于则将b所指的数依次与已排序的数比较，并插入到对应位置上，而后a,b同时加一。
算法代码：
/*插入排序*/
#include
#include
voidinsertway（float*p,longn）
{longi;
for（i=1;i{if（p[i]{floatt=p[i];
longj=i-1;
do{p[j+1]=p[j];
j--;
}while（tp[j+1]=t;
}
}
}
5．希尔排序
与插入排序相近，不同的是设置了步进量，步进量小于数组的长度，开始时先选取步进量，步进量整数倍的数组元素为一个组，对这个组内的数进行插入排序，而后按一定的数值减小步进量，重复上述步骤，当步进量为一时，所有的数都在一个组内，只需作少量的调整就可有序。
算法代码：
/*希尔排序*/
#include
#include
voidshellsort（float*p,longn）
{voidshellinsert（float*p,longi,longn）;
longi=5;
for（;i>=1;i-=2）
{shellinsert（p,i,n）;
}
}
voidshellinsert（float*p,longi,longn）
{longj;
for（j=i;j{if（p[j]{floatt=p[j];
longm=j-i;
do{p[m+i]=p[m];
m-=i;
}while（m>=0&&tp[m+i]=t;
}
}
}
6．合并排序
采用分解的方法，当数组的每个元素都为一组时有序，而后依次两两归并，得到的数组个数为N/2，再两两归并，直到数组个数为一，则为有序。
算法代码：
/*合并排序*/
#include
#include
#include
voidmergeway（float*p,longn,longm）
{longt;
voidmerge（float*p,longn,longt,longm）;
if（n{if（m-n==1）
{merge（p,n,n,m）;
return;
}
t=（long）（（m+n）/2）;
mergeway（p,n,t）;
mergeway（p,t+1,m）;
merge（p,n,t,m）;
}
return;
}
voidmerge（float*p,longn,longt,longm）
{
longi=n,j=t+1,k=n;
float*p1=calloc（m-n+1,sizeof（float））;
if（m-n==1）
{floattemp;
if（p[n]>p[m]）
{temp=p[n];
p[n]=p[m];
p[m]=temp;
}
free（p1）;
return;
}
for（;i<=m;i++）
{p1[i]=p[i];
}
i=n;
while（i<=t&&j<=m&&k<=m）
{if（p1[i]<=p1[j]）
{p[k++]=p1[i++];
}
else
{p[k++]=p1[j++];}
}
while（i<=t&&k<=m）
{p[k++]=p1[i++];
}
while（j<=m&&k<=m）
{p[k++]=p1[j++];
}
free（p1）;
return;
}
二．实验结果
1．N=10时，排序结果。
2．N=1000，10000，100000时，对同一个样本实例，不同排序完成所需的时间。
N=1000
N=10000
N=100000
3．N=1000，10000，100000时，每个排序用不同的样本多试验几次（最低5次）得出平均时间，比较不同排序算法所用的平均时间。
N=1000
N=10000
N=100000
三．排序性能
快速排序的时间复杂度为O（nlgn）,冒泡排序的时间复杂度为O（n2）,插入排序的时间复杂度为O（n^2）,希尔排序时间复杂度为O（n^1.25）,桶排序的时间复杂度为O（n），归并排序时间复杂度为O（nlgn）。
从实验结果可以看出，快速排序效率最高，桶排序、归并排序和希尔排序效率会差些，插入排序效率低些，冒泡排序效率最差。
升级会员 