排序算法时间测试比较

之前介绍过常见的排序算法，可以查看这里

之前实现的代码都是针对int型的算法，现在我将代码改写成了模板，这样可以应用于常见的一些类型。

为了测试比较不同的排序算法，采用了两种计时方式。注意，下面的两段代码中，void(*_sort[])(T*,int) 是函数指针数组。

1. 采用clock函数，统计排序算法所使用的时钟数

代码如下： 

template <class T>
void clock_test()
{
    void(*_sort[])(T*,int)={insert_sort,binary_insert_sort,shell_sort,shell_sort2,select_sort,
                           select_sort2,select_sort3,heap_sort,bubble_sort,bubble_sort2,quick_sort,
                           merge_sort,merge_sort2,merge_sort3,merge_sort4,rank_sort,rank_sort2};
    int len=sizeof(_sort)/sizeof(_sort[0]);
    clock_t start,finish;
    //    cout<<CLOCKS_PER_SEC<<endl;
    cout<<"鐩存帴鎻掑叆\t鎶樺崐鎻掑叆\t甯屽皵鎺掑簭\t"<<endl;
    int step=100;
    for(int k=100;k<=100000;k+=step)
    {
        const int N=k;
        T arr[N];
        double tm[N];
        //    srand(time(0));
        for(int i=0;i<N;i++)
            arr[i]=rand()%1000;
        for(int i=0;i<len;i++) {
            start=clock();
            _sort[i](arr,N);
            finish=clock();
            tm[i]=(finish-start)*1.0/CLOCKS_PER_SEC;
        }
        cout<<k<<'\t';
        for(int i=0;i<len;i++)
            cout<<tm[i]<<'\t';
        cout<<endl;
    }
}

部分测试输出如下： 

 

2. 利用ftime函数，具体介绍见这儿

代码如下：

template <class T>
void time_test()
{
    void(*_sort[])(T*,int)={insert_sort,binary_insert_sort,shell_sort,shell_sort2,select_sort,
                           select_sort2,select_sort3,heap_sort,bubble_sort,bubble_sort2,quick_sort,
                           merge_sort,merge_sort2,merge_sort3,merge_sort4,rank_sort,rank_sort2};
    int len=sizeof(_sort)/sizeof(_sort[0]);
    struct TIMEB ts1,ts2;
    time_t t_sec,t_ms,ti;
    cout<<"鐩存帴鎻掑叆\t鎶樺崐鎻掑叆\t甯屽皵鎺掑簭\t"<<endl;
    int step=100;
    for(int k=100;k<=100000;k+=step)
    {
        const int N=k;
        T arr[N];
        double tm[N];
        for(int i=0;i<N;i++)
            arr[i]=rand()%1000;
        cout<<k<<'\t';
        for(int i=0;i<len;i++) {
            ftime(&ts1);
            _sort[i](arr,N);
            ftime(&ts2);
            t_sec=ts2.time-ts1.time;
            t_ms=ts2.millitm-ts1.millitm;
            ti=t_sec*1000+t_ms;
            cout<<ti<<'\t';
        }
        cout<<endl;
    }
}

部分测试输出如下：

 

最终的全部代码如下：

#include <iostream>
#include <iterator>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <list>
#include <sys/timeb.h>
#define TIMEB timeb
#define _FUNC cout<<__FUNCTION__<<endl
#define print(arr,n) copy(arr,arr+n,ostream_iterator<T>(cout," "));\
    cout<<endl;
using namespace std;
const char *const red = "\033[0;40;31m";
const char *const green= "\033[0;40;32m";
const char *const normal = "\033[0m";

