几种排序算法的效率

对于排序算法的效率一直不太清楚，今天自己动手试了一试，才发现对于大量数据的排序时，各个算法效率的差异实在惊人！

代码如下：

 

/********************************************************************
    created:    2009/03/22
    created:    22:3:2009   20:58
    filename:     e:\Graduate\Sort\Sort\Sort.cpp
    file path:    e:\Graduate\Sort\Sort
    file base:    Sort
    file ext:    cpp
    author:        zwicker
    
    purpose:    用来演示几种排序的效率
*********************************************************************/
#include <iostream>
#include <stdlib.h>
#include <Windows.h>
using namespace std;

//随机初始化数组
void initArray(int a[],int n)
{
    srand(GetTickCount());
    for (int i=0;i<n;i++)
    {
        a[i]=rand();
    }
}

//插入排序
void insertionSort(int a[],int n)
{
    for (int i=1;i<n;i++)
    {
        int tmp=a[i];
        int j;
        for (j=i;j>0&&tmp<a[j-1];j--)
        {
            a[j]=a[j-1];
        }
        a[j]=tmp;
    }
}

//交换两个数
void swapValue(int &a,int &b)
{
    int tmp=a;
    a=b;
    b=tmp;
}

//选择排序
void selectionSort(int a[],int n)
{
    for(int past=0,j;past<n-1;past++)
    {

        int min=past;
        for(j=past+1;j<n;j++)
        {
            
            if(a[j]<a[min])
                min=j;
        }
        swapValue(a[past],a[min]);
    }
}

//选择排序
void selectionSort2(int a[],int n)
{
    int least,i,j;
    for(i=0;i<n-1;i++)
        for(j=i+1,least=i;j<n;j++)
            if(a[j]<a[least])
                least=j;
    swapValue(a[least],a[i]);
}

//冒泡排序
void bubbleSort(int a[],int n)
{
    for (int past=0;past<n-1;past++)
    {
        for (int j=n-1;j>past;j--)
        {
            if(a[j]<a[j-1])
                swapValue(a[j],a[j-1]);


        }
    }
}

//打印数组
void printArray(int a[],int n)
{

    int l=0;
    for (int i=0;i<n;i++,l++)
    {

        if(l%10==0)
            cout<<endl;
        cout<<a[i]<<"  ";
    }
}

//希尔排序
void shellSort(int data[],int arrSize)
{
    int i,j,hCnt,h;
    int increaments[20],k;
    for(h=1,i=0;h<arrSize;i++)
    {
        increaments[i]=h;
        h=3*h+1;
    }

    for(i--;i>=0;i--)
    {
        h=increaments[i];
        for(hCnt=h;hCnt<2*h;hCnt++)
        {
            for(j=hCnt;j<arrSize;)
            {
                int tmp=data[j];
                k=j;
                while (k-h>0&&tmp<data[k-h])
                {
                    data[k]=data[k-h];
                    k-=h;
                }
                data[k]=tmp;
                j+=h;
            }
        }
    }

}



//判断数组是否有序
bool judgeSorted(int a[],int n)
{
    for (int i=1;i<n-1;i++)
    {
        if(a[i]>a[i+1])
            return false;
    }
    return true;
}

//快速排序
void quickSort(int data[],int first,int last)
{
    int lower=first+1,upper=last;
    swapValue(data[first],data[(first+last)/2]);
    int bound=data[first];
    while (lower<=upper)
    {
        while (data[lower]<bound)
        lower++;
        while(bound<data[upper])
            upper--;
        if(lower<upper)
            swapValue(data[lower++],data[upper--]);
        else
            lower++;
    }
    swapValue(data[upper],data[first]);
        if(first<upper-1)
            quickSort(data,first,upper-1);
    if(upper+1<last)
        quickSort(data,upper+1,last);
}

void quickSort(int data[],int n)
{
    if(n<2)
        return;
    int i,max;
    for(i=1,max=0;i<n;i++)
        if(data[max]<data[i])
            max=i;
    swapValue(data[n-1],data[max]);
    quickSort(data,0,n-2);
}

