计数排序，基数排序，桶排序和快速排序算法时间对比

//桶排序
#include <iostream>
#include <ctime>
#include <boost/timer/timer.hpp>
using namespace std;
using namespace boost::timer;

typedef struct node{//数组联合指针的节点
int value;
node *next;
}node ,*pNode;

void find_max_min(int *a,int &max,int &min,int n)//查找最大值
{
max=a[0],min=a[0];//寻找最大最小值
for(int i=1;i<n;++i){
if(max<a[i]){
max=a[i];
}else if(min>a[i]){
min=a[i];
}
}
}

void inserting_sort(node *c,int b)
{//c是带插入的桶，b是待插入的节点
//node *cur=c;
node *inse=new node;//为b元素生成一个节点
inse->value=b;
if(c->next==NULL){
c->next=inse;
inse->next=NULL;
}else{
while (c->next!=NULL){
c=c->next;
}
inse->next=c->next;
c->next=inse;
}
}

void bucket_sort(int *a,int n)//桶排序
{
int max,min;
find_max_min(a,max,min,n);//找出节点的最大最小值

int count=max-min+1;
pNode *c=new pNode[count];//生成count个桶
for(int i=0;i<count;++i){
c[i]=new node;
c[i]->value=min+i;//存储值,正负数同等对待处理,每个桶的初始值
c[i]->next=NULL;//置空
}
int index;
for(int i=0;i<n;++i){
index=floor(a[i]);
inserting_sort(c[index-min],a[i]);
}

node *ptr;//控制指针
node *pDl;//删除节点指针
int k=0;
for(int i=0;i<count;++i){
ptr=c[i]->next;
pDl=c[i];
while (ptr!=NULL){
a[k++]=ptr->value;
pDl=ptr;//删除元素的指针
ptr=ptr->next;
delete pDl;
}
}
delete [] c;
}

void same_elem_quick_sort(int *a,int low,int high)//考虑相同元素的情况
{
if(low<high){
int pivot=a[low];
int i=low,h=low;
for(int j=low+1;j<high;++j){
if(a[j]<pivot){
int y=a[j];
a[j]=a[h+1];
a[h+1]=a[i];
a[i]=y;
++h,++i;
}else if(a[j]==pivot){
int y=a[j];
a[j]=a[h+1];
a[h+1]=y;
++h;
}
}
same_elem_quick_sort(a,low,i);
same_elem_quick_sort(a,h+1,high);
}
}

int max_bit(int max,int min)//返回基数排序的最大位数
{
int bits=1;
while ((max/10)||(min/10)){//考虑为负数的情况
bits++;
max/=10,min/=10;
}
return bits;
}

void counting_sort(int *a,int *b,int n)//计数排序
{
int min,max;
find_max_min(a,max,min,n);//寻找最大最小值
int count=max-min+1;//计算c数组的大小
int *c=new int[count];
memset(c,0,count*sizeof(int));//初始化为0

for(int i=0;i<n;++i){
c[a[i]-min]++;//个数加1
}

for(int i=1;i<count;++i){
c[i]+=c[i-1];
}

for(int i=n-1;i>=0;--i){
b[c[a[i]-min]-1]=a[i];//c数组从0开始，但是值可正可负
c[a[i]-min]--;        //所以要将最小值的下标调整到0.
}
delete[]c;
}

void radix_sort(int *a,int n)//基数排序
{
int min,max;//存储最大最小值
find_max_min(a,max,min,n);//寻找最大最小值
int bits=max_bit(max,min);//返回基数排序最大循环次数
int radix=1;
int *s=new int
;//存储每轮的数据
int *b=new int
;//存储每轮排序后的数据，并将其转移到a中
for(int i=0;i<bits;++i,radix*=10){

//for(int i=0;i<n;++i){//输出每轮基数排序后a数组的值
//	cout<<a[i]<<"\t";
//}
//cout<<endl;

for(int j=0;j<n;++j){
s[j]=(a[j]/radix)%10;//存储a的每位数据
//cout<<s[j]<<"\t";
}
//cout<<endl;
find_max_min(s,max,min,n);//早出s数组中的最大最小值
int count=max-min+1;//计算c数组的大小
int *c=new int[count];
memset(c,0,count*sizeof(int));//初始化为0

for(int i=0;i<n;++i){
c[s[i]-min]++;//个数加1
}
for(int i=1;i<count;++i){
c[i]+=c[i-1];
}
for(int i=n-1;i>=0;--i){
b[c[s[i]-min]-1]=a[i];//c数组从0开始，但是值可正可负
c[s[i]-min]--;        //所以要将最小值的下标调整到0.
}

for(int i=0;i<n;++i){
a[i]=b[i];
}

delete[]c;
}
delete[]s;
delete[]b;
}

int main()
{
srand(time(NULL));
int count;
while (count=rand()%10,count<4);
count=20000000;
int *a=new int[count];
int *b=new int[count];
int *c=new int[count];
int *d=new int[count];
int *e=new int[count];
for(int i=0;i<count;++i){
a[i]=rand()%20000001-10000000;
b[i]=a[i];
c[i]=b[i];
d[i]=c[i];
//cout<<a[i]<<"\t";
}
//cout<<endl;

cpu_timer t1;
t1.start();
bucket_sort(a,count);//桶排序
t1.stop();
cout<<"bucket sort"<<endl;
cout<<t1.format();
/*for(int i=0;i<count;++i){
cout<<a[i]<<"\t";
}
cout<<endl;*/

cpu_timer t2;
t2.start();
same_elem_quick_sort(b,0,count);//快速排序
t2.stop();
cout<<"quick sort"<<endl;
cout<<t2.format();

cpu_timer t3;
t3.start();
counting_sort(c,e,count);
t3.stop();
cout<<"counting sort"<<endl;
cout<<t3.format();

cpu_timer t4;
t4.start();
radix_sort(d,count);
t4.stop();
cout<<"radix sort"<<endl;
cout<<t4.format();

delete[]a;
delete[]b;
delete[]c;
delete[]d;
delete[]e;
}