an improved counting sort for handling negative integers, also take an easy performance compare

#include <stdio.h>
#include <stdlib.h>
#define MAX_LENGTH 9999
void print_array(const int a[],int size)
{
    int i=0;
    for(i=0;i<size;i++)
    {
        printf("%d,",a[i]);
    }
    printf("\n");
}

/*
assume a[i]>0
*/
void counting_sort(const int a[],int b[],int size,int maxvalue)
{
    int i=0;
    for(i=0;i<size;i++)
    {
        b[i]=0;
    }

    int temp[maxvalue+1];
    for(i=0;i<=maxvalue;i++)
    {
        temp[i]=0;
    }

    for(i=0;i<size;i++)
    {
        temp[a[i]]+=1;
    }

    for(i=1;i<=maxvalue;i++)
    {
        temp[i]=temp[i]+temp[i-1];
    }

    for(i=size-1;i>=0;i--)
    {
        b[temp[a[i]]-1]=a[i];
        temp[a[i]]=temp[a[i]]-1;
    }
}

/*
handle a[i] <0
*/
void counting_sort2(const int a[],int b[],int size,int maxvalue)
{
    int i=0;
    int copyofa[size];
    int min=0;
    for(i=0;i<size;i++)
    {
        b[i]=0;
        if(min>a[i])
        {
            min=a[i];
        }
    }

    int newmaxvalue=maxvalue-min;
    for(i=0;i<size;i++)
    {
        copyofa[i]=a[i]-min;
    }

    int temp[newmaxvalue+1];
    for(i=0;i<=newmaxvalue;i++)
    {
        temp[i]=0;
    }

    for(i=0;i<size;i++)
    {
        temp[copyofa[i]]+=1;
    }

    for(i=1;i<=newmaxvalue;i++)
    {
        temp[i]=temp[i]+temp[i-1];
    }

    for(i=size-1;i>=0;i--)
    {
        b[temp[copyofa[i]]-1]=copyofa[i];
        temp[copyofa[i]]=temp[copyofa[i]]-1;
    }

    for(i=0;i<size;i++)
    {
        b[i]=b[i]+min;
    }
}

void bubble_sort(const int a[],int b[],int size)
{
    int i=0;
    int j=0;
    int temp;

    for(i=0;i<size;i++)
    {
        b[i]=a[i];
    }

    for(i=0;i<size;i++)
    {
        for(j=i;j<size;j++)
        {
            if(b[j]<b[i])
            {
                temp=b[i];
                b[i]=b[j];
                b[j]=temp;
            }
        }
    }
}

the second counting method is improved for handing negative integers.

the first is O(n+k), the second is twice: O(2n+2k).

write  a test program to compare these three subroutines,

int a[MAX_LENGTH];
    int b[MAX_LENGTH];

    int i=0;
    for(i=0;i<MAX_LENGTH;i++)
    {
        a[i]=rand();
        b[i]=0;
    }
    for(i=0;i<1000;i++)
    {
        bubble_sort(a,b,MAX_LENGTH);
        counting_sort2(a,b,MAX_LENGTH,RAND_MAX);
        counting_sort(a,b,MAX_LENGTH,RAND_MAX);
    }

the result as follow:

we can see it’s very obvious that a O(n²) algorithm is heavy slower than O(n+k). to sort 9999 random integers it will cost 195.5ms each time sorting use bubble but only 0.17 ms by using counting method(0.35 for the second coutning sort, because its running time is O(2n+2k))