經典排序算法實驗複雜性分析

十大經典排序算法：冒泡排序，插入排序，選擇排序，歸併排序，希爾排序（插入排序的變形），快速排序，堆排序， 計數排序，基數排序，桶排序。

理論上的分析各類算法的複雜性：

（1）冒泡排序：平均（期望）運行時間：O(n^2)；最好（輸入是排好序的數組）運行時間：O(n^2)；最差（輸入是逆序的數組）運行時間：O(n^2)。一般實際應用中會選擇修改的冒泡排序，這種情況下最好運行時間是O(n^2)。

（2）插入排序：平均（期望）運行時間：O(n^2)；最好（輸入是排好序的數組）運行時間：O(n)；最差（輸入是逆序的數組）運行時間：O(n^2)。在最好的情況每個插入要求常量時間。

（3）選擇排序：平均（期望）運行時間：O(n^2)；最好（輸入是排好序的數組）運行時間：O(n^2)；最差（輸入是逆序的數組）運行時間：O(n^2)。即使是完美的排好序的輸入也要求掃描整個數組。

（4）歸併排序：平均（期望）運行時間：O(n*log(n))；最好（輸入是排好序的數組）運行時間：O(n*(log(n))；最差（輸入是逆序的數組）運行時間：O(n*(log(n))。使用數組存儲數據時需要O(n)的存儲空間，使用鏈表時常量的存儲空間。

（5）希爾排序：使用高納德（1973）的增量序列[1, 4, 13, 40, 121...] 最差（輸入是逆序的數組）運行時間：O(n^1.5)。不穩定排序。

（6）快速排序：平均（期望）運行時間：O(n*log(n))；最好（輸入是排好序的數組）運行時間：O(n*(log(n))；最差（輸入是逆序的數組）運行時間：O(n^2)。

（7）堆  排  序：平均（期望）運行時間：O(n*log(n))；最好（輸入是排好序的數組）運行時間：O(n*(log(n))；最差（輸入是逆序的數組）運行時間：O(n*(log(n))；堆排序與待排數的初始位置無關。不穩定排序。

（8）計數排序：平均（期望）運行時間：O(n)；最好（輸入是排好序的數組）運行時間：O(n)；最差（輸入是逆序的數組）運行時間：O(n)。

（9）基數排序：平均（期望）運行時間：O(n)；最好（輸入是排好序的數組）運行時間：O(n)；最差（輸入是逆序的數組）運行時間：O(n)。

（10）桶  排  序：平均（期望）運行時間：O(n)；最好（輸入是排好序的數組）運行時間：O(n)；最差（所有待排序的數被散列到一個桶中）運行時間：O(n^2)。

    使用的兩個測試數據文件分別是FNRandomNum.txt和SNRandomNum.txt，其大小分別是10000， 30000；最初計劃使用三個數據集10000， 100000， 1000000，其中使用1000000的數據集時對內存要求爲常量的冒泡排序在win7,32位，4 GB RAM的Core 2主機上無法裝載運行。同時對100000大小的數據集使用歸併排序算法時內存無法裝載，爲了使實驗結果更具對比性，第二個使用了30000大小的數據集，以確保所有排序算法在現有主機上都可以運行。

生成測試 .txt文件

#include <stdio.h>
#include <stdlib.h>

#define FN 10000
#define TN 30000
#define SN 100000

main()
{
    int i, c;
    unsigned long x;
    FILE *frofp, *srofp, *trofp;

    frofp = fopen("FNRandomNum.txt", "w");
    srand((unsigned)time(NULL));
    for (i = 0; i < FN; i++) {
        c = rand();
        if (i != 0 && i % 15 == 0)
            putc('\n', frofp);
        fprintf(frofp, "%10d", c);
    }
    fclose(frofp);

    srofp = fopen("SNRandomNum.txt", "w");
    srand((unsigned)time(NULL));
    for (i = 0; i < SN; i++) {
        c = rand();
        c <<= 15;
        c ^= rand();
        c %= 100001;
        if (i != 0 && i % 15 == 0)
            putc('\n', srofp);

        fprintf(srofp, "%10d", c);
    }
    fclose(srofp);

    trofp = fopen("TNRandomNum.txt", "w");
    srand((unsigned)time(NULL));
    for (i = 0; i < TN; i++) {
        x = rand();
        x %= 30001;
        if (i != 0 && i % 15 == 0)
            putc('\n', trofp);

        fprintf(trofp, "%10d", x);
    }
    fclose(trofp);

    return 0;
}

1、冒泡排序bubble sort 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

void BubbleSort(int [], int);
void BucketSort(int [], int);

main()
{
    int c, i, len, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    BubbleSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("BubbleSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    BubbleSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    BubbleSort(vr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    BubbleSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    BubbleSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    BubbleSort(svr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);

    return 0;
}

void BubbleSort(int a[], int len)
{
    int i, j, temp;

    for (i = 0; i < len - 1; i++) {
        for (j = len - 1; j > i; j--) {
            if (a[j] < a[j-1]) {
                temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

2、插入排序 insertion sort

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

void InsertionSort(int [], int);

main()
{
    int c, i, len, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    InsertionSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("InsertionSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    InsertionSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    InsertionSort(vr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    InsertionSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    InsertionSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    InsertionSort(svr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
    return 0;
}

void InsertionSort(int a[], int len)
{
    int i, j, key;

    for ( j = 1; j < len; j++) {
        key = a[j];

        i = j - 1;
        while (i >= 0 && a[i] > key) {
            a[i+1] = a[i];
            i = i - 1;
        }
        a[i+1] = key;
    }
}

3、選擇排序 selection sort

#include <stdio.h>
#include <stdlib.h>
#include <time.h>


#define FN 10000
#define SN 30000


#define NELEMS(x) (sizeof(x) / sizeof(x[0]))


void SelectionSort(int [], int);


main()
{
    int c, i, len, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;


    i = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    SelectionSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("SelectionSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    SelectionSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    SelectionSort(vr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    SelectionSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    SelectionSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    SelectionSort(svr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);


    return 0;
}


void SelectionSort(int a[], int len)
{
    int i, j, mi, key, temp;


    for (i = 0; i < len - 1; i++) {
        mi = a[i];
        key = i;
        for (j = i + 1; j < len; j++) {
            if (a[j] < mi) {
                mi = a[j];
                key = j;
            }
        }
        temp = a[i];
        a[i] = a[key];
        a[key] = temp;
    }
}

4、歸併排序merge sort

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>


#define FN 10000
#define SN 30000


#define NELEMS(x) (sizeof(x) / sizeof(x[0]))


void MergeSort(int [], int, int);
void Merge(int [], int, int, int);


main()
{
    int c, i, low, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;


    i = 0;
    low = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    MergeSort(fr, low, FN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("MergeSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    MergeSort(fr, low, FN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    MergeSort(vr, low, FN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    MergeSort(sfr, low, SN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    MergeSort(sfr, low, SN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    MergeSort(svr, low, SN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);


    return 0;
}


void MergeSort(int a[], int p, int r)
{
    int q;


    if (p < r) {
        q = (p + r) / 2;
        MergeSort(a, p, q);
        MergeSort(a, q + 1, r);
        Merge(a, p, q, r);
    }
}


void Merge(int a[], int p, int q, int r)
{
    int n1, n2, i, j, k;


    n1 = q - p + 1;
    n2 = r - q;


    int ri[n1+1], lf[n2+1];
    for (i = 0; i < n1; i++)
        ri[i] = a[p + i];
    for (j = 0; j < n2; j++)
        lf[j] = a[q + j + 1];
    ri[n1] = INT_MAX;
    lf[n2] = INT_MAX;
    i = 0;
    j = 0;
    for (k = p; k <= r; k++) {
        if (lf[j] <= ri[i]) {
            a[k] = lf[j];
            j++;
        } else {
            a[k] = ri[i];
            i++;
        }
    }
}

5.希爾排序（shell sort)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

void ShellSort(int [], int);
int power(int, int);

main()
{
    int c, i, len, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    ShellSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("ShellSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    ShellSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    ShellSort(vr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    ShellSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    ShellSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    ShellSort(svr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);

    return 0;
}

void ShellSort(int a[], int len)
{
    int i, gap, j, k, temp, itv, key;

    key = 1;
    do {
        itv = (power(3, key) - 1) / 2;
        key++;
    }while (itv < ((float)len) / 3.0f + 0.5f);
    key -= 2;
    int in[key];
    for (i = key; i > 0; i--) {
        gap = (power(3, i) - 1) / 2;
        for (j = gap; j < len; j++) {
            temp = a[j];
            for (k = j; j >= gap && a[j] < a[j-gap]; j = j - gap)
                a[j] = a[j-gap];
            a[j] = temp;
        }
    }
}

int power(int base, int exp)
{
    int i, pro;

    pro = 1;
    for (i = 0; i < exp; i++)
        pro *= base;
    return pro;
}

6.快速排序（quick sort)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

void QuickSort(int [], int, int);
int Partion(int [], int, int);

main()
{
    int c, i, low, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    low = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    QuickSort(fr, low, FN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("QuickSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    QuickSort(fr, low, FN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    QuickSort(vr, low, FN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    QuickSort(sfr, low, SN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    QuickSort(sfr, low, SN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    QuickSort(svr, low, SN-1);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);
    return 0;
}

void QuickSort(int a[], int p, int r)
{
    int q;

    if (p < r) {
        q = Partion(a, p, r);
        QuickSort(a, p, q - 1);
        QuickSort(a, q + 1, r);
    }
}

int Partion(int a[], int p, int r)
{
    int i, j, temp;

    i = p - 1;
    for (j = p; j < r; j++) {
        if (a[j] <= a[r]) {
            i++;
            temp = a[j];
            a[j] = a[i];
            a[i] = temp;
        }
    }
    temp = a[i+1];
    a[i+1] = a[r];
    a[r] = temp;
    return i+1;
}

7.堆排序（heap sort)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

void HeapSort(int[], int);
void BuildMaxHeap(int [], int);
void MaxHeap(int [], int, int);

main()
{
    int c, i, len, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    HeapSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("HeapSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    HeapSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    HeapSort(vr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    HeapSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    HeapSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    HeapSort(svr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);

    return 0;
}

void HeapSort(int a[], int len)
{
    int i, temp, si;

    si = len;
    BuildMaxHeap(a, len);
    for (i = len - 1; i > 0; i--) {
        temp = a[i];
        a[i] = a[0];
        a[0] = temp;
        si = si - 1;
        MaxHeap(a, 0, si);
    }
}

void BuildMaxHeap(int a[], int len)
{
    int i, si, mid;

    si = len;
    mid = len / 2 - 1;
    for (i = mid; i>=0; i--)
        MaxHeap(a, i, si);
}

void MaxHeap(int a[], int i, int si)
{
    int lef, rig, largest, temp;

    lef = 2 * i + 1;
    rig = 2 * i + 2;
    if (lef < si && a[lef] > a[i])
        largest = lef;
    else
        largest = i;
    if (rig < si && a[rig] > a[largest])
        largest = rig;
    if (largest != i) {
        temp = a[i];
        a[i] = a[largest];
        a[largest] = temp;
        MaxHeap(a, largest, si);
    }
}

8.計數排序（count sort)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

void CountSort(int [], int [], int, int);
int maximum(int [], int);

main()
{
    int c, i, len, ran,
        fr[FN], vr[FN], ofr[FN],
        sfr[SN], svr[SN], osr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    CountSort(fr, ofr, FN, maximum(fr, FN));
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("CountSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    CountSort(ofr, fr, FN, maximum(ofr, FN));
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    CountSort(vr, ofr, FN, maximum(vr, FN));
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    CountSort(sfr, osr, SN, maximum(sfr, SN));
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    CountSort(osr, sfr, SN, maximum(ofr, SN));
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    CountSort(svr, osr, SN, maximum(svr, SN));
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);

    return 0;
}

void CountSort(int a[], int b[], int len, int ran)
{
    int i, j, k, m;
    int c[ran+1];

    for (i = 0; i <= ran; i++)
        c[i] = 0;
    for (j = 0; j < len; j++)
        c[a[j]]++;
    for (k = 1; k <= ran; k++)
        c[k] += c[k-1];
    for (m = len - 1; m >= 0; m--) {
        b[c[a[m]]-1] = a[m];
        c[a[m]]--;
    }
}

int maximum(int a[], int len)
{
    int i, maxval;

    maxval = a[0];
    for (i = 1; i < len; i++)
        if (maxval < a[i])
            maxval = a[i];
    return maxval;
}

9.基數排序（radix sort)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

void RadixSort(int [], int [], int, int);
void CountSort(int [], int [], int [], int[], int, int);

main()
{
    int c, i, len, sd, fd,
        fr[FN], vr[FN], ofr[FN],
        sfr[SN], svr[SN], osr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    sd = fd = 5;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    RadixSort(fr, ofr, FN, fd);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("RadixSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    RadixSort(ofr, fr, FN, fd);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    RadixSort(vr, ofr, FN, fd);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    RadixSort(sfr, osr, SN, sd);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    RadixSort(osr, sfr, SN, sd);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    RadixSort(svr, osr, SN, sd);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);

    return 0;
}

void RadixSort(int a[], int temp[], int len, int d)
{
    int i, j, k, m, ran;
    int bb[len], c[len];

    ran = 9;
    for (i = 0; i < len; i++)
            bb[i] = a[i];
    for (j = 0; j < d; j++) {
        for (k = 0; k < len; k++) {
            c[k] = bb[k] % 10;
            bb[k] = bb[k] / 10;
        }
        CountSort(a, c, temp, bb, len, ran);
        for (m = 0; m < len; m++)
            a[m] = temp[m];
    }
}

void CountSort(int a[], int b[], int temp[], int bb[], int len, int ran)
{
    int i, j, k, m, n;
    int c[ran+1], te[len];

    for (i = 0; i <= ran; i++)
        c[i] = 0;
    for (j = 0; j < len; j++)
        c[b[j]]++;
    for (k = 1; k <= ran; k++)
        c[k] += c[k-1];
    for (m = len - 1; m >= 0; m--) {
        temp[c[b[m]]-1] = a[m];
        te[c[b[m]]-1] = bb[m];
        c[b[m]]--;
    }
    for (n = 0; n < len; n++)
        bb[n] = te[n];
}

10.桶排序（bucket sort）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define FN 10000
#define SN 30000

#define NELEMS(x) (sizeof(x) / sizeof(x[0]))

typedef struct node *link;
struct node
{
    int item;
    link next;
};

void BucketSort(int [], int);

main()
{
    int c, i, len, fr[FN], vr[FN],
                   sfr[SN], svr[SN];
    double spent;
    FILE *fifp, *sifp, *fofp, *sofp;
    clock_t tic, toc;

    i = 0;
    fifp = fopen("FNRandomNum.txt", "r");
    fscanf(fifp, "%d", &c);
    while (!feof(fifp)) {
        fr[i++] = c;
        fscanf(fifp, "%d", &c);
    }
    fr[i] = c;
    fclose(fifp);
    i = 0;
    sifp = fopen("TNRandomNum.txt", "r");
    fscanf(sifp, "%d", &c);
    while (!feof(sifp)) {
        sfr[i++] = c;
        fscanf(sifp, "%d", &c);
    }
    sfr[i] = c;
    fclose(sifp);
    tic = clock();
    BucketSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("BucketSort:\n");
    printf("\t%10d elements average running time: %f seconds\n", FN, spent);
    tic = clock();
    BucketSort(fr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", FN, spent);
    for (i = 0; i < FN; i++)
        vr[i] = fr[FN - 1 - i];
    tic = clock();
    BucketSort(vr, FN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", FN, spent);
    tic = clock();
    BucketSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements average running time: %f seconds\n", SN, spent);
    tic = clock();
    BucketSort(sfr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements best running time: %f seconds\n", SN, spent);
    for (i = 0; i < SN; i++)
        svr[i] = sfr[SN - 1 - i];
    tic = clock();
    BucketSort(svr, SN);
    toc = clock();
    spent = (double)(toc - tic) / CLOCKS_PER_SEC;
    printf("\t%10d elements worst running time: %f seconds\n", SN, spent);

    return 0;
}

link nextSort(link);
int maximum(int [], int);
void BucketSort(int a[], int len)
{
    int i, j, pos, maxval;
    link buc[len], curr, nlist;

    maxval = maximum(a, len);
    for (i = 0; i < len; i++)
        buc[i] = NULL;
    for (i = 0; i < len; i++) {
        pos = (int)(a[i] * len / maxval);
        curr = (link)malloc(sizeof(*curr));
        curr->next = buc[pos];
        curr->item = a[i];
        buc[pos] = curr;
    }
    for (i = 0, j = 0; i < len; i++) {
        buc[i] = nextSort(buc[i]);
        nlist = buc[i];
        while(nlist) {
            a[j++] = nlist->item;
            nlist = nlist->next;
        }
    }
    for (i = 0; i < len; i++) {
        link hd;
        hd = buc[i];
        while (hd) {
            link nt;
            nt = hd;
            hd = hd->next;
            free(nt);
        }
    }
    free(buc);
}

link nextSort(link lis)
{
    struct node head;
    link slis, b, p, tmp;
    if (lis == NULL || lis->next == NULL)
        return lis;
    slis = &head;
    slis->next = NULL;
    for (p = lis; p != NULL; p = tmp) {
        tmp = p->next;
        for (b = slis; b->next != NULL; b = b->next)
            if (b->next->item > p->item)
                break;
        p->next = b->next;
        b->next = p;
    }
    return slis->next;
}

int maximum(int a[], int len)
{
    int i, maxval;

    maxval = a[0];
    for (i = 1; i < len; i++)
        if (maxval < a[i])
            maxval = a[i];
    return maxval;
}