各种排序算法代码（C语言版）

选择排序

#include <stdio.h>
/*
 * 选择排序
 * 稳定性：不稳定
 * 时间复杂度：O(N^2)
**/

void select_sort(int a[], int l, int r)
{
    for (int m_v, m_idx, t, i = l; i < r; ++i) {
        m_v = a[i]; m_idx = i;
        for (int j = i + ; j < r; ++j) {
            if (m_v > a[j]) {
                m_v = a[j];
                m_idx = j;
            }
        }
        t = a[i]; a[i] = a[m_idx]; a[m_idx] = t;
    }
}

int main(void)
{
    int a[];
    int n; scanf("%d", &n);
    for (int i = ; i < n; ++i) scanf("%d", &a[i]);
    select_sort(a, , n);
    for (int i = ; i < n; ++i) printf("%d ", a[i]);
    return ;
}

冒泡排序

#include <stdio.h>
/*
 * 冒泡排序
 * 稳定性：稳定
 * 时间复杂度：O(N^2)
**/

void bubble_sort(int a[], int l, int r)
{
    for (int i = l; i < r; ++i) {
        for (int j = l; j < r - i - ; ++j) {
            if (a[j] > a[j + ]) {
                int tmp = a[j];
                a[j] = a[j + ];
                a[j + ] = tmp;
            }
        }
    }
}

int main(void)
{
    int a[];
    int n; scanf("%d", &n);
    for (int i = ; i < n; ++i) scanf("%d", &a[i]);
    bubble_sort(a, , n);
    for (int i = ; i < n; ++i) printf("%d ", a[i]);
    return ;
}

插入排序

#include <stdio.h>
/*
 * 插入排序
 * 稳定性：稳定
 * 时间复杂度： O(N^2)
**/
void insert_sort(int a[], int l, int r)
{
    for (int tmp, j, i = l + ; i < r; ++i) {
        tmp = a[i], j = i - ;
        while (j >= l && tmp < a[j]) a[j+] = a[j--];
        a[j+] = tmp;
    }
}

int main(void)
{
    int a[];
    int n; scanf("%d", &n);
    for (int i = ; i < n; ++i) scanf("%d", &a[i]);
    insert_sort(a, , n);
    for (int i = ; i < n; ++i) printf("%d ", a[i]);
    return ;
}

希尔排序

#include <stdio.h>
/*
 * 希尔排序
 * 稳定性：不稳定
 * 时间复杂度：O(N*logN)
**/

void shell_insert_sort(int a[], int l, int r, int d)
{
    for (int tmp, j, i = l + d; i < r; ++i) {
        tmp = a[i], j = i - d;
        while (j >= l && tmp < a[j]) {
            a[j + d] = a[j];
            j -= d;
        }
        a[j + d] = tmp;
    }
}

void shell_sort(int a[], int l, int r)
{
    int d = (r - l) / ;
    while (d >= ) {
        shell_insert_sort(a, l, r, d);
        d /= ;
    }
}

int main(void)
{
    int a[];
    int n; scanf("%d", &n);
    for (int i = ; i < n; ++i) scanf("%d", &a[i]);
    shell_sort(a, , n);
    for (int i = ; i < n; ++i) printf("%d ", a[i]);
    return ;
}

归并排序

/*
 * 归并排序
 * 稳定性：稳定
 * 时间复杂度：O(N*logN)
**/
void merge(int a[], int n, int b[], int m, int t[])
{
    int i, j, k;
    i = j = k = ;
    while (i < n && j < m) {
        if (a[i] < b[j]) t[k++] = a[i++];
        else t[k++] = b[j++];
    }
    while (i < n) t[k++] = a[i++];
    while (j < m) t[k++] = b[j++];
}

void my_merge_sort(int a[], int l, int r, int t[])
{
    int mid = (l + r) >> ;
    int n = r - l;
    int i;
    if (l +  < r) {
        my_merge_sort(a, l, mid, t);
        my_merge_sort(a, mid, r, t);
        merge(a+l, mid-l, a+mid, r-mid, t);
        for (i = ; i < n; ++i) a[i + l] = t[i];
    }
}

void merge_sort(int a[], int l, int r)
{
    int *t = (int *)malloc((r-l) * sizeof (int));
    my_merge_sort(a, l, r, t);
    free(t);
}