template <class T>
void insert_sort(T a[],int n)
{
    for(int i=1;i<n;i++) {
        T t=a[i];
        int j;
        for(j=i-1;j>=0&&a[j]>t;j--) {
                a[j+1]=a[j];
        }
        a[j+1]=t;
    }

}
template <class T>
void binary_insert_sort(T a[],int n){
    for(int i=1;i<n;i++){
        int low=0;
        int high=i-1;
        T t=a[i];
        int mid;
        while(low<=high){
            mid=(low+high)/2;
            if(t<a[mid])
                high=mid-1;
            else
                low=mid+1;
        }
        for(int j=i;j>mid;j--)
            a[j]=a[j-1];
        a[low]=t;

    }
}
template <class T>
void shell_sort(T a[],int n)
{
    int gap=n/2;
    bool flag=true;
    while(gap>1||flag)
    {
        flag=false;
        for(int i=0;i+gap<n;i++)
            if(a[i]>a[i+gap])
            {
                swap(a[i],a[i+gap]);
                flag=true;
            }
        if(gap>1)
            gap/=2;
    }

}
template <class T>
void shell_sort2(T a[],int n){
    int gap=n/2;
    while(gap>0){
        for(int i=gap;i<n;i++){
            T t=a[i];
            int j;
            for(j=i-gap;j>=0&&a[j]>t;j-=gap)
                a[j+gap]=a[j];
            a[j+gap]=t;
        }
        gap/=2;
    }
}
template <class T>
void select_sort(T a[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        T min=a[i];
        int index=i;
        for(int j=i+1;j<n;j++)
            if(a[j]<min)
            {
                min=a[j];
                index=j;
            }
        swap(a[i],a[index]);
    }
}
template <class T>
void select_sort2(T a[],int n)
{
    for(int i=n-1;i>0;i--){
        for(int j=0;j<i;j++)
            if(a[j]>a[i])
                swap(a[j],a[i]);
    }

}
template <class T>
void select_sort3(T a[],int n)
{
    bool flag=true;
    for(int i=n-1;i>0&&flag;i--){
        flag=false;
        for(int j=0;j<i;j++)
            if(a[j]>a[i])
                swap(a[j],a[i]),flag=true;
    }

}
template <class T>
void adjust(T b[],int m,int n){
    int j=m;
    int k=2*m;
    while(k<=n){
        if(k<n&&b[k]<b[k+1])
            k++;
        if(b[j]<b[k])
            swap(b[j],b[k]);
        j=k;
        k*=2;
    }
}
template <class T>
void heap_sort(T a[],int n){
    T *b=a-1;
    for(int i=n/2;i>=1;i--)
        adjust(b,i,n);
    for(int i=n-1;i>=1;i--){
        swap(b[1],b[i+1]);
        adjust(b,1,i);
    }
}
template <class T>
void bubble_sort(T a[],int n)
{
    for(int i=n-1;i>0;i--)
        for(int j=0;j<i;j++)
            if(a[j]>a[j+1])
                swap(a[j],a[j+1]);

}
template <class T>
void bubble_sort2(T a[],int n)
{
    bool flag=true;
    for(int i=n-1;i>0&&flag;i--){
        flag=false;
        for(int j=0;j<i;j++)
            if(a[j]>a[j+1])
                swap(a[j],a[j+1]),flag=true;
    }

}
template <class T>
void qsort(T a[],int l,int r){
    T pvt=a[(l+r)/2];
    int i=l,j=r;
    while(i<=j){
        while(a[i]<pvt)
            i++;
        while(a[j]>pvt)
            j--;
        if(i<=j){
            if(i!=j)
                swap(a[i],a[j]);
            i++;
            j--;
        }
    }
    if(j>l)
        qsort(a,l,j);
    if(i<r)
        qsort(a,i,r);
}
template <class T>
void quick_sort(T a[],int n){
    qsort(a,0,n-1);
}
template <class T>
void merge(T a[],T b[],int l,int m,int r){
    int i,j,k;
    i=l;
    j=m+1;
    k=l;
    while(i<=m&&j<=r){
        if(a[i]<a[j])
            b[k++]=a[i++];
        else
            b[k++]=a[j++];
    }
    while(i<=m)
        b[k++]=a[i++];
    while(j<=r)
        b[k++]=a[j++];
    for(int s=l;s<=r;s++)
        a[s]=b[s];
}
template <class T>
void msort(T a[],T b[],int l,int r){
    if(l<r){
        int m=(l+r)/2;
        msort(a,b,l,m);
        msort(a,b,m+1,r);
        merge(a,b,l,m,r);
    }
}
template <class T>
void merge_sort(T a[],int n){
    T *b=new T[n];
    msort(a,b,0,n-1);
    delete[] b;
}
template <class T>
void merge_pass(T x[],T y[],int s,int n){
    int i=0;
    while(i+2*s-1<n){
        merge(x,y,i,i+s-1,i+2*s-1);
        i+=2*s;
    }
    if(i+s<n)
        merge(x,y,i,i+s-1,n-1);
    else
        for(int j=i;j<=n-1;j++)
            y[j]=x[j];
}
template <class T>
void merge_sort2(T a[],int n){
    T *b=new T[n];
    int s=1;
    while(s<n){
        merge_pass(a,b,s,n);
        s+=s;
        merge_pass(b,a,s,n);
        s+=s;
    }
    delete[] b;
}

