排序（上）

排序算法在线演示

冒泡排序

从数组头部开始，依次进行两两数据比较，若第 i - 1 个元素大于第 i 个元素，两值互换。一轮下来就有一个最大的元素“沉底”，然后进行第二轮，从第 1 个元素到第 N - 1 个元素。

// Bubble_sort
void Bubble_sort(int A[], int N){
    for(int P = N; P > 0; P--){
        int flag = 0; /* 标识是否有元素发生互换 */
        for(int i = 0; i < P; i++){
            if(A[i] > A[i+1]){
                swap(A[i], A[i+1]);
                flag = 1;
            }
        }
        if(flag == 0) break;
    }
}

插入排序

假设第一个数是排好序的，重复取出第 i 个数（1 <= i <= N），从后往前同前面 i - 1 个数比较，若遇到一个比它大的数，把这个数插入到比它大的数前面。

// Insertion_sort
void Insertion_sort(int A[], int N){
    int i,j;
    for(i = 1; i < N; i++){
        int temp = A[i]; // 抽出第i个数
        for(j = i; temp < A[j-1] && j > 0; j--){ // 跟前面i-1个数比较
            A[j] = A[j-1];
        }
        A[j] = temp;
    }
}

简单排序的时间复杂度

对同一个序列，插入排序和冒泡排序在交换元素上是相等的，这是因为每次两两交换，消除了一个逆序对。而任一N个元素，拥有的逆序对数量是N(N - 1) / 4，所以，任意仅以相邻元素两两互换的排序算法的时间复杂度是

$$Ω(N^2)$$

希尔排序

“跳着排序”，可能一次交换消除对个逆序对，从而提高速度。

简单的希尔排序

希尔增量序列为 N/2

/Shell_sort
// 定义增量序列Dm > Dm-1 > ... > D1 = 1
// 依次进行Dk间隔排序
void Shell_sort(int A[], int N){
    int P,i,temp;
    for(int D = N/2; D >0; D /= 2){ /* 希尔增量序列 */
        for(P = D; P < N; P ++){ /* 插入排序 */
            temp = A[P];
            for(i = P; i >= D && A[i-D] > temp; i -= D )
                A[i] = A[i-D];
            A[i] = temp;
        }
    } 

}

更多增量序列

上述希尔排序的增量序列不是互质的，这就可能导致在增量较小时，消除的逆序对过少。

1. Hibbard 序列 Dk = 2^k - 1
2. Sedgewick 序列

基于这两个增量序列的希尔排序的时间复杂度分析是十分复杂的。

堆排序

算法一

调成最小堆，每次弹出堆顶元素。

// Heap_sort1
// O(NlogN)
void Heap_sort(int A[], int N){
    int[] temp;
    BuildHeap(A); /* O(N) */
    for(int i = 0; i < N; i++)
        temp[i] = DeleteMin(A); /* O(logN) */
    for(int i = 0; i< N; i++)
        A[i] = temp[i]; /* O(N) */
}

复杂度是O(NlogN) 但是要挪出一半空间来拷贝元素。

算法二

调成最大堆，把堆顶元素放到最后，然后删掉最后一个元素（即对前N-1个数做堆排序）。

#define LeftChild(i) (2*(i) + 1)
#define ElementType int

void PercDown(ElementType A[], int i, int N){
    int child;
    ElementType Tmp;

    for(Tmp = A[i]; LeftChild(i) < N; i = child ){
        child = LeftChild(i);
        if(child != N-1 && A[child + 1] > A[child]) 
            child ++;
        /*左儿子不是剩下的最后一个元素，而且右儿子大于左儿子*/

        if(Tmp < A[child]){
            A[i] = A[child];
        }else {
            break;
        }
    }
    A[i] = Tmp;
}
/* - - - - - - - - - - - - - - - - - - - */


void Heap_sort(int A[], int N){
    for(int i = N/2; i >= 0; i--)
        PercDown(A, i, N); /*建立最大堆*/
    for(int i = N-1; i > 0; i--){
        swap(&A[0], &A[i]); /*Delete Max*/
        PercDown(A, 0, i);
    }
}

PercDown 是对一个元素进行检查，选择左右儿子中比它大的值（如果有）替换自己的值，然后去被取走值的儿子进行PercDown。建立堆的时候是从第 N/2 的元素（倒数的第一个有儿子的元素）往前PercDown的，大的元素不断往上走。
堆排序处理N个不同的元素的随机序列产生的比较次数是2NlogN - O(NloglogN) ，比O(NlogN) 稍微好一点。

归并排序