排序算法总结（算法导论）

排序算法是众多算法的基础，是实际工程中真正需要用到的算法之一。

在数据的组织中，排序因为能将数据变得有序，往往能带来访问效率的提高。另一方面，在有些时候，排序算法中前k大值等的求取本身就是直接需求。

数据hash算法是与排序相匹敌的另一类高效访问算法，效率高到O(1)，但hash算法只能用于普通的插入查找，不能用于需要比较数值的情况，另一方面，对于小规模数据，hash算法的实际代码长度抵消了复杂度优势。

纸牌游戏中的插入排序通常是身边最能接触到的最简单排序算法，而堆排序则是一种稳定高效的排序算法。本文将由简入繁介绍相关的排序算法。

1、插入排序

int sort_insertion(int* data, int n){
    for (int i = 1; i<n; i++){
        //insert data[i] into sorted array data[0:i-1];
        int j = 0;
        int iv = data[i];
        for (j = i-1; j >= 0 && data[j]>iv; j--){
            data[j + 1] = data[j];
        }
        data[j + 1] = iv;
    }
    return 0;
}

这个算法原理是，依次将第 i 个数插入在 之前排好序的 i 大小的队列中，复杂度为 O(n^2)。

2、冒泡排序

int sort_up(int *data, int n){
    for (int i = 0; i<n; i++){
        for (int j = i + 1; j<n; j++){
            if (data[i] > data[j]){
                int temp = data[i];
                data[i] = data[j];
                data[j] = temp;
            }
        }
    }
    return 0;
}

这个算法原理是将余下的数依次上翻两两比较，从而将最小的数浮到顶部。1和2的算法简单，适合于小规模数据，由于其代码简短的优点，即使复杂度为O（n^2），效率依然不错。

3、快速排序

int sort_quick(int *data, int p, int q){
    if (p >= q){
        return 0;
    }
    int sep = data[q];
    int d = p - 1;
    for (int i = p; i<q; i++){
        if (data[i] < sep){
            d++;
            int temp = data[i];
            data[i] = data[d];
            data[d] = temp;
        }
    }
    d++;
    data[q] = data[d];
    data[d] = sep;

    sort_quick(data, p, d - 1);
    sort_quick(data, d + 1, q);
    return 0;
}

这个算法原理是用尾部数将数据分成大小两段，再分别递归。复杂度为 O(n logn)，但是在极端情况下，比如数据已经排好序的情况下，复杂度退化为 O（n^2）。

4、计数排序

//k = max(data(n))
int sort_count(int* data, int k, int n){
    int *a = new int[k];
    int *b = new int[n];
    memset(a, 0, k*sizeof(int));
    memset(b, 0, n*sizeof(int));
    for (int i = 0; i < n; i++){
        a[data[i]] ++;
    }
    for (int i = 1; i < k; i++){
        a[i] = a[i - 1] + a[i];
    }
    for (int i = n-1; i >= 0; i--){
        b[a[data[i]]-1] = data[i];
        a[data[i]]--;
    }
    memcpy(data, b, n*sizeof(int));
    delete[]a;
    delete[]b;
    return 0;
}

计数排序时间复杂度为O(k+n)，因为他并不是比较排序算法，所以下界优于 O( nlogn )。一个优点，它是稳定的。一个缺点，它不是原地的。

5、基数排序

技术排序利用了计数排序稳定性的特点。

SORT_RADIX(A, d)
for i<-1, d
    do use a stable sort to sort array A on digit i

基数排序时间复杂度为O(d*(n+k))。

6、桶排序

当数据的输入符合均匀分布时，可以以线性期望时间运行。

BUCKET_SORT(A, n)
    for i in 1 to n:
        do insert A[i] into list B[ |n*A[i]|下界 ]
    for i in 0 to n-1:
        do sort B[i] with insertion sort;
    concatenate the list B[0], B[1], ..., B[n-1] together in order

时间复杂度为O(n* (2-1/n))，即O(n).

7、归并排序

归并排序是一种分治合并策略。

int sort_merge(int *a, int p, int r){
    if (p >= r){
        return 0;
    }
    int q = (p + r + 1) / 2;
    int *b1 = new int[q - p + 1];
    int *b2 = new int[r - q + 1 + 1];
    memcpy(b1, a, (q - p)*sizeof(int));
    memcpy(b2, a + q, (r - q + 1)*sizeof(int));
    sort_merge(b1, 0, q - p - 1);
    sort_merge(b2, 0, r - q);
    b1[q - p] = b2[r - q + 1] = 0x7fffffff;
    for (int k = p, i = 0, j = 0; k <= r; k++){
        if (b1[i] < b2[j]){
            a[k] = b1[i];
            i++;
        }
        else{
            a[k] = b2[j];
            j++;
        }
    }
    delete[]b1;
    delete[]b2;
    return 0;
}

归并排序时间复杂度为O(nlogn)

8、堆排序

//a[1:n]
int max_heap(int *a, int i, int n){
    while (i < n){
        if (a[i] < a[i * 2] && i * 2 == n){
            swap(a[i], a[i * 2]);
            break;
        }
        else if (a[i] < a[i * 2] && i * 2 + 1 <= n && a[i * 2] >= a[i * 2 + 1]) {
            swap(a[i], a[i * 2]);
            i = i * 2;
        }
        else if (a[i]<a[i * 2 + 1] && i * 2 + 1 <= n && a[i * 2 + 1]>a[i * 2]){
            swap (a[i], a[i * 2 + 1]);
            i = i * 2 + 1;
        }
        else{
            break;
        }
    }
    return 0;
}

int bulid_max_heap(int *a, int n){
    for (int i = n / 2; i >= 1; i--){
        max_heap(a, i, n);
    }
    return 0;
}

int heap_sort(int *a, int n){
    bulid_max_heap(a, n);
    for (int i = n; i >= 1; i--){
        swap (a[i], a[1]);
        max_heap(a, 1, i - 1);
    }
    return 0;
}

堆排序时间复杂度为O(nlogn)。