int main()
{

    int a[40000];//用于测试效率的数组

    initArray(a,40000);//初始化数组

    DWORD oldtime1=GetTickCount();//获得当前计算机Tick
    insertionSort(a,40000);//进行插入排序
    if(judgeSorted(a,40000))//判断数组是否已经排序
        cout<<"The array has benn insertionSorted!"<<endl;
    DWORD insertSortElapse=GetTickCount()-oldtime1;//获得插入排序的时间
    
    initArray(a,40000);//重新初始化数组

    DWORD oldtime2=GetTickCount();
    selectionSort(a,40000);//进行选择排序
    if(judgeSorted(a,40000))
        cout<<"The array has benn selectionSorted!"<<endl;
    DWORD selectSortElapse=GetTickCount()-oldtime2;

    initArray(a,40000);

    DWORD oldtime3=GetTickCount();
    bubbleSort(a,40000);//进行冒泡排序
    if(judgeSorted(a,40000))
        cout<<"The array has benn bubbleSorted!"<<endl;
    DWORD bubbleSortElapse=GetTickCount()-oldtime3;

    initArray(a,40000);

    DWORD oldtime4=GetTickCount();
    shellSort(a,40000);//进行希尔排序
    if(judgeSorted(a,40000))
        cout<<"The array has been shellSorted!"<<endl;
    DWORD shellSortElapse=GetTickCount()-oldtime4;


    initArray(a,40000);

    DWORD oldtime5=GetTickCount();
    quickSort(a,40000);//进行快速排序
    if(judgeSorted(a,40000))
        cout<<"The array has been quickSorted!"<<endl;
    DWORD qucikSortElapse=GetTickCount()-oldtime5;

    //输出各个排序所耗费的时间
    cout<<"InsertionSort Elapsed:"<<insertSortElapse<<endl;
    cout<<"SelectionSort Elapsed:"<<selectSortElapse<<endl;
    cout<<"BubbleSort Elapsed:"<<bubbleSortElapse<<endl;
    cout<<"ShellSort Elapsed:"<<shellSortElapse<<endl;
    cout<<"QuickSort Elapsed:"<<qucikSortElapse<<endl;


    /*int a[]={2,3,5,8,1};

    cout<<"Before InsertionSort:";
    printArray(a,5);

    cout<<endl<<"After InsertionSort:";
    selectionSort(a,5);
    printArray(a,5);

    int b[5];
    initArray(b,5);
    cout<<endl<<"Before SelectionSort:";
    printArray(b,5);

    cout<<endl<<"After SelectionSort:";
    selectionSort(b,5);
    printArray(b,5);*/


    //int c[]={2,3,5,8,1};
    //cout<<endl<<"Before BubbleSort:";
    //printArray(c,5);

    //cout<<endl<<"After BubbleSort:";
    //bubbleSort(c,5);
    //printArray(c,5);

    //int d[100];
    //initArray(d,100);
    //cout<<endl<<"Before ShellSort:";
    //printArray(d,100);

    //cout<<endl<<"After ShellSort:";
    //shellSort(d,100);
    //printArray(d,100);



    int k;
    cin>>k;

}

这是运行结果：

The array has benn insertionSorted!
The array has benn selectionSorted!
The array has benn bubbleSorted!
The array has been shellSorted!
The array has been quickSorted!
InsertionSort Elapsed:3219
SelectionSort Elapsed:4344
BubbleSort Elapsed:18171
ShellSort Elapsed:32
QuickSort Elapsed:15

 另一组测试数据：

The array has benn insertionSorted!
The array has benn selectionSorted!
The array has benn bubbleSorted!
The array has been shellSorted!
The array has been quickSorted!
InsertionSort Elapsed:2860
SelectionSort Elapsed:4125
BubbleSort Elapsed:17406
ShellSort Elapsed:16
QuickSort Elapsed:0

从运行结果可以看出对于大数据量的排序，快速排序效率比最慢的冒泡排序要快100多倍，多么惊人！