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

空闲时整理了一下关于排序算法的内容，写写也当作是复习吧。
在这里我列了六种排序算法，分别是冒泡，选择，插入，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坑啊······