常用排序演算法——合併排序

分治

分治(Divide and Conquer)是一場常見的演算法策略。分治策略的基本思想就是對於一個問題規模為N的問題，將其劃分為規模足夠小的K個子問題，子問題由於規模足夠小可以直接求解，最後將規模足夠小的K的問題的解合併得出原問題的解。
分治策略的問題的求解過程的一般套路就是：

1. 判斷問題規模，足夠小進入步驟2，否者進入步驟3
2. 直接對問題進行求解，返回問題的解。
3. 將問題拆分成K個小規模的問題，進入步驟2。並將解合併，得到原問題的解。

由於分治策略的步驟描述自帶遞迴屬性，因此分治策略的演算法實現常採用遞迴來實現。遞迴的演算法通常會含有三部分，第一部分是個基準情況(Base Case)

分治策略中主要有兩個關鍵過程：

• 將原問題拆分Division
• 將各子問題合併Combination

分治策略的主要時間開銷發生在這兩個過程，通常分治策略有兩類

1. 拆分容易，合併困難
2. 拆分困難，合併簡單

下文中的合併排序和快速排序分別屬於上面的第1和第2類。

合併排序和快速排序

在常見排序演算法中，合併排序和快速排序是典型的分治演算法，其時間複雜度的平均效能均為nlgn。合併排序的最壞時間複雜度也能保持nlgn，而快速排序的最壞時間複雜度卻為n*n。合併排序是穩定的，而快速排序不是穩定的。另外合併排序是拆分容易，合併困難，而快速排序則是拆分困難，合併容易。

合併排序又稱歸併排序，主要的思想是：將待排序列拆分至數個足夠小的子序列，然後將相鄰子序列合併為一個有序子序列，重複合併相鄰有序子序列直到整個序列有序。

快速排序的主要思想則是，將待排序列拆分為左右兩個子序列A,B，使得子序列A的元素都小於子序列B，然後對子序列A，B繼續進行這種拆分，直到待拆分的序列足夠小，最後整個序列變成有序。

由於合併排序和快速排序每次元素的移動都不只移動了一個位置，因此每次元素的比較都不只消除了一個逆序對，因此對於插入排序這種每次比較只移動一個位置的演算法，時間複雜度會得到改善。

快速排序的遞迴實現

int partition(int* a, int l, int
 
 h) {
    int pivot = a[l];
    int i,j;
    i = l - 1;
    j = h + 1;
    while(true) {
        while(a[--j] > pivot);
        while(a[++i] < pivot)
            if(i >= h)
                break;
        //i 、j cross
        if(i >= j)
            break;

        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }
    a[j] = pivot;
    return j;
}

void quickSort(int* a, int l, int h) {
    if(l >= h)
        return;
    int p = partition(a, l, h);
    quickSort(a, l, p);
    quickSort(a, p+1, h);
}

合併排序的遞迴實現

void merge(int* a, int l, int m, int h) {
    if(l == h)
        return;

    int* b = (int*)malloc(sizeof(int) * (h - l + 1));
    int i = l, j = m + 1;
    int k = 0;

    while(i <= m && j <= h)
        b[k++] = a[i] > a[j] ? a[j++] : a[i++];

    if(i <= m)
        while(i <= m)
            b[k++] = a[i++];
    if(j <= h)
        while(j <= h)
            b[k++] = a[j++];
    //回寫
    i = l;
    k = 0;

    for(; i <= h;)
        a[i++] = b[k++];
}

void mergeSort(int* a, int l, int h) {
    if(l >= h)
        return;
    int m = (h + l) / 2;
    mergeSort(a, l, m);
    mergeSort(a, m+1, h);
    merge(a, l, m, h);
}

合併排序的非遞迴實現

由於遞迴會導致函式呼叫棧的暴增，會引入額外的時間開銷，例如現場保護和恢復之類的。通遞迴版本的演算法都可以改寫為迭代版本的演算法。遞迴演算法的優點是實現簡單直觀，易於理解，缺點是如果有時候呼叫深度過深，會帶來棧記憶體溢位和額外的執行時間開銷。迭代演算法的有點是不會有額外的函式呼叫棧的增長， 缺點是難於理解且難於實現。

合併排序的迭代版本的實現相對來講是比較簡單直觀的，大致思路就是：第1輪，待排序列S中相鄰的長度為1的子序列進行合併，第2輪，序列S中相鄰的長度為2的子序列進行合併，第i輪，待排序列S中相鄰的長度為2的i-1次方的子序列進行合併。直到待合併的子序列數為1。

void merge(int* a, int l, int m, int h) {
    if(l == h)
        return;

    int* b = (int*)malloc(sizeof(int) * (h - l + 1));
    int i = l, j = m + 1;
    int k = 0;

    while(i <= m && j <= h)
        b[k++] = a[i] > a[j] ? a[j++] : a[i++];

    if(i <= m)
        while(i <= m)
            b[k++] = a[i++];
    if(j <= h)
        while(j <= h)
            b[k++] = a[j++];
    //回寫
    i = l;
    k = 0;

    for(; i <= h;)
        a[i++] = b[k++];
}

//非遞迴版本
void mergeIteation(int* a, int n) {
    int offset = 1;
    while(offset <= n) {
        int i = 0;
        for(;i < n;) {
            merge(a,i, i+offset-1,i+offset*2 - 1);
            i = i + offset * 2;
            if(n - 1 - i < offset)
                break;
        }
        offset *= 2;
    }
}