常见的排序方法

常见的排序方法

实用排序算法（复杂度小于等于O(n^2)）中效率最低但实现并不是最简单的的两个，C、C++教材却总喜欢拿来大讲特讲，非常不利于初学者养成“程序效率”的思维。实际上，各种排序算法里，除了堆排序实现较为复杂外，从代码量的角度，大多数算法都不比冒泡、选择算法复杂多少。

一 冒泡法排序

 #include "stdio.h"

 void bubble(int *a, int len)
 {
     int i,j,temp;

     for(i = 0;i < len - 1;i ++)
     {
         for(j = 0;j < len - i - 1;j ++)
         {
             if(a[j] > a[j + 1])
             {
                 temp = a[j];
                 a[j] = a[j + 1];
                 a[j + 1] = temp;
             }
         }
     }
 }
 void main(void)
 {
     int i,a[ ] = {2,5,4,1,6,3,7,9,8,0};

     int len = sizeof(a) / sizeof(int);

     bubble(a, len);

     for(i = 0; i < len; i ++)
     {
         printf("%2d",a[i]);
     }
     printf("\n");

 }

二 选择法排序

1)普通方法

 #include "stdio.h"

 void choiceOne(int *a, int len)
 {
     int i,j,temp;

     for(i = 0;i < len - 1;i ++)
     {
         for(j = i + 1;j < len ;j ++)
         {
             if(a[i] > a[j])
             {
                 temp = a[i];
                 a[i] = a[j];
                 a[j] = temp;
             }
         }
     }
 }
 void main(void)
 {
     int i,a[]={2,5,4,1,6,3,7,9,8,0};

     int len = sizeof(a) / sizeof(int);

     choiceOne(a, len);

     for(i = 0;i < len;i ++)
     {
         printf("%2d",a[i]);
     }
     printf("\n");

 }

2)改进方法

 #include "stdio.h"

 void choiceTwo(int *a, int len)
 {
     int i,j,k,temp;

     for(i = 0; i < len - 1; i ++)
     {
         k = i;
         for(j = i + 1;j < len ;j ++)
         {
             if(a[k] > a[j])
             {
                 k = j;
             }
         }
         if(k != i)
         {
             temp = a[i];
             a[i] = a[k];
             a[k] = temp;
         }
     }
 }
 void main(void)
 {
     int i,a[]={2,5,4,1,6,3,7,9,8,0};

     int len = sizeof(a) / sizeof(int);

     choiceTwo(a, len);

     for(i = 0;i < len;i ++)
     {
         printf("%2d",a[i]);
     }
     printf("\n");
 }

 void func(int *a, int len)
 {
     int i,j,k;

     for(i = 0; i < len - 1; i ++)
     {
         k = i;
         for(j = i + 1;j < len ;j ++)
         {
             if(a[k] > a[j])
             {
                 k = j;
             }
         }
         if(k != i)
         {
             a[i] ^= a[k] ^= a[i] ^= a[k];
         }
     }
 }

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

 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;
 }

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

 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的一半

 #include <stdio.h>

 int  Partition(int *iArray, int i, int j)
 {
     int pivot = iArray[ i ];

     while(i < j)
     {
         while(i < j && iArray[ j ] >= pivot )
         {
             j --;
         }

         if(i < j)
         {
             iArray[ i ++ ] = iArray[ j ];
         }

         while(i < j && iArray[ i ] <= pivot)
         {
             i ++;
         }

         if(i < j)
         {
             iArray[ j -- ] = iArray[ i ];
         }
     }

     iArray[ i ] = pivot;

     return i;
 }

 void QuickSort(int *iArray, int low, int high)
 {
     if(low < high)
     {
         int pivotpos = Partition(iArray, low, high);

         QuickSort(iArray, low, pivotpos - 1);

         QuickSort(iArray, pivotpos + 1, high);
     }

 }
 int main()
 {
     int iArray[] = {1,0,9,3,7,2,-90,78,45,4,77,79,78,37,0,-1,2,3,6,9,5,4,78,78,78,1,1,1};

     int len = sizeof(iArray) / sizeof(int);

     QuickSort(iArray, 0, len - 1);

     for(int i = 0; i < len; ++ i)
     {
         printf("%3d ",iArray[ i ]);
     }

     printf("\n");
 }

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

 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的三分之一

 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速度相当，但是需要一个与输入缓冲一样大的缓冲区

 #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的六分之一，通常的实现是递归，但和快排不同，归并改循环极其容易

 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);
 }