本文通过大量随机数列和不同数据场景，对八种排序算法（包括插入、希尔、冒泡、快速、选择和堆排序）进行了性能比较，揭示了各种算法在不同数列状态下的优劣，特别强调了快排的平均时间复杂度最低。
排序算法性能的比较
注: 由于只是测试算法性能, 所以不会对排序算法做深入讲解, 在随后的时间将会推出排序的详细讲解
问题需求分析
排序算法经过了很长时间的演变，产生了很多种不同的方法。每种算法主要针对不同的数列进行排序，这些排序算法具有各自的利弊，并且应用的场景各自不同，为了针对不同的场景选出最合适的排序算法，接下来将使用大量随机数列，以及不同的数据场景对不同的排序算法进行比较，最终找出排序算法各自的优缺点以及不同应用的场景。
数据结构定义
选用8种不同乱序的数列，每种数列使用6组不同的数列进行测试，每组数列大小在500左右(若数据量太小不能明显测试，将会修改为更大的数据)。
测试系统功能设计及排序算法原理概述
随机数产生函数:总共有8中乱序数据, 其中两组是属于正序与反序状态, 这两种状态直接通过排序函数获得, 剩余6种状态采用的方法是通过设定随机数范围n,m控制随机数整体体现一个升序或者是降序的状态, 但是局部出现的就是部分无序, 所以就可以限定数列有序的状态
插入排序: 1.获得一个数, 就去数组从数组末尾比较直达找这个数合适的位置, 2.重复1中的步骤, 直到所有数在数组中都没找到一个合适的位置.
希尔排序: 原理与插入排序的效果一样, 插入排序每次从数组中选的数总是依次选, 选取的数间隔是1, 而希尔排序每次总是按照一定的间隔选取数, 就比如第一次选n/2, 第二次选n/4, 直到选间隔数为1, 此时的希尔排序就只是单纯的插入排序, 但是与插入排序不同的, 当处理大量数据且数据一定程度上有序, 相比于插入排序, 希尔排序的速度将会是极大的提升.
冒泡排序: 1.遍历整个数组, 相邻之间的数不断比较, 直到数组中最大(最小)的数移动到数组的末尾(开头). 2.重复1中步骤, 直到所有数都能在数组中(局部)变为最大或最小的数.
快速排序: 1.遍历数组, 从右往左, 找比基准元素小的元素A, 同时从左往右, 找比基准元素大的元素B, 若找到则交换A,B的位置(此时i,j下标还没碰头), 当i,j碰头的时候, i,j对应的下标就是基准元素的位置, 此时将基准元素与i,j下标的元素交换, 这样的一轮循环就完成了一个元素的寻找. 2.递归往下寻找, 以刚才找到的元素位置作为分界线, 二分再次进行查找, 重复1中步骤.(1中的查找方式, 为步骤2二分操作打下基础, 每次基准元素(此时的基准元素已经找到了合适的位置)左边的元素总是会比右边的元素小)
选择排序: 1.遍历数组, 找到数组中最大(最小)元素的位置, 然后交换该元素与数组末尾(开头)的元素, 一趟遍历就能找到一个元素的合适位置. 2.重复1中步骤, 直达所有元素都能找到自己合适的位置.
堆排序: 1.根据父节点与左右子树下标的关系(左节点:2i,右节点:2i+1)遍历数组, 比较左右节点, 父节点之间的大小关系, 3个元素中找出最小(最大)的元素作为父节点(存在父节点与子节点之间顺序的交换), 此时局部的子树就构建成小顶堆(大顶堆). 2.进行size/2次循环执行步骤1, 使得能构建大顶堆(小顶堆). 3.在构建出大顶堆(小顶堆)的基础上, 拿出最大数(最小数)(这里的做法是, 将root处的值与数组末尾的值(叶子节点, 下标j–, 排好序的数列就不能打乱哦)交换), 剩下数再进行1中步骤, 此处类似于选择, 在构建好的大顶堆(小顶堆)中拿出最大(最小)值. 4.重复3中步骤, 直到所有数都找出来.
函数调用图
测试样例数据:
Level取值如下(5,6,7属于整体逆序的状态):1:正序; 2:有点乱; 3:乱的比较多; 4:完全随机; 5:乱的比较多; 6:有点乱; 7:逆序 ;8:正序 ;测试数据量为400.
结论分析
从上面这个表来看, 当数量已经是正序的时候采用冒泡排序是最快; 在逆序的状态下还是采用快速排序, 若要求数列稳定性, 应该采用选择排序; 在整体处于正序的时候使用冒泡, 选择排序都是有优势的; 而整体处于逆序的时候还是选择排序和快速排序; 当数列完全逆序的时候, 选择快速排序是最好的; 从上面整体来看, 快排的平均时间复杂度最低, 堆排序平均时间复杂度最高, 冒泡, 插入, 选择时间复杂度差不多, 而希尔排序在大量数据的时候优于插入排序.
调试代码存在的问题
1.构建随机函数的时候, 由于n, m参数没有控制好, 导致出现的数列具有一定的误差, 这个问题只用通过大量的参数测试, 直到找出最合适的n与m.
2.进行希尔排序的时候, 我选用的间隔是 n/=2, 每次选取的间隔数自动缩短为1/2, 但是也导致了一个问题就是, 到最后n的值可能是0, 由此导致希尔排序出现死循环, 这个问题调试了好一会, 才发现, 在这一次的调试中, 更加深入理解了希尔排序的真谛, 其他排序也一样,写的过程中, 也存在许多问题, 大部分问题最终还是体现在对排序算法的不熟悉导致, 由于没有弄清楚排序的真正机制, 所以也就导致太多不应该犯的错误.
完整代码
#include<iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
const long Size=400;
//所有元素的0号位都是临时元素
void show(int a[],int size){
for(int i=1;i<size;i++){
cout<<a[i]<<" ";
if((i+1)%20==0)cout<<endl;
}
}
//插入排序
void insertSort(int a[],int size, int &cs, int &ss){
int i,j;
for(i=1;i<size;i++){
a[0]=a[i];
j=i-1;
while(true){
//临时元素从数列末尾-1进行比较，直到遇到比他小的停止
++cs;
if(a[0]<a[j]){
//移动过程中出现交换
++ss;
a[j+1]=a[j--];
}else break;
}
//找到比他小的元素，进行交换
++ss;
a[j+1]=a[0];
}
}
//希尔排序
void shellSort(int a[],int size, int &cs, int &ss){
int i,j,dk=size/25;
while(dk > 0){
dk /= 2;
if(dk > 0 && dk < 10) dk = 1;
for(i = dk; i < size; i++){
++cs;
if(a[i] < a[i-dk]){
a[0] = a[i];
j = i-dk;
++cs;
while(a[0] < a[j]){
++ss;
a[j+dk] = a[j];
j -= dk;
}
++ss;
a[j+dk] = a[0];
}
}
}
}
//冒泡排序
void bubbleSort(int a[],int size, int &cs, int &ss){
int flag=0;
for(int i=1;i<size;i++){
flag=1;
for(int j=1;j<size-i;j++){
++cs;
if(a[j]>a[j+1]){
++ss;
a[0]=a[j];a[j]=a[j+1];a[j+1]=a[0];
flag=0;
}
}
if(flag==1)break;
}
}
//快速排序
void quickSort(int a[],int l,int r, int &cs, int &ss){
if(l>r)return;
int i=l,j=r,t;a[0]=a[l];
++cs;
while(i!=j){
++cs;
while(a[0]<=a[j]&&i<j){
j--;
}
++cs;
while(a[0]>=a[i]&&i<j){
i++;
}
++cs;
if(i<j){
++ss;
t=a[i];a[i]=a[j];a[j]=t;//左右两边的值交换
}
}
++ss;
a[l]=a[i];a[i]=a[0];//基数的交换
quickSort(a,l,i-1, cs, ss);
quickSort(a,i+1,r, cs, ss);
}
//选择排序
void selectSort(int a[],int size, int &cs, int &ss){
int i,j,k;
for(i=1;i<size;i++){
k=i;
for(j=i;j<size;j++){
++cs;
if(a[k]>a[j])k=j;
}
++cs;
if(k!=i){
++ss;
a[0]=a[k];a[k]=a[i];a[i]=a[0];
}
}
}
//建堆操作
void heapAdjust(int a[],int i,int n, int &cs, int &ss){//建立大顶堆
int temp;//将局部最小的树变为堆
temp=a[i];
for(int j=i*2;j<=n;j++){//for循环主要针对局部子树的调整,
//将左右子树中大值往前调整
++cs;
if(j<n&&a[j]<a[j+1])j++;//左右子树进行比较
++cs;
if(temp>=a[j])break;
++ss;
a[i]=a[j];//与根节点进行交换
i=j;//i原本为j的root,现在j向子树深入,root进行改变
//i变为j
}
++ss;
a[i]=temp;
}
//堆排序
void heapSort(int a[],int size, int &cs, int &ss){
for(int i=size/2;i>0;i--)
heapAdjust(a,i,size, cs, ss);
for(int j=size;j>1;j--){
//每调整一下,就将root与最远的叶子进行交换
//此处的root为最大值
++ss;
a[0]=a[1];a[1]=a[j];a[j]=a[0];
heapAdjust(a,1,j-1, cs, ss);
}
}
//生成随机数,level代表乱序程度
控制m, n取值范围, 可有效控制随机数混乱程度
1 5个数中取随机数
2 10 中取随机数
3 完全随机
4 完全随机
5 10个取随机数
6 5个取随机数
7 逆序
**/
void createSrand(int a[],int size, int level){
int m, n;
if(level < 5){
m = 0; n = 50;
}else{
m = 3951; n = 4001;
}
srand((unsigned)time(NULL));
// rand()%(n-m+1)+m, [m,n]范围内的随机数
for(int i= 0; i < size;i++ ){
if(level == 1){
m += 10;
n += 10;
}else if(level == 2){
m += 5;
n += 7;
}else if(level == 4){
m = 0;
n = 4001;
}else if(level == 4){
m = 0;
n = 4001;
}else if(level == 5){
m -= 5;
n -= 7;
}else if(level == 6){
m -= 10;
n -= 10;
}else if(level == 7){
int flag=0;
for(int i=1;i<size;i++){
flag=1;
for(int j=1;j<size-i;j++){
if(a[j]<a[j+1]){
a[0]=a[j];a[j]=a[j+1];a[j+1]=a[0];
flag=0;
}
}
if(flag==1)break;
}
// show(a, size);
return;
}else if(level == 8){
int i = 0;
quickSort(a, 1, Size-1, i, i);
// show(a, size);
return;
}
a[i]=rand()%(n-m+1)+m;
}
// show(a, size);
}
//性能测试函数
void testLevel(int a[], int size){
int cs, ss;
for(int i = 1; i < 9; i++){
cs = 0, ss = 0;
createSrand(a, size, i);
cout<<"Level="<<i<<" insertSort:";
insertSort(a,Size,cs,ss);
cout<<" cs="<<cs<<" ss="<<ss<<endl;
cout<<"-----------------------------------------------------------\n"<<endl;
cs = 0, ss = 0;
createSrand(a,Size,i);
cout<<"Level="<<i<<" shellSort:";
shellSort(a,Size,cs,ss);
cout<<" cs="<<cs<<" ss="<<ss<<endl;
cout<<"-----------------------------------------------------------\n"<<endl;
cs = 0, ss = 0;
createSrand(a,Size,i);
cout<<"Level="<<i<<" bubbleSort:";
bubbleSort(a,Size,cs,ss);
cout<<" cs="<<cs<<" ss="<<ss<<endl;
cout<<"-----------------------------------------------------------\n"<<endl;
cs = 0, ss = 0;
createSrand(a,Size,i);
cout<<"Level="<<i<<" quickSort:";
quickSort(a,1,Size-1,cs,ss);
cout<<" cs="<<cs<<" ss="<<ss<<endl;
cout<<"-----------------------------------------------------------\n"<<endl;
cs = 0, ss = 0;
createSrand(a,Size,i);
cout<<"Level="<<i<<" selectSort:";
selectSort(a,Size,cs,ss);
cout<<" cs="<<cs<<" ss="<<ss<<endl;
cout<<"-----------------------------------------------------------\n"<<endl;
cs = 0, ss = 0;
createSrand(a,Size,i);
cout<<"Level="<<i<<" heapSort:";
heapSort(a,Size-1,cs,ss);
cout<<" cs="<<cs<<" ss="<<ss<<endl;
cout<<"-----------------------------------------------------------\n"<<endl;
}
}
int main(){
int a[Size];
testLevel(a, Size);
return 0;
}
扫一扫
1130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