堆排序

#include <stdio.h>
/*
 * 堆排序
 * 稳定性：不稳定
 * 时间复杂度：O(N*logN)
**/

// big top pile
void heap_adjust(int a[], int fa, int n)
{
    int cd = fa *  + ;
    while (cd < n) {
        if (cd +  < n && a[cd] < a[cd + ]) cd++;
        if (a[fa] >= a[cd]) break;
        int tmp = a[fa];
        a[fa] = a[cd];
        fa = cd;
        cd = fa *  + ;
        a[fa] = tmp;
    }
}

void build_heap(int a[], int n)
{
    // ignore leap node
    for (int i = (n - ) / ; i >= ; --i) {
        heap_adjust(a, i, n);
    }
}

void heap_sort(int a[], int l, int r)
{
    build_heap(a + l, r - l);
    for (int tmp, i = r - ; i > l; --i) {
        tmp = a[i]; a[i] = a[]; a[] = tmp;
        heap_adjust(a + l, , i);
    }
}

int main(void)
{
    int a[];
    int n; scanf("%d", &n);
    for (int i = ; i < n; ++i) scanf("%d", &a[i]);
    heap_sort(a, , n);
    for (int i = ; i < n; ++i) printf("%d ", a[i]);
    return ;
}

快速排序

/*
 * 快速排序
 * 稳定性：不稳定
 * 时间复杂度：O(N*logN)
**/
void quick_sort(int a[], int l, int r)
{
    if (l +  >= r) return ;
    int low = l, high = r;
    int key = a[l];
    while (low < high) {
        while (low < high && a[--high] >= key); a[low] = a[high];
        while (low < high && a[++low] < key); a[high] = a[low];
    }
    a[low] = key;
    quick_sort(a, l, low);
    quick_sort(a, low+, r);
}

基数排序

/*
 * 基数排序
 * 稳定性：稳定
 * 时间复杂度：O(d(n+radix)) [d个关键码，关键码的取值范围为radix]
**/
int tmp[];
void radix_sort(int arr[], int beg, int ed)
{
    static int a[] = {, , , , , , };
    int cnt[];    // 0~9十个数字
    int digit = ;  // 最大位数
    for (int i = beg; i < ed; ++i)
        while (arr[i] / a[digit + ] > ) digit++;

    // 从低位到高位依次排序
    for (int idx = ; idx <= digit; ++idx) {
        for (int i = ; i < ; ++i) cnt[i] = ;    // 桶计数清零
        for (int i = beg; i < ed; ++i) cnt[ arr[i]/a[idx]% ]++; // 统计每个数字出现的次数
        // 前缀和 统计每个数字前面的数字个数 这样就可以知道每个数字应该排在第几位了
        for (int i = ; i < ; ++i) cnt[i] += cnt[i - ];
        for (int i = ed - ; i >= beg; --i) tmp[ --cnt[arr[i]/a[idx]%] ] = arr[i];
        for (int i = beg, j = ; i < ed; ++i, ++j) arr[i] = tmp[j];
    }
}

测试性能

int a[];
double test(void(*fun)(int*, int, int), int range)
{
    for (int i = ; i < range; ++i) a[i] = rand();

    clock_t start = clock();
    fun(a, , range);
    clock_t finish = clock();

    //for (int i = 0; i < range; ++i) printf("%d\n", a[i]);

    return ((double)finish - start) / CLOCKS_PER_SEC;
}

int main()
{
    srand((unsigned)time(NULL));
    printf(" 数据范围    堆排序  归并排序 希尔排序 快速排序 插入排序 冒泡排序 选择排序 基数排序\n");
    for (int range = ; range <= ; range *= ) {
        printf("%9d %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f\n", range, test(heap_sort, range), test(merge_sort, range), test(shell_sort,  range),
        test(quick_sort, range), test(insert_sort, range), test(bubble_sort, range), test(select_sort, range), test(radix_sort, range));
    }
    for (int range = ; range <= ; range *= ) {
        printf("%9d %8.3f %8.3f %8.3f %8.3f %8.3f\n", range, test(heap_sort, range), test(merge_sort, range), test(shell_sort,  range),
                                    test(quick_sort, range), test(radix_sort, range));
    }

    return ;
}