排序算法比较（归并，堆，快速，冒泡)

#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
#include<time.h>
#define MAXSIZE 100000

/******两路归并排序***************************/
void merge(int A[], int low, int mid, int high){
    int i, j;
    i = low;
    j = mid+1;
    int k = 0;
    int *temp = (int *)malloc(sizeof(int)*MAXSIZE);//分配临时数组，存放有序序列
    while (i < mid+1 && j <= high){
        if (A[i] > A[j]){
            temp[k++] = A[j++];    
        }
        else {
            temp[k++] = A[i++];
        }
    }
    while (i <= mid){
        temp[k++] = A[i++];
    }
    while (j <= high){
        temp[k++] = A[j++];
    }
    for (i = 0; i < k; ++i){
        A[low + i] = temp[i];
    }
    free(temp);//释放临时数组
}
void mergeSort(int A[],int low, int high){
    if (low < high){
        int mid = (low+high)/2;
        mergeSort(A,low,mid);//归并排序前半段
        mergeSort(A,mid+1,high);//归并排序后半段
        merge(A,low,mid,high);//组合两个有序序列
    }
}

/******冒泡排序***************************/
void upSort(int R[], int n){
    int i, j, temp;
    int flag;
    for (i = n -1 ; i >= 1; --i){
        flag = 0;//0为未进行排序
        for (j = 1; j <= i; ++j){
            if (R[j-1] > R[j]){
                temp = R[j-1];
                R[j-1] = R[j];
                R[j] = temp;
                flag = 1;
            }
        }
        if (flag == 0) return ;
    }
}

/******堆排***************************/
void Sift(int r[], int low, int high){
    int i, j;
    int temp;
    i = low;
    j = i*2;
    temp = r[i];
    while (j <= high){
        if (j < high && r[j]<r[j+1]){
            ++j;
        }
        if (r[j] > temp){
            r[i] = r[j];
            i = j;
            j = i*2;
        }
        else break;
    }
    r[i] = temp;
}
void heapSort(int r[], int n){
    int i, temp;
    for (i = n/2; i >= 1; --i){
        Sift(r,i,n);
    }
    for (i = n; i >= 2; --i){
        temp = r[1];
        r[1] = r[i];
        r[i] = temp;
        Sift(r,1,i-1);
    }
}

/******快排***************************/
void quickSort(int R[],int low, int hi){
    int i, j;
    i = low;
    j = hi;
    if (low < hi){
        int temp = R[low];
        while (i < j && R[j] > temp) --j;
        if (i < j){
            R[i] = R[j];
            ++i;
        }
        while (i < j && R[i] < temp) ++i;
        if (i < j){
            R[j] = R[i];
            --j;
        }
        R[i] = temp;
        quickSort(R,i+1,hi);
        quickSort(R,low,i-1);
    }
    
}
int main()
{
    int start, end;
    int R[MAXSIZE];
    
    for (int i = 0; i < MAXSIZE; ++i){
        R[i] = rand();
    }
    start = clock();
    mergeSort(R,0,MAXSIZE-1);
    end = clock();
    printf("归并排序：%d毫秒\n",(end - start));
    
    for (int i = 0; i < MAXSIZE; ++i){
        R[i] = rand();
    }
    start = clock();
    heapSort(R,MAXSIZE-1);
    end = clock();
    printf("堆排序：%d毫秒\n",(end - start));
    
    for (int i = 0; i < MAXSIZE; ++i){
        R[i] = rand();
    }
    start = clock();
    quickSort(R,0,MAXSIZE-1);
    end = clock ();
    printf("快速排序：%d毫秒\n",(end - start));

    for (int i = 0; i < MAXSIZE; ++i){
        R[i] = rand();
    }
    start = clock();
    upSort(R,MAXSIZE);
    end = clock();
    printf("冒泡排序：%d毫秒\n",(end - start));
    return 0;
}

对MAXSIZE组随机数据进行比较：