冒泡排序、希尔排序、归并排序 、快速排序性能分析

本代码用来测量分析冒泡排序、希尔排序、归并排序 和快速排序在数组大小不同的情况下的用时情况。

 

使用函数比较两个数组是否一致：

bool check(int*s, int*s2,int len){
    bool same = true;
    for(int i=0;i<len;i++) if(s[i]!=s2[i]) same = false;
    return same;
}

希尔排序

void shellsort(int* s,int len) {
    for(int gap=len/2; gap>0; gap/=2) {
        for(int i=0; i<gap; i++) {
            for(int j=i+gap; j<len; j+=gap) {
                if(s[j]<s[j-gap]) {
                    int temp = s[j];
                    int k=j-gap;
                    while(k>=0 && s[k]>temp) { //注意k包含0
                        s[k+gap] = s[k];
                        k-=gap;
                    }
                    s[k+gap] = temp;
                }
            }
        }
    }
}

归并排序

void gsort(int*  s,int l, int r) {
    if(l==r) return;
    int m = (l+r)/2;
    gsort(s,l,m);
    gsort(s,m+1,r);
    int i=l,j=m+1,k=0;
    int* temp = new int[r-l+1];
    while(i<=m || j<=r) {
        while(i<=m)
            if(j>r || s[i]<=s[j] ) temp[k++]=s[i++];
            else break;
        while(j<=r)
            if(i>m || s[j]<=s[i]) temp[k++]=s[j++];
            else break;
    }
    for(int t=0;t<k;t++) s[l+t] = temp[t];
    delete[] temp;
    return;
}

快速排序

void qsort(int* a, int l, int r) {
    if (l < r) {
        int i,j,x;
        i = l;
        j = r;
        x = a[i];
        while (i < j) {
            while(i < j && a[j] > x)
                j--;             
            if(i < j)
                a[i++] = a[j];
            while(i < j && a[i] < x)
                i++;         
            if(i < j)
                a[j--] = a[i];
        }
        a[i] = x;
        qsort(a, l, i-1); 
        qsort(a, i+1, r);
    }
}
void isort(int a[], int n){ 
    int i, j, k;
    for (i = 1; i < n; i++){            
        for (j = i - 1; j >= 0; j--)    
            if (a[j] < a[i])
                break;
        if (j != i - 1) {               
            int temp = a[i];
            for (k = i - 1; k > j; k--)
                a[k + 1] = a[k];
            a[k + 1] = temp;
        }
    }
}

冒泡排序

void bsort(int a[], int n) {
    int i,j;
    int flag;               
    for (i=n-1; i>0; i--){
        flag = 0;            
        for (j=0; j<i; j++) {
            if (a[j] > a[j+1]) {
                swap(a[j], a[j+1]);
                flag = 1; 
            }
        }
        if (flag==0)
            break;            
    }
}

int main() {   
    srand(time(NULL));
    for(int i=0; i<use; i++) {        //制作一个随机数数组
        int t = rand()%use;
        for(int j=0;j<5;j++) s[j][i] = t;
    }
    
    cout<<endl<<endl<<"answer :"<<endl;
    clock_t temp1 = clock();    //统计不同算法排序时间
    sort(s[0],s[0]+use);
    clock_t temp2 = clock();
    for(int i=0; i<show; i++) cout<<s[0][i] <<" ";
    cout<<"   using time "<<temp2 - temp1; 
    
    cout<<endl<<endl<<"guibingsort :"<<endl;
    temp1 = clock();
    gsort(s[1],0,use-1);
    temp2 = clock();
    for(int i=0; i<show; i++) cout<<s[1][i]<<" "; 
    cout<<(check(s[0],s[1],use)?"right":"worng")<<"   using time "<<temp2-temp1<<endl<<endl;
    
    cout<<endl<<endl<<"quick_sort :"<<endl;
    temp1 = clock();
    qsort(s[2],0,use-1);
    temp2 = clock();
    for(int i=0; i<show; i++) cout<<s[2][i]<<" "; 
    cout<<(check(s[0],s[2],use)?"right":"worng")<<"   using time "<<temp2-temp1<<endl<<endl;
    
    cout<<endl<<endl<<"insert_sort :"<<endl;
    temp1 = clock();
    isort(s[3],use);
    temp2 = clock();
    for(int i=0; i<show; i++) cout<<s[3][i]<<" "; 
    cout<<(check(s[0],s[3],use)?"right":"worng")<<"   using time "<<temp2-temp1<<endl<<endl;
    
    cout<<endl<<endl<<"bubble_sort :"<<endl;
    temp1 = clock();
    bsort(s[4],use);
    temp2 = clock();
    for(int i=0; i<show; i++) cout<<s[4][i]<<" "; 
    cout<<(check(s[0],s[4],use)?"right":"worng")<<"   using time "<<temp2-temp1<<endl<<endl
    
}

结果比较：

use = 1000 时：

 

use太小时，前面几个算法比较不出什么差异，只有冒泡排序慢5ms

use = 10000 时：

use扩大十倍，algrightm 自带的快速排序大约耗时一毫秒，自己写的快速排序更快，但未明显。插入排序与冒泡排序开始感觉到延迟。

use = 50000 时：

use = 99000 时：

 

总结：

1.在数组没有规律时，插入排序比冒泡排序要快不少。

2.<algorithm>提供的sort方法虽然经过了很多优化，但是在普通的数组排序时，速度可能会低于普通的快速排序算法。

（以上算法均出自作者原创，不能确保完全正确，如有不足之处望及时指出）