常见的排序算法对比及实现C语言版本

/*文件命名为：sort.c

欢迎大家交流指正

*/

#include <stdio.h>

#include <stdlib.h>
#include <time.h>
#include <memory.h>
//#define _DEBUG
#ifdef _DEBUG
#define N       100
#else
#define N       100000
#endif
#define LOOP    1
#define BASE    10   // for radix sort
int A[N],A2[N],B[N];
int BUCKET[N/5+1][5]; // bucket sort 使用
int COUNT[N]; // counting sort 使用
void print_array(int *a, int nLen) {
    int i;
   #ifndef _DEBUG
    return;
   #endif    
    for (i=0;i<nLen;i++) 
        printf("%d, ", a[i]);
    printf("\n");
} // end of print_array()
void swap(int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}
int cmp(const void *a, const void *b) { 
    return (*(int *)a-*(int *)b);
}
void insertion_sort(int a[N]) {
    int i, j, temp;


    for (i=1; i<N; i++) {
        temp = a[i];
        j = i;
        while (j>0 && a[j-1] > temp) {
            a[j] = a[j-1];
            j--;
        }
        a[j] = temp;
    }
} // end of insertion_sort()
void selection_sort(int a[N]) {
    int i,j,max,temp;
    for (i=N-1;i>0;i--) {
        max = i;
        for (j=0;j<i;j++)
            if (a[j] > a[max])
                max = j;
        //swap (&a[max],&a[i]);
        temp = a[max];
        a[max] = a[i];
        a[i] = temp;
    }
} // end of selection_sort()
int partition (int* a, int left, int right) { 
    int index = left; 
    int pivot = a[index];
    int i=0;
    swap(&a[index], &a[right]); 
    for (i=left; i<right; i++)
        if (a[i] < pivot) // ascending 
            swap(&a[index++], &a[i]);
    swap(&a[right], &a[index]); 
    return index; 
} // end of partition (for my_qsort)
void my_qsort (int* a, int left, int right) {
    int i;
    if (left >= right) return; 
    int index = partition(a, left, right);
    my_qsort(a, left, index - 1); 
    my_qsort(a, index + 1, right); 
} // my_qsort()
void heapify(int* a,int i,int nLength)
{
    int nChild;
    for(;2*i+1<nLength;i=nChild) {
        //子结点的位置=2*（父结点位置）+1
        nChild=2*i+1;
        //得到子结点中较大的结点
        if(nChild<nLength-1 && a[nChild+1]>a[nChild])
            ++nChild;
        //如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
        if(a[i]<a[nChild])
            swap(&a[i],&a[nChild]);
        else
            //否则退出循环
            break;
    } // end of for
} // end of heapify
 
//堆排序算法, copy from 百度百科
void heap_sort(int* a,int length) {
    int i=0;
    //调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
    //length/2-1是最后一个非叶节点，此处"/"为整除
    for(i=length/2-1;i>=0;--i)
        heapify(a,i,length);
    //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
    for(i=length;i>0;--i) {
        //把第一个元素和当前的最后一个元素交换，
        //保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
        swap(&a[0],&a[i]);
        //不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
        heapify(a,0,i);
    }
} // end of heap_sort()


