比快速排序还快的计数排序

支持负数排序，用到malloc函数动态申请空间，排较大的数时不会发生内存溢出

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<malloc.h>
//计数排序
#define N 1000
int ot[N];
void prin(int t2[],int b,int n)
{
    int i;
    for(i=b; i<n; i++)
    {
        printf("%d ",t2[i]);
    }
    printf("\n");
}
int Ysort(int t[],int n)
{
    int j;
    for(j=0; j<N-1; j++)
    {
        if(t[j]>t[j+1])
        {
            return 0;
        }
    }
    return 1;
}
void esd(int t[],int n,int min,int max)
{
    int i;
    srand((unsigned)time(NULL));
    for(i=0; i<n; i++)
    {
        t[i]=rand()%(max-min)+min;
    }
}
void shusort(int t[],int n)
{
    int i,j,max,min;
    max=t[0];
    for(i=1; i<N; i++)
    {
        if(max<t[i])
        {
            max=t[i];
        }
    }
    min=t[0];
    for(i=1; i<N; i++)
    {
        if(min>t[i])
        {
            min=t[i];
        }
    }
    int r=max-min;
    int *f=(int *)malloc(sizeof(int)*(r+1));
    for(i=0; i<r+1; i++)
    {
        f[i]=0;
    }
    //printf("r:%d   ",r);
    for(i=0; i<N; i++)
    {
        f[t[i]-min]++;
    }
    j=0;
    for(i=0; i<r+1; i++)
    {
        if(f[i]!=0)
        {
            while(f[i]--)
            {
                t[j]=i+min;
                j++;
            }
        }
    }
}
int main()
{
    int min=-100;
    int max=1000;
    esd(ot,N,min,max);
    //prin(ot,0,N);
    printf("size:%d\n",N);
    printf("min:%d  max:%d\n",min,max);
    int b,e;
    b=clock();
    shusort(ot,N);
    e=clock();
    printf("running time:%dms\n",(e-b));
    if(Ysort(ot,N))
    {
        printf("sort:yes\n");
    }
    else
    {
        printf("sort:no\n");
    }
    printf("排序后数组前100个:\n"); 
    prin(ot,0,100);
    printf("排序后数组后100个:\n"); 
    prin(ot,N-100,N);
    printf("__FUNCTION__");
    return 0;
}

测试截图