对一些简单排序算法的效率比较

空闲时整理了一下关于排序算法的内容，写写也当作是复习吧。

在这里我列了六种排序算法，分别是冒泡，选择，插入，Shell，快排和堆排。因为只是强调算法和效率，所以都用一维数组的形式来验证了。

首先我们整理一下这几种算法的时间复杂度（第一个是平均情况，第二个是最坏情况）：

/*

冒泡排序 O(n^2) O(n^2)

选择排序 O(n^2) O(n^2)

插入排序 O(n^2) O(n^2)

希尔排序 O(n^1.5) O(n^2)

快速排序 O(nlogn) O(n^2)

堆排序 O(nlogn) O(nlogn)

*/

还有就是关于排序稳定性的比较。我们知道，若排序前有两个关键字相等的数据，在排序之后位置并没有相对变动，那么我们就称该种排序方式是稳定的。

据此我们可以把冒泡排序，插入排序归为稳定排序，而相应的，选择排序，Shell排序，快排和堆排都是不稳定排序。

对于如何合理地选择排序方法，我写了一段程序，针对一个大小为10000的随机数组进行排序，比较所需的时间。

代码如下：

#include<iostream>
#include<ctime>
#include<cstdlib>
#include<time.h>
using namespace std;

int a[10001];
void Infos(int size)//show the oeders
{
cout<<"--------------------------------------------"<<endl;
cout<<"intput order"<<endl;
cout<<"1 for Bubble sort_1"<<endl;
cout<<"2 for Bubble sort_2"<<endl;
cout<<"3 for Selection sort"<<endl;
cout<<"4 for Insertion sort"<<endl;
cout<<"5 for Shell sort"<<endl;
cout<<"6 for Quick sort"<<endl;
cout<<"7 for Heap sort"<<endl;
cout<<"--------------------------------------------"<<endl;
for(int i=0;i<size;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
cout<<"--------------------------------------------"<<endl;
}

void restore(int array[],int size)//restore the array
{
for(int i=0;i<size;i++)
{
array[i]=a[i];
}
}

void s_print(int array[],int size)//output function
{
for(int i=0;i<size;i++)
{
cout<<array[i]<<endl;
}
cout<<endl;
}

void exchange(int a,int b)
{
int temp;
temp=a;
a=b;
b=temp;
}
/**********************************************************/
//case 1:
void Bsort1(int array[],int size)//Bubble sort 1(fast)
{
int temp;
for(int i=0;i<size-1;i++)
{
for(int j=size-1;j>i;j--)
{
if(array[j]<array[j-1])
{
temp=array[j];
array[j]=array[j-1];
array[j-1]=temp;
}
}
}
//s_print(array,size);
}
/**********************************************************/
//case 2:
void Bsort2(int array[],int size)//Bubble sort 2(slow)
{
int temp;
for(int i=0;i<size-1;i++)
{
for(int j=0;j<size-1;j++)
{
if(array[j+1]<array[j])
{
temp=array[j+1];
array[j+1]=array[j];
array[j]=temp;
}
}
}
//s_print(array,size);
}
/**********************************************************/
//case 3:
void Ssort(int array[],int size)//Selection sort
{
int temp=array[0],m=0;
for(int i=0;i<size;i++)
{
for(int j=i;j<size;j++)
{
if(temp>array[j])
{
temp=array[j];
m=j;
}
}
array[m]=array[i];
array[i]=temp;
temp=array[i+1];
m=i;
m++;
}
//s_print(array,size);
}
/**********************************************************/
//case 4:
void Isort(int array[],int size)//Insertion sort
{
int temp,j;
for(int i=1;i<size;i++)
{
temp=array[i];
j=i-1;
while(j>=0&&temp<array[j])
{
array[j+1]=array[j];
j--;
}
array[j+1]=temp;
}
//s_print(array,size);
}
/**********************************************************/
//case 5:
void Sh_sort(int array[],int size)//Shell sort
{
int t,j,temp;
for(int t=size/2;t>=1;t/=2)
{
for(int i=t;i<size;i++)
{
temp=array[i];
j=i-t;
while(array[j]>temp&&j>=0)
{
array[j+t]=array[j];
j=j-t;
}
array[j+t]=temp;
}
}
//s_print(array,size);
}
/**********************************************************/
//case 6:
void Qsort(int array[],int left,int right)//Quick sort
{
int l,r,temp;
l=left;
r=right;
int p=(left+right)/2;             //确定比较的基准数
while(l<r)
{
while(array[l]<array[p])
{
l=l+1;
}
while(array[r]>array[p])
{
r=r-1;
}
if(l<r||l==r)
{
temp=array[l];
array[l]=array[r];
array[r]=temp;
r=r-1;
l=l+1;
}
}
if(l==r)
{
l=l+1;
}
if(left<r)                //递归
{
Qsort(array,left,r);
}
if(right>l)
{
Qsort(array,l,right);
}
//s_print(array,left+right+1);
}
/**********************************************************/
//case 7:
void Build_Heap(int array[],int i,int n)//按节点规律构造堆
{
int j,temp;
while(2*i+1<n)
{
j=2*i+1;
if(j+1<n)
{
if(array[j]<array[j+1])
{
j=j+1;
}
}
if(array[i]<array[j])
{
temp=array[i];
array[i]=array[j];
array[j]=temp;
i=j;
}
else
{
break;
}
}
}
void Hsort(int array[],int size)//Heap sort
{
int i,j,temp,m;
for(i=size/2-1;i>=0;i--)
{
Build_Heap(array,i,size);
}
//cout<<"初始堆"<<endl;
//s_print(array,size);
for(i=size-1;i>0;i--)
{
temp=array[0];
array[0]=array[i];
array[i]=temp;
m=0;
Build_Heap(array,m,i);
}
//s_print(array,size);
}

void Get_time_Bsort1(int a[],int size)
{
cout<<"Bubble sort(fast): "<<endl;
clock_t start,end;
double cpu_time;
srand(time(NULL));
for(int i=0;i<size;i++)
{
a[i]=rand();
}
start=clock();
Bsort1(a,size);
end=clock();
cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
cout<<"Run Time = "<<cpu_time<<endl;
cout<<"——————————————————"<<endl;
}
void Get_time_Bsort2(int a[],int size)
{
cout<<"Bubble sort(slow): "<<endl;
clock_t start,end;
double cpu_time;
srand(time(NULL));
for(int i=0;i<size;i++)
{
a[i]=rand();
}
start=clock();
Bsort2(a,size);
end=clock();
cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
cout<<"Run Time = "<<cpu_time<<endl;
cout<<"——————————————————"<<endl;
}
void Get_time_Ssort(int a[],int size)
{
cout<<"Selection sort: "<<endl;
clock_t start,end;
double cpu_time;
srand(time(NULL));
for(int i=0;i<size;i++)
{
a[i]=rand();
}
start=clock();
Ssort(a,size);
end=clock();
cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
cout<<"Run Time = "<<cpu_time<<endl;
cout<<"——————————————————"<<endl;
}
void Get_time_Isort(int a[],int size)
{
cout<<"Insertion sort: "<<endl;
clock_t start,end;
double cpu_time;
srand(time(NULL));
for(int i=0;i<size;i++)
{
a[i]=rand();
}
start=clock();
Isort(a,size);
end=clock();
cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
cout<<"Run Time = "<<cpu_time<<endl;
cout<<"——————————————————"<<endl;
}
void Get_time_Sh_sort(int a[],int size)
{
cout<<"Shell sort: "<<endl;
clock_t start,end;
double cpu_time;
srand(time(NULL));
for(int i=0;i<size;i++)
{
a[i]=rand();
}
start=clock();
Sh_sort(a,size);
end=clock();
cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
cout<<"Run Time = "<<cpu_time<<endl;
cout<<"——————————————————"<<endl;
}
void Get_time_Qsort(int a[],int size)
{
cout<<"Quick sort: "<<endl;
clock_t start,end;
double cpu_time;
srand(time(NULL));
for(int i=0;i<size;i++)
{
a[i]=rand();
}
start=clock();
Qsort(a,0,size-1);
end=clock();
cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
cout<<"Run Time = "<<cpu_time<<endl;
cout<<"——————————————————"<<endl;
}
void Get_time_Hsort(int a[],int size)
{
cout<<"Heap sort: "<<endl;
clock_t start,end;
double cpu_time;
srand(time(NULL));
for(int i=0;i<size;i++)
{
a[i]=rand();
}
start=clock();
Hsort(a,size);
end=clock();
cpu_time=((double)(end-start))/CLOCKS_PER_SEC;
cout<<"Run Time = "<<cpu_time<<endl;
cout<<"——————————————————"<<endl;
}
const int N=10000;
int main()
{
Get_time_Bsort1(a,N);
Get_time_Bsort2(a,N);
Get_time_Ssort(a,N);
Get_time_Isort(a,N);
Get_time_Sh_sort(a,N);
Get_time_Qsort(a,N);
Get_time_Hsort(a,N);
}

运行之后，结果如下：



所以在面对数据大的随机数列时，应采用堆排，快排这种时间复杂度为O(nlogn)的算法，而数据量小时，可采用插入排序或选择排序法。

P.S:没有FP坑啊······