插入排序 | 冒泡排序 | 希尔排序 | 堆排序 | 快速排序 | 选择排序 | 归并排序

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <limits.h>
typedef int EleType;
typedef int (*CompFunc)(void *,void *);
int IntComp(void * a,void *b)
{
    if(*(int *)a > *(int *)b) return 1;
    if(*(int *)a == *(int *)b) return 0;
    if(*(int *)a < *(int *)b) return -1;
}
void insertion_sort(EleType A[],int N,CompFunc f)
{
    int step;
    EleType tmp;
    int i;
    for(step = 1; step < N; ++step)
    {
        tmp = A[step];
        for(i = step -1; i >= 0; --i)
        {
            if(f(&A[i],&tmp) > 0)
            {
                A[i+1] = A[i];
            }
            else //退出！！！！！！！
                break;                
        }
        A[i+1] = tmp;
    }
}
void bubble_sort(EleType A[],int N,CompFunc f)
{
    int step,i;
    
    EleType tmp;
    int flag = 0;
    for(step = 0; step < N-1; ++step)
    {
        flag = 0;
        for(i = N-1; i > step ; --i)
        {
            if(f(&A[i-1],&A[i]) > 0)
            {
                // swap
                tmp = A[i-1];
                A[i-1] = A[i];
                A[i] = tmp;
                flag = 1;
            }
            else
                continue;
        }
        if(!flag)
            break;
    }
}

void shell_sort(EleType A[],int N,CompFunc f)
{
    int step,i,h;
    EleType tmp;
    // determine start of h
    for(h = 1; h < N/9; h = 3*h+1)
        ;
    for(; h >=1; h = h/3)
    {
        for(step = h; step < N; step++)
        {
            tmp = A[step];
            for(i = step-h; i >=0; i-=h)
            {
                if( f(&tmp,&A[i]) <0 )
                {
                    A[i+h] = A[i];
                }//退出
                else 
                    break;
            }
            A[i+h] = tmp;
        }
    }
    
}

// heapsort
// 第一个元素位置为0
#define LeftChild(i) (2*(i)+1)


void print_array(EleType A[],int N)
{
    for(int i = 0; i < N; ++i)
        printf("%3d",A[i]);
    printf("\n");
}
void percdown(EleType A[],int i, int N,CompFunc f)
{
    int Child;
    EleType tmp;
    for(tmp = A[i]; LeftChild(i) < N; i = Child)
    {
        Child = LeftChild(i);
        if(Child != N-1 && f(&A[Child+1] ,&A[Child])>0 )
            Child++;
        if(f(&tmp,&A[Child]) < 0)
            A[i] = A[Child];
        else
            break;
    }
    A[i] = tmp;
}

void heap_sort(EleType A[], int N,CompFunc f)
{
    int i;
    EleType tmp;
    for(i = N/2; i >= 0; i--)
    {
        percdown(A,i,N,IntComp);
        //#ifdef DEBUG
        //print_array(A,N);
        //#endif
    }
    for(i = N-1; i > 0; i--)
    {
        tmp = A[i];
        A[i] = A[0];
        A[0] = tmp;
        percdown(A,0,i,IntComp);
    }
}