template <class T>
void merge_sort3(T a[],int n){
    vector<int> st;
    for(int i=0;i<n-1;i++){
        if(a[i]>a[i+1])
            st.push_back(i);
    }
    st.push_back(n-1);
    T *b=new T[n];
    int l,m,r;
    l=0;
    if(!st.empty())
    {
        m=st.front();
        st.erase(st.begin());
    }
    while(!st.empty()){
        r=st.front();
        st.erase(st.begin());
        merge(a,b,l,m,r);
        m=r;
    }
    delete [] b;
}
template <class T>
void merge_sort4(T a[],int n){
    int *pos=new int[n];
    int k=0;
    for(int i=0;i<n-1;i++){
        if(a[i]>a[i+1])
            pos[k++]=i;
    }
    pos[k++]=n-1;
    T *b=new T[n];
    int l,m,r;
    l=0;
    int p=0;
    if(p<k)
        m=pos[p++];
    while(p<k){
        r=pos[p++];
        merge(a,b,l,m,r);
        m=r;
    }
    delete [] b;
}
template <class T>
void rank(T arr[],int n,int r[])
{
    for(int i=0;i<n;i++)
        r[i]=0;
    for(int i=1;i<n;i++){
        for(int j=0;j<i;j++)
        {
            if(arr[j]<=arr[i])
                r[i]++;
            else
                r[j]++;
        }
    }
}
template <class T>
void rank_sort(T arr[],int n)
{
    int *r=new int[n];
    rank(arr,n,r);
    for(int i=0;i<n;i++)
    {
        while(r[i]!=i)
        {
            T t=r[i];
            swap(arr[i],arr[t]);
            swap(r[i],r[t]);
        }
    }
    delete[] r;
}
template <class T>
void rank_sort2(T a[],int n){
    int *r=new int[n];
    rank(a,n,r);
    T *u=new T[n];
    for(int i=0;i<n;i++)
        u[r[i]]=a[i];
    for(int i=0;i<n;i++)
        a[i]=u[i];
    delete[] r;
    delete[] u;
}
int maxbits(int a[],int n){
    int d=0;
    for(int i=0;i<n;i++){
        int b=1;
        int r=a[i];
        while(r/10>0){
            b++;
            r/=10;
        }
        if(d<b)
            d=b;
    }
    return d;
}
void radix_sort(int a[],int n){
    int d=maxbits(a,n);
    int *temp=new int[n];
    int *count=new int[10];
    int adix=1;
    for(int b=1;b<=d;b++){
        for(int i=0;i<10;i++)
            count[i]=0;
        for(int i=0;i<n;i++){
            int k=(a[i]/adix)%10;
            count[k]++;
        }
        for(int i=1;i<10;i++)
            count[i]+=count[i-1];
        for(int i=n-1;i>=0;i--){
            int k=(a[i]/adix)%10;
            count[k]--;
            temp[count[k]]=a[i];
        }
        for(int i=0;i<n;i++)
            a[i]=temp[i];
        adix*=10;
    }
    delete[] temp;
    delete[] count;
}
void radix_sort2(int a[],int n){
    int bits=maxbits(a,n);
    list<int> x(a,a+n);
    int range=10;
    vector<list<int> > bin(range);
    list<int> y;
    list<int>::iterator ite;
    int adix=1;
    for(int i=0;i<bits;i++){
        for(ite=x.begin();ite!=x.end();ite++){
            int d=(*ite/adix)%10;
            bin[d].push_back(*ite);
        }   
        vector<list<int> >::iterator ite2;
        y.clear();
        for(ite2=bin.begin();ite2!=bin.end();++ite2){
            for(ite=ite2->begin();ite!=ite2->end();++ite)
                y.push_back(*ite);
            ite2->clear();
        }
        x=y;
        adix*=10;
    }
    int i=0;
    for(ite=x.begin();ite!=x.end();ite++)
        a[i++]=*ite;
}
template <class T>
void sort_test(void (*_sort)(T*,int)){
    const int N=10;
    T orig[N];
    T standard[N];
    T arr[N];
    srand(time(0));
    for(int j=0;j<18;j++){
        for(int i=0;i<N;i++)
            orig[i]=rand()%100;
        cout<<"bef:";
        print(orig,N);

        copy(orig,orig+N,standard);
        sort(standard,standard+N);
        cout<<"std:";
        print(standard,N);

        copy(orig,orig+N,arr);
        _sort(arr,N);
        cout<<"aft:";
        print(arr,N);
        if(equal(standard,standard+N,arr))
            printf("%sOK%s\n",green,normal);
        else
            printf("%sNO%s\n",red,normal);
    }

}
template <class T>
void clock_test()
{
    void(*_sort[])(T*,int)={insert_sort,binary_insert_sort,shell_sort,shell_sort2,select_sort,
                           select_sort2,select_sort3,heap_sort,bubble_sort,bubble_sort2,quick_sort,
                           merge_sort,merge_sort2,merge_sort3,merge_sort4,rank_sort,rank_sort2};
    int len=sizeof(_sort)/sizeof(_sort[0]);
    clock_t start,finish;
    //    cout<<CLOCKS_PER_SEC<<endl;
    cout<<"鐩存帴鎻掑叆\t鎶樺崐鎻掑叆\t甯屽皵鎺掑簭\t"<<endl;
    int step=100;
    for(int k=100;k<=100000;k+=step)
    {
        const int N=k;
        T arr[N];
        double tm[N];
        //    srand(time(0));
        for(int i=0;i<N;i++)
            arr[i]=rand()%1000;
        for(int i=0;i<len;i++) {
            start=clock();
            _sort[i](arr,N);
            finish=clock();
            tm[i]=(finish-start)*1.0/CLOCKS_PER_SEC;
        }
        cout<<k<<'\t';
        for(int i=0;i<len;i++)
            cout<<tm[i]<<'\t';
        cout<<endl;
    }
}
template <class T>
void time_test()
{
    void(*_sort[])(T*,int)={insert_sort,binary_insert_sort,shell_sort,shell_sort2,select_sort,
                           select_sort2,select_sort3,heap_sort,bubble_sort,bubble_sort2,quick_sort,
                           merge_sort,merge_sort2,merge_sort3,merge_sort4,rank_sort,rank_sort2};
    int len=sizeof(_sort)/sizeof(_sort[0]);
    struct TIMEB ts1,ts2;
    time_t t_sec,t_ms,ti;
    cout<<"鐩存帴鎻掑叆\t鎶樺崐鎻掑叆\t甯屽皵鎺掑簭\t"<<endl;
    int step=100;
    for(int k=100;k<=100000;k+=step)
    {
        const int N=k;
        T arr[N];
        double tm[N];
        for(int i=0;i<N;i++)
            arr[i]=rand()%1000;
        cout<<k<<'\t';
        for(int i=0;i<len;i++) {
            ftime(&ts1);
            _sort[i](arr,N);
            ftime(&ts2);
            t_sec=ts2.time-ts1.time;
            t_ms=ts2.millitm-ts1.millitm;
            ti=t_sec*1000+t_ms;
            cout<<ti<<'\t';
        }
        cout<<endl;
    }
}
int main()
{
//    sort_test(radix_sort2);
//    clock_test<int>();
    time_test<int>();
}