线性时间排序

之前所学的排序都是基于比较的，通过两数的比较得出数的大小顺序，基于比较的算法最优的时间复杂度为n*lg(n)。

而计数排序采用了另一种方式，没有比较，让人眼前一亮。但需要特定的环境下才能行。比如输入数组需要是0~k之间的整数。

但他至少让排序能在线性时间O(n)内完成。

基数排序弥补了计数排序排列大数时需太多内存的缺陷，而且基数排序排列大数时时间也快一些。我的这个基数排序还可以改进。

#include<stdio.h>
#include<math.h>

//计数排序，A为输入数组，B为输出数组，n为数组大小,k为数组中最大的数。
//时间复杂度为O(n+k)，取决于k，当k为O(n)时，则为线性时间。
//缺点为会浪费太多内存空间。
void COUNTING_SORT(int A[],int B[],int n,int k){
    int *C=malloc((k+1)*sizeof(int));
    int i,j=0;
    k=k+1;
    for(i=0;i<k;i++)
        C[i]=0;
    for(i=0;i<n;i++)
        C[A[i]]++;
    /*
    for(i=0,j=0;i<k;i++)
        while(C[i]>0){
            B[j]=i;
            j++;
            C[i]--;
        }    
    */
    for(i=1;i<k;i++)
        C[i]=C[i-1]+C[i];
    for(i=n-1;i>=0;i--){//排序稳定性
        B[C[A[i]]-1]=A[i];
        C[A[i]]--;
    }
}

//基数排序，n为数组大小，d为数组中最大数的长度;
//h为进制，相当于计数排序中的k，可见减小了所需空间;
//时间复杂度为O(d(n+h))
void RADIX_SORT(int A[],int n,int d,int h){
    int i;
    int *C=malloc(h*sizeof(int));
    int *B=malloc(n*sizeof(int));
    int j=0;
    for(i=1;i<=d;i++){
        for(j=0;j<h;j++)
            C[j]=0;
        for(j=0;j<n;j++)
            C[((int)(A[j]/(pow(h,i-1)))%h)]++;
        for(j=1;j<h;j++)
            C[j]=C[j]+C[j-1];
        for(j=n-1;j>=0;j--){//排序稳定性
            B[C[((int)(A[j]/(pow(h,i-1)))%h)]-1]=A[j];
            C[((int)(A[j]/(pow(h,i-1)))%h)]--;
        }
        for(j=0;j<n;j++)
            A[j]=B[j];
    }
}

void main(){
    int i;
    int n;
    int A[8]={2,5,3,0,29,123,3200,38};
    int B[8]={0};
    n=sizeof(A)/sizeof(int);
    //COUNTING_SORT(A,B,n,3200);
    RADIX_SORT(A,n,4,10);
    for(i=0;i<n;i++)
        printf("%d	",A[i]);
    printf("
");
}

推荐学习基数排序地址：http://www.cnblogs.com/hazir/archive/2011/05/05/2447290.html