// quicksort
int qsort_partition(EleType A[],int p,int q,CompFunc f)
{
    int rd = (((double)rand())/((double)RAND_MAX))*(q-p) + p;
    EleType tmp;
    tmp = A[p];
    A[p] = A[rd];
    A[rd] = tmp;
    
    int i = p;    int j = p+1;
    
    while(j <= q)
    {
        if( f(&A[p],&A[j]) > 0 )
        {
            ++i;
            tmp = A[i];
            A[i] = A[j];
            A[j] = tmp;
            ++j;
        }
        else
            ++j;
    }
    tmp = A[i]    ;
    A[i]=A[p];
    A[p] = tmp;
    return i;
}
void qsort_recursion(EleType A[],int p, int q, CompFunc f)
{
    if(p < q)
    {
        int r = qsort_partition(A,p,q,f);
        qsort_recursion(A,p,r-1,f);
        qsort_recursion(A,r+1,q,f);
    }
}
void quick_sort(EleType A[],int N,CompFunc f)
{
    srand((unsigned int )time(NULL));
    qsort_recursion(A,0,N-1,f);
}
// selection sort
void selection_sort(EleType A[], int N, CompFunc f)
{
    EleType tmp;
    int max_index;
    for(int i = N-1; i > 0; i--)
    {
        max_index = i;
        for(int j = 0; j < i; ++j)
        {
            if( f( &A[max_index] , &A[j] ) < 0 )
            {
                max_index = j;
            }
        }
        tmp = A[max_index];
        A[max_index] = A[i];
        A[i] = tmp;
    }
}
// merge sort
void merge_divide(EleType A[],int p, int q,CompFunc f)
{
    if( q - p < 1 )  return ;
    // divide routine
    int mid = (p + q) /2;
    merge_divide(A, p , mid, f);
    merge_divide(A,mid+1, q, f);
    // merge routine
    int * tmp =(int *) malloc(sizeof(EleType) * (q - p + 1) );
    int i, m, n;
    m = p; n = mid + 1;
    i = 0;
    while(m <= mid && n <= q)
    {
        if( f( &A[m], &A[n]) < 0)
        {
            tmp[i++] = A[m++];
        }else
        {
            tmp[i++] = A[n++];
        }
    }
    while(m <= mid)
        tmp[i++] = A[m++];
    while(n <= q)
        tmp[i++] = A[n++];
    
    if(i != q - p +1) 
    {
        printf("Error: p = %d, q = %d\n",p,q);
    }
    
    // copy back
    int j = p;
    for(i = 0; i <= q-p; i++)
    {
        A[j++]  =tmp[i];
    }
    free(tmp);
}
void merge_sort(EleType A[], int N, CompFunc f)
{
    merge_divide(A,0,N-1,f);
}


#define ITEMNUM 2000
 int main()
 {
 
    int i;
     int A1[ITEMNUM ],A2[ ITEMNUM],A3 [ITEMNUM],A4[ITEMNUM];
     srand((unsigned int )time( NULL));
     for(i = 0; i < ITEMNUM; ++i )
     {
          A4[i] = A1 [i]= A2[i]=A3 [i]= rand();
     }
     clock_t start,finish;
     
     double d1,d2,d3,d4;
     
     merge_sort(A1,ITEMNUM,IntComp);
     quick_sort(A3,ITEMNUM,IntComp);
     shell_sort(A4,ITEMNUM,IntComp);
     
     for(i = 0; i < ITEMNUM; ++i )
     {
          printf("%5d %5d %5d %5d\n",A2[i],A1[i],A3[i],A4[i]);
     }
     
     
     //insertion_sort(A1,ITEMNUM,IntComp);
     //bubble_sort(A2,ITEMNUM,IntComp);
/*     
     start = clock();
     qsort(A1,ITEMNUM,sizeof(EleType),IntComp);
     finish = clock();
     d1 = finish - start;
     
     start = clock();
     quick_sort(A2,ITEMNUM,IntComp);
     finish = clock();
     
     d2 = finish - start;
     
     
     start = clock();
     shell_sort(A3,ITEMNUM,IntComp);
     finish = clock();
     
     d3 = finish - start;
     
     start = clock();
     heap_sort(A4,ITEMNUM,IntComp);
     finish = clock();
     
     d4 = finish - start;
     printf("qsort time spending: %f\n",d1);
     printf("quick sort time spending:%f\n",d2);
     printf("shell sort time spending: %f\n", d3);
     printf("heap sort time spending: %f\n",d4);
     */
     
     /*
      for(i = 0; i < ITEMNUM; ++i )
     {
          printf ("%10d%10d%10d\n",A1[i ],A2[ i],A3[i ]);
     }
*/
// test heap sort
/*
    int A[] = {3,5,6,8,9,4,1,7,2,0};
    int N = sizeof(A)/sizeof(A[0]);
    print_array(A,N);
    
    heap_sort(A,N);
    
    printf("result:\n");
    print_array(A,N);
    
    
    return 0;*/
    

 }