各种实用排序算法

实用排序算法（复杂度小于等于O(n^2)）中效率最低但实现并不是最简单的的两个，C、C++教材却总喜欢拿来大讲特讲，非常不利于初学者养成“程序效率”的思维。

实际上，各种排序算法里，除了堆排序实现较为复杂外，从代码量的角度，大多数算法都不比冒泡、选择算法复杂多少。

举几个高速的排序算法的例子，这些才适合进入教材

鸽巢排序，排序字节串、宽字节串最快的排序算法，计数排序的变种（将计数缓冲区大小固定，少一次遍历开销），速度是STL中std::sort的20多倍，更重要的是实现极其简单！缺点是需要一个size至少等于待排序数组取值范围的缓冲区，不适合int等大范围数据

C/C++ code

void PigeonholeSort(BYTE *array, int length){    int b[256] = {0};    int i,k,j = 0;    for(i=0; i<length; i++)        b[array[i]]++;    for(i=0; i<256; i++)        for(k=0; k<b[i]; k++)            array[j++] = i;}

多一次遍历的计数排序，排序字节串的话速度约是鸽巢排序的一半

C/C++ code

void CountingSort(BYTE *array, int length){    int t;    int i, z = 0;    BYTE min,max;    int *count;    min = max = array[0];    for(i=0; i<length; i++)    {        if(array[i] < min)            min = array[i];        else if(array[i] > max)            max = array[i];    }    count = (int*)malloc((max-min+1)*sizeof(int));    for(i=0; i<max-min+1; i++)        count[i] = 0;    for(i = 0; i < length; i++)        count[array[i]-min]++;    for(t = 0; t <= 255; t++)        for(i = 0; i < count[t-min]; i++)            array[z++] = (BYTE)t;    free(count);}

快速排序，快排最标准的递归实现，速度约是std::sort的一半

C/C++ code

void swap(BYTE *a,BYTE *b){    BYTE tmp;    if ( a != b )    {        tmp = *a;        *a = *b;        *b = tmp;    }}int partition(BYTE *arr,int left, int right){    int i = left - 1, j = right;    BYTE v = arr[right];    while(1)    {        while(arr[++i] < v);        while(arr[--j] > v)            if(j == 1)                break;        if(i >= j)            break;        swap(&arr[i],&arr[j]);    }    swap(&arr[i],&arr[right]);    return i;}void quicksort(BYTE *arr, int left, int right){    if (left < right)    {        int i = partition(arr,left,right);        quicksort(arr,left,i-1);        quicksort(arr,i+1,right);    }}void QuickSort(BYTE *array,int length){    quicksort(array,0,length-1);}

这是速度与std::sort相当的三路划分快排

C/C++ code

void swap(BYTE *a,BYTE *b){    BYTE tmp;    if ( a != b )    {        tmp = *a;        *a = *b;        *b = tmp;    }}void quicksort(BYTE *arr, int left, int right){    if (left < right)    {        BYTE v = arr[right];        int i = left - 1,j = right,p = left - 1,q = right,k=0;        while (1)        {            while (arr[++i] < v);            while (arr[--j] > v)                if(j==left)                    break;            if (i >= j)                break;            swap(&arr[i], &arr[j]);            if(arr[i] == v)            {                p++;                swap(&arr[p],&arr[i]);            }            if(arr[j] == v)            {                q--;                swap(&arr[q],&arr[j]);            }        }        swap(&arr[i],&arr[right]);        j = i - 1;        i++;        for(k=left; k<=p; k++,j--)            swap(&arr[k],&arr[j]);        for(k=right-1; k>=q; k--,i++)            swap(&arr[k],&arr[i]);        quicksort(arr,left,j);        quicksort(arr,i,right);    }}void QuickSort(BYTE *array,int length){    quicksort(array,0,length-1);}

相当简单的梳排序，效率是std::sort的三分之一

C/C++ code

void CombSort(BYTE *arr, int size){    UINT gap = size, swapped = 1, i = 0;    BYTE swap = 0;    while ((gap > 1) || swapped)    {        if (gap > 1)            gap = gap / 1.3;        swapped = 0;         i = 0;        while ((gap + i) < size)        {            if (arr[i] - arr[i + gap] > 0)            {                swap = arr[i];                arr[i] = arr[i + gap];                arr[i + gap] = swap;                swapped = 1;            }            ++i;        }    }}

LSD基数排序，与std::sort速度相当，但是需要一个与输入缓冲一样大的缓冲区

C/C++ code

#define R 256#define digit(a, d)    ( a >> 8*d )static BYTE *aux;void radix_sort(BYTE *arr, int left, int right){    if(left < right)    {        int d = 0;        for(d=3; d>=0; d--)        {            int i=0, j=0, count[R+1];            for(j=0; j<R; j++)                count[j] = 0;            for(i=left; i<=right; i++)                count[digit(arr[i],d) + 1]++;            for(j=1; j<R; j++)                count[j] += count[j-1];            for(i=left; i<=right; i++)                aux[count[digit(arr[i],d)]++] = arr[i];            for(i=left; i<=right; i++)                arr[i] = aux[i-1];        }        }}void RadixSort(BYTE *array,int length){    aux = (BYTE*)malloc(length);    radix_sort(array,0,length-1);    free(aux);}

归并排序，效率越是std::sort的六分之一，通常的实现是递归，但和快排不同，归并改循环极其容易

C/C++ code

void merge(BYTE *array, int low, int mid, int high){    int i, k;    BYTE *temp = (BYTE *) malloc(high-low+1);    int begin1 = low;    int end1 = mid;    int begin2 = mid + 1;    int end2 = high;    for (k = 0; begin1 <= end1 && begin2 <= end2; ++k)        if(array[begin1]<array[begin2])            temp[k] = array[begin1++];        else            temp[k] = array[begin2++];        while(begin1<=end1)        temp[k++] = array[begin1++];    while(begin2<=end2)        temp[k++] = array[begin2++];    for (i = 0; i < (high-low+1); i++)        array[low+i] = temp[i];    free(temp);}void merge_sort(BYTE *array, UINT first, UINT last){    UINT mid,i;    for(mid=1; mid<=last-first; mid += mid)        for(i=first; i<=last-mid; i+=mid+mid)            merge(array,i,i+mid-1,min(i+mid+mid-1,last));}void MergeSort(BYTE *array, UINT length){    merge_sort(array,0,length-1);}