高等排序算法

1. 归并排序

基本思想：利用分治法，将局部数组分割成两个局部数组，再对两局部数组执行归并排序，最后通过归并方法将两个已排序的局部数组整合成一个数组。

伪代码如下：

merge(A, left, mid, right)
    n1 = mid -left
    n2 = right -mid
    // 生成L[0 ... n1], R[0 ... n2]
    for i = 0 to n1-1
        L[i] = A[left + i]
    for i = 0 to n2-1
        R[i] = A[mid+i]
    L[n1] = INF //一个足够大的值
    R[n2] = INF
    i, j = 0
    for k = left to right -1
        if L[i] <= R[j]
            A[k] = L[i]
            i++
        else
            A[k] = R[j]
            j++

MergeSort(A, left, right)
    if left + 1 < right
        mid = (left+right)/2
        MergeSort(A, left, mid)　　//利用递归方式容易导致递归深度过深，使得栈溢出
        MergeSort(A, mid, right)
        merge(A, left, mid, right)

　　

2. 快速排序

基本思想：先可任意一个元素作为分割点，将数组中大于该分割点的元素放置在其右边，小于该分割点的元素置于其左边。然后再对分割成的两部分执行以上同样的操作，直至完成排序。

伪代码：

quickSort(A, p, r)
    if p < r
        q = partition(A, p, r)
        quickSort(A, p, q-1)
        quickSort(A, q+1, r)

int partition(int A[], int n, int p, int r) {
    int i, j;
    int t, x;
    x = A[r];
    i = p - 1;
    for (j = p; j < r; j++) {
        if (A[j].value <= x.value) {
            i++;
            t = A[i]; A[i] = A[j]; A[j] = t;
        }
    }
    t = A[i+1]; A[i+1] = A[r]; A[r] = t;
    return i+1;
}

　　

3. 计数排序

思想：属于稳定排序算法，能在线性时间（O(n+k)）内对包含n个元素的数组排序，其中数组元素均大于等于0且小于等于k。

伪代码：

CountSort(A, B, k)    //A为输入数组，B为输出数组
    for i = 0 to k
        C[i] = 0
    // 在C[i] 中记录i的出现次数
    for j = 1 to n        
        C[A[j]]++
    // 在C[i]中记录小于等于i的元素的出现次数
    for i = 1 to k
        C[i] = C[i] + C[i-1]
    for j = n to 1
        B[C[A[j]]] = A[j]
        C[A[j]]--