void merge(int *a, unsigned int first, unsigned int mid, unsigned int last) {
    int i,j,k;
    for (i=first,j=mid+1,k=first;;) {
        if (i > mid) {
            memcpy(&A2[k],&a[j],sizeof(int)*(last-j+1));
            break;
        }
        if (j > last) {
            memcpy(&A2[k],&a[i],sizeof(int)*(mid-i+1));
            break;
        }
        if (a[i] <= a[j]) {
            A2[k] = a[i];
            k++; i++;
        }
        else {
            A2[k] = a[j];
            k++; j++;
        }
    }
    memcpy(a+first,&A2[first],sizeof(int)*(last-first+1));
} // end of merge()
void merge_sort(int *a, unsigned int first, unsigned int last) {
    int mid=0;
    if (first < last) {
        mid = ((first & last) + ((first ^ last) >> 1));
        merge_sort(a,first,mid);
        merge_sort(a,mid+1,last);
        merge(a,first,mid,last);
    }
} // end of merge_sort();
void radix_sort(int *a) {
    int i, m=a[0], exp=1, bucket[BASE];
    for (i=1;i<N;i++)
        if (a[i] > m)
            m = a[i];
    while (m / exp > 0) {
        memset(bucket,0,sizeof(int)*BASE);
        for (i=0;i<N;i++)
            bucket[(a[i]/exp) % BASE]++;
        for (i=1;i<BASE;i++)
            bucket[i] += bucket[i-1];
        for (i=N-1;i>=0;i--)
            A2[--bucket[(a[i]/exp) % BASE]] = a[i];
        memcpy(a,A2,sizeof(int)*N);
        exp *= BASE;
    }
} // end of radix_sort()
void bucket_sort(int *a) {
    int i,j,k;
    for (i=0;i<N/5+1;i++)
        for (j=0;j<5;j++)
            BUCKET[i][j] = -1;
    for (i=0;i<N;i++) {
        k = a[i] / 5;
        for (j=0;j<5;j++)
            if (BUCKET[k][j] == -1) {
                BUCKET[k][j] = a[i];
                break;
            }
    }
    for (i=0,j=0;i<N;i+=5,j++) {
        memcpy(a+i,BUCKET[j],sizeof(int)*5);
    }
    insertion_sort(a);
} // end of bucket_sort()

void counting_sort(int *a) {
    int i;
    for (i=0;i<N;i++)
        COUNT[i] = 0;
    for (i=0;i<N;i++)
        COUNT[a[i]]++;
    for(i=1;i<N;i++)
        COUNT[i] += COUNT[i-1];
    for (i=N;i>0;i--) {
        A2[COUNT[a[i-1]]-1] = a[i-1];
        COUNT[a[i-1]]--;
    }
    memcpy(a,A2,sizeof(int)*N);
} // end of counting_sort()

int main(void) {
    time_t t;
    int i=0,j=0,temp=0,sum=0;
    clock_t begin,end;
    time(&t);
    srand(t);
   
    // init array A
   
    for (i=0;i<N;i++)
        A[i] = i;
   
    // Scramble A
   
    for (i=N-1;i>0;i--) {
        j = rand() % (i+1);
        temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
    print_array(A,N);
   
    // Backup array A to array B
   
    memcpy(B,A,sizeof(int)*N);
   
    // Insertion sort 
   
    sum = 0;
    //begin = clock();
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        insertion_sort(A);
        end = clock();
        sum = sum + (end - begin);
    }
    //end = clock();
    //sum = end - begin;
    printf("Time of insertion sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // Selection sort 
   
    sum = 0;
    //begin = clock();
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        selection_sort(A);
        end = clock();
        sum = sum + (end - begin);
    } 
    //end = clock();
    //sum = end - begin;
    printf("Time of selection sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // qsort in C 
   
    sum = 0;
    //begin = clock();
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        qsort(A,N,sizeof(A[0]),cmp);
        end = clock();
        sum = sum + (end - begin);
    }
    //end = clock();
    //sum = end - begin;
    printf("Time of qsort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // my_qsort 
   
    sum = 0;
    //begin = clock();
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        my_qsort(A,0,N-1);
        end = clock();
        sum = sum + (end - begin);
    }
    //end = clock();
    //sum = end - begin;
    printf("Time of quick sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // heap_sort 
   
    sum = 0;
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        heap_sort(A,N-1);
        end = clock();
        sum = sum + (end - begin);
    }
    printf("Time of heap sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // merge_sort 
   
    sum = 0;
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        merge_sort(A,0,N-1);
        end = clock();
        sum = sum + (end - begin);
    }
    printf("Time of merge sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // radix_sort 
   
    sum = 0;
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        radix_sort(A);
        end = clock();
        sum = sum + (end - begin);
    }
    printf("Time of radix sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // bucket_sort 
   
    sum = 0;
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        bucket_sort(A);
        end = clock();
        sum = sum + (end - begin);
    }
    printf("Time of bucket sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
   
    // counting_sort 
   
    sum = 0;
    for (i=0;i<LOOP;i++) {
        memcpy(A,B,sizeof(int)*N);
        begin = clock();
        counting_sort(A);
        end = clock();
        sum = sum + (end - begin);
    }
    printf("Time of counting sort=[%f]\n",(float)sum / LOOP / CLOCKS_PER_SEC);
    print_array(A,N);
    return 0;
} // end of main()