排序(一) —— 歸併排序

歡迎訪問https://blog.csdn.net/lxt_Lucia～～

宇宙第一小仙女\(^o^)/～～萌量爆表求帶飛=≡Σ((( つ^o^)つ~ dalao們點個關注唄～～

一. 概念描述

歸併排序(Merge Sort)就是利用歸併思想對數列進行排序。將兩個的有序數列合併成一個有序數列，我們稱之爲"歸併"。歸併排序（MERGE-SORT）是利用歸併的思想實現的排序方法，該算法採用經典的分治（divide-and-conquer）策略（分治法將問題分(divide)成一些小的問題然後遞歸求解，而治(conquer)的階段則將分的階段得到的各答案"修補"在一起，即分而治之)。根據具體的實現，歸併排序包括"從上往下"和"從下往上"2種方式。

1）從下往上的歸併排序：將待排序的數列分成若干個長度爲1的子數列，然後將這些數列兩兩合併；得到若干個長度爲2的有序數列，再將這些數列兩兩合併；得到若干個長度爲4的有序數列，再將它們兩兩合併；直接合併成一個數列爲止。這樣就得到了我們想要的排序結果。(參考下面的圖片)

2）從上往下的歸併排序：它與"從下往上"在排序上是反方向的。它基本包括3步：
① 分解 -- 將當前區間一分爲二，即求分裂點 mid = (low + high)/2;
② 求解 -- 遞歸地對兩個子區間a[low...mid] 和 a[mid+1...high]進行歸併排序。遞歸的終結條件是子區間長度爲1。
③ 合併 -- 將已排序的兩個子區間a[low...mid]和 a[mid+1...high]歸併爲一個有序的區間a[low...high]。

二. 圖解

分而治之

三. 過程

　　由上一部分的圖解可以看到這種結構很像一棵完全二叉樹，本文的歸併排序我們採用遞歸去實現（也可採用迭代的方式去實現）。分階段可以理解爲就是遞歸拆分子序列的過程，遞歸深度爲log2n。再來看看治階段，合併相鄰有序子序列，我們需要將兩個已經有序的子序列合併成一個有序序列，比如上圖中的最後一次合併，要將[4,5,7,8]和[1,2,3,6]兩個已經有序的子序列，合併爲最終序列[1,2,3,4,5,6,7,8]，來看下實現步驟。

四. 代碼實現

1）(從上往下)

/*
 * 將一個數組中的兩個相鄰有序區間合併成一個
 *
 * 參數說明：
 *     a -- 包含兩個有序區間的數組
 *     start -- 第1個有序區間的起始地址。
 *     mid   -- 第1個有序區間的結束地址。也是第2個有序區間的起始地址。
 *     end   -- 第2個有序區間的結束地址。
 */
void merge(int a[], int start, int mid, int end)
{
    int *tmp = (int *)malloc((end-start+1)*sizeof(int));    // tmp是彙總2個有序區的臨時區域
    int i = start;            // 第1個有序區的索引
    int j = mid + 1;        // 第2個有序區的索引
    int k = 0;                // 臨時區域的索引

    while(i <= mid && j <= end)
    {
        if (a[i] <= a[j])
            tmp[k++] = a[i++];
        else
            tmp[k++] = a[j++];
    }

    while(i <= mid)
        tmp[k++] = a[i++];

    while(j <= end)
        tmp[k++] = a[j++];

    // 將排序後的元素，全部都整合到數組a中。
    for (i = 0; i < k; i++)
        a[start + i] = tmp[i];

    free(tmp);
}

/*
 * 歸併排序(從上往下)
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     start -- 數組的起始地址
 *     endi -- 數組的結束地址
 */
void merge_sort_up2down(int a[], int start, int end)
{
    if(a==NULL || start >= end)
        return ;

    int mid = (end + start)/2;
    merge_sort_up2down(a, start, mid); // 遞歸排序a[start...mid]
    merge_sort_up2down(a, mid+1, end); // 遞歸排序a[mid+1...end]

    // a[start...mid] 和 a[mid...end]是兩個有序空間，
    // 將它們排序成一個有序空間a[start...end]
    merge(a, start, mid, end);
}

通過"從上往下的歸併排序"來對數組{80,30,60,40,20,10,50,70}進行排序時：
1. 將數組{80,30,60,40,20,10,50,70}看作由兩個有序的子數組{80,30,60,40}和{20,10,50,70}組成。對兩個有序子樹組進行排序即可。
2. 將子數組{80,30,60,40}看作由兩個有序的子數組{80,30}和{60,40}組成。
將子數組{20,10,50,70}看作由兩個有序的子數組{20,10}和{50,70}組成。
3. 將子數組{80,30}看作由兩個有序的子數組{80}和{30}組成。
將子數組{60,40}看作由兩個有序的子數組{60}和{40}組成。
將子數組{20,10}看作由兩個有序的子數組{20}和{10}組成。
將子數組{50,70}看作由兩個有序的子數組{50}和{70}組成。

2）從下往上

/*
 * 對數組a做若干次合併：數組a的總長度爲len，將它分爲若干個長度爲gap的子數組；
 *             將"每2個相鄰的子數組" 進行合併排序。
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     len -- 數組的長度
 *     gap -- 子數組的長度
 */
void merge_groups(int a[], int len, int gap)
{
    int i;
    int twolen = 2 * gap;    // 兩個相鄰的子數組的長度

    // 將"每2個相鄰的子數組" 進行合併排序。
    for(i = 0; i+2*gap-1 < len; i+=(2*gap))
    {
        merge(a, i, i+gap-1, i+2*gap-1);
    }

    // 若 i+gap-1 < len-1，則剩餘一個子數組沒有配對。
    // 將該子數組合併到已排序的數組中。
    if ( i+gap-1 < len-1)
    {
        merge(a, i, i + gap - 1, len - 1);
    }
}

/*
 * 歸併排序(從下往上)
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     len -- 數組的長度
 */
void merge_sort_down2up(int a[], int len)
{
    int n;

    if (a==NULL || len<=0)
        return ;

    for(n = 1; n < len; n*=2)
        merge_groups(a, len, n);
}

通過"從下往上的歸併排序"來對數組{80,30,60,40,20,10,50,70}進行排序時：
1. 將數組{80,30,60,40,20,10,50,70}看作由8個有序的子數組{80},{30},{60},{40},{20},{10},{50}和{70}組成。
2. 將這8個有序的子數列兩兩合併。得到4個有序的子樹列{30,80},{40,60},{10,20}和{50,70}。
3. 將這4個有序的子數列兩兩合併。得到2個有序的子樹列{30,40,60,80}和{10,20,50,70}。
4. 將這2個有序的子數列兩兩合併。得到1個有序的子樹列{10,20,30,40,50,60,70,80}。

五. 時間複雜度和穩定性

1）複雜度

歸併排序的時間複雜度是O(N*lgN)。
假設被排序的數列中有N個數。遍歷一趟的時間複雜度是O(N)，需要遍歷多少次呢？
歸併排序的形式就是一棵二叉樹，它需要遍歷的次數就是二叉樹的深度，而根據完全二叉樹的可以得出它的時間複雜度是O(N*lgN)。

2）穩定性

歸併排序是穩定的算法，它滿足穩定算法的定義。
算法穩定性 -- 假設在數列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；並且排序之後，a[i]仍然在a[j]前面。則這個排序算法是穩定的！

六. 多語言代碼實現

下面給出歸併排序的三種實現：C、C++和Java。這三種實現的原理和輸出結果都是一樣的，每一種實現中都包括了"從上往下的歸併排序"和"從下往上的歸併排序"這2種形式。

1）歸併排序C實現
實現代碼(merge_sort.c)

/**
 * 歸併排序：C 語言
 *
 * @author skywang
 * @date 2014/03/12
 */

#include <stdio.h>
#include <stdlib.h>

// 數組長度
#define LENGTH(array) ( (sizeof(array)) / (sizeof(array[0])) )

/*
 * 將一個數組中的兩個相鄰有序區間合併成一個
 *
 * 參數說明：
 *     a -- 包含兩個有序區間的數組
 *     start -- 第1個有序區間的起始地址。
 *     mid   -- 第1個有序區間的結束地址。也是第2個有序區間的起始地址。
 *     end   -- 第2個有序區間的結束地址。
 */
void merge(int a[], int start, int mid, int end)
{
    int *tmp = (int *)malloc((end-start+1)*sizeof(int));    // tmp是彙總2個有序區的臨時區域
    int i = start;            // 第1個有序區的索引
    int j = mid + 1;        // 第2個有序區的索引
    int k = 0;                // 臨時區域的索引

    while(i <= mid && j <= end)
    {
        if (a[i] <= a[j])
            tmp[k++] = a[i++];
        else
            tmp[k++] = a[j++];
    }

    while(i <= mid)
        tmp[k++] = a[i++];

    while(j <= end)
        tmp[k++] = a[j++];

    // 將排序後的元素，全部都整合到數組a中。
    for (i = 0; i < k; i++)
        a[start + i] = tmp[i];

    free(tmp);
}

/*
 * 歸併排序(從上往下)
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     start -- 數組的起始地址
 *     endi -- 數組的結束地址
 */
void merge_sort_up2down(int a[], int start, int end)
{
    if(a==NULL || start >= end)
        return ;

    int mid = (end + start)/2;
    merge_sort_up2down(a, start, mid); // 遞歸排序a[start...mid]
    merge_sort_up2down(a, mid+1, end); // 遞歸排序a[mid+1...end]

    // a[start...mid] 和 a[mid...end]是兩個有序空間，
    // 將它們排序成一個有序空間a[start...end]
    merge(a, start, mid, end);
}


/*
 * 對數組a做若干次合併：數組a的總長度爲len，將它分爲若干個長度爲gap的子數組；
 *             將"每2個相鄰的子數組" 進行合併排序。
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     len -- 數組的長度
 *     gap -- 子數組的長度
 */
void merge_groups(int a[], int len, int gap)
{
    int i;
    int twolen = 2 * gap;    // 兩個相鄰的子數組的長度

    // 將"每2個相鄰的子數組" 進行合併排序。
    for(i = 0; i+2*gap-1 < len; i+=(2*gap))
    {
        merge(a, i, i+gap-1, i+2*gap-1);
    }

    // 若 i+gap-1 < len-1，則剩餘一個子數組沒有配對。
    // 將該子數組合併到已排序的數組中。
    if ( i+gap-1 < len-1)
    {
        merge(a, i, i + gap - 1, len - 1);
    }
}

/*
 * 歸併排序(從下往上)
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     len -- 數組的長度
 */
void merge_sort_down2up(int a[], int len)
{
    int n;

    if (a==NULL || len<=0)
        return ;

    for(n = 1; n < len; n*=2)
        merge_groups(a, len, n);
}

void main()
{
    int i;
    int a[] = {80,30,60,40,20,10,50,70};
    int ilen = LENGTH(a);

    printf("before sort:");
    for (i=0; i<ilen; i++)
        printf("%d ", a[i]);
    printf("\n");

    merge_sort_up2down(a, 0, ilen-1);        // 歸併排序(從上往下)
    //merge_sort_down2up(a, ilen);            // 歸併排序(從下往上)

    printf("after  sort:");
    for (i=0; i<ilen; i++)
        printf("%d ", a[i]);
    printf("\n");
}

2）歸併排序C++實現
實現代碼(MergeSort.cpp)

/**
 * 歸併排序：C++
 *
 * @author skywang
 * @date 2014/03/12
 */

#include <iostream>
using namespace std;

/*
 * 將一個數組中的兩個相鄰有序區間合併成一個
 *
 * 參數說明：
 *     a -- 包含兩個有序區間的數組
 *     start -- 第1個有序區間的起始地址。
 *     mid   -- 第1個有序區間的結束地址。也是第2個有序區間的起始地址。
 *     end   -- 第2個有序區間的結束地址。
 */
void merge(int* a, int start, int mid, int end)
{
    int *tmp = new int[end-start+1];    // tmp是彙總2個有序區的臨時區域
    int i = start;            // 第1個有序區的索引
    int j = mid + 1;        // 第2個有序區的索引
    int k = 0;                // 臨時區域的索引

    while(i <= mid && j <= end)
    {
        if (a[i] <= a[j])
            tmp[k++] = a[i++];
        else
            tmp[k++] = a[j++];
    }

    while(i <= mid)
        tmp[k++] = a[i++];

    while(j <= end)
        tmp[k++] = a[j++];

    // 將排序後的元素，全部都整合到數組a中。
    for (i = 0; i < k; i++)
        a[start + i] = tmp[i];

    delete[] tmp;
}

/*
 * 歸併排序(從上往下)
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     start -- 數組的起始地址
 *     endi -- 數組的結束地址
 */
void mergeSortUp2Down(int* a, int start, int end)
{
    if(a==NULL || start >= end)
        return ;

    int mid = (end + start)/2;
    mergeSortUp2Down(a, start, mid); // 遞歸排序a[start...mid]
    mergeSortUp2Down(a, mid+1, end); // 遞歸排序a[mid+1...end]

    // a[start...mid] 和 a[mid...end]是兩個有序空間，
    // 將它們排序成一個有序空間a[start...end]
    merge(a, start, mid, end);
}


/*
 * 對數組a做若干次合併：數組a的總長度爲len，將它分爲若干個長度爲gap的子數組；
 *             將"每2個相鄰的子數組" 進行合併排序。
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     len -- 數組的長度
 *     gap -- 子數組的長度
 */
void mergeGroups(int* a, int len, int gap)
{
    int i;
    int twolen = 2 * gap;    // 兩個相鄰的子數組的長度

    // 將"每2個相鄰的子數組" 進行合併排序。
    for(i = 0; i+2*gap-1 < len; i+=(2*gap))
    {
        merge(a, i, i+gap-1, i+2*gap-1);
    }

    // 若 i+gap-1 < len-1，則剩餘一個子數組沒有配對。
    // 將該子數組合併到已排序的數組中。
    if ( i+gap-1 < len-1)
    {
        merge(a, i, i + gap - 1, len - 1);
    }
}

/*
 * 歸併排序(從下往上)
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     len -- 數組的長度
 */
void mergeSortDown2Up(int* a, int len)
{
    int n;

    if (a==NULL || len<=0)
        return ;

    for(n = 1; n < len; n*=2)
        mergeGroups(a, len, n);
}

int main()
{
    int i;
    int a[] = {80,30,60,40,20,10,50,70};
    int ilen = (sizeof(a)) / (sizeof(a[0]));

    cout << "before sort:";
    for (i=0; i<ilen; i++)
        cout << a[i] << " ";
    cout << endl;

    mergeSortUp2Down(a, 0, ilen-1);        // 歸併排序(從上往下)
    //mergeSortDown2Up(a, ilen);            // 歸併排序(從下往上)

    cout << "after  sort:";
    for (i=0; i<ilen; i++)
        cout << a[i] << " ";
    cout << endl;

    return 0;
}

3）歸併排序Java實現
實現代碼(MergeSort.java)

/**
 * 歸併排序：Java
 *
 * @author skywang
 * @date 2014/03/12
 */

public class MergeSort {

    /*
     * 將一個數組中的兩個相鄰有序區間合併成一個
     *
     * 參數說明：
     *     a -- 包含兩個有序區間的數組
     *     start -- 第1個有序區間的起始地址。
     *     mid   -- 第1個有序區間的結束地址。也是第2個有序區間的起始地址。
     *     end   -- 第2個有序區間的結束地址。
     */
    public static void merge(int[] a, int start, int mid, int end) {
        int[] tmp = new int[end-start+1];    // tmp是彙總2個有序區的臨時區域
        int i = start;            // 第1個有序區的索引
        int j = mid + 1;        // 第2個有序區的索引
        int k = 0;                // 臨時區域的索引

        while(i <= mid && j <= end) {
            if (a[i] <= a[j])
                tmp[k++] = a[i++];
            else
                tmp[k++] = a[j++];
        }

        while(i <= mid)
            tmp[k++] = a[i++];

        while(j <= end)
            tmp[k++] = a[j++];

        // 將排序後的元素，全部都整合到數組a中。
        for (i = 0; i < k; i++)
            a[start + i] = tmp[i];

        tmp=null;
    }

    /*
     * 歸併排序(從上往下)
     *
     * 參數說明：
     *     a -- 待排序的數組
     *     start -- 數組的起始地址
     *     endi -- 數組的結束地址
     */
    public static void mergeSortUp2Down(int[] a, int start, int end) {
        if(a==null || start >= end)
            return ;

        int mid = (end + start)/2;
        mergeSortUp2Down(a, start, mid); // 遞歸排序a[start...mid]
        mergeSortUp2Down(a, mid+1, end); // 遞歸排序a[mid+1...end]

        // a[start...mid] 和 a[mid...end]是兩個有序空間，
        // 將它們排序成一個有序空間a[start...end]
        merge(a, start, mid, end);
    }


    /*
     * 對數組a做若干次合併：數組a的總長度爲len，將它分爲若干個長度爲gap的子數組；
     *             將"每2個相鄰的子數組" 進行合併排序。
     *
     * 參數說明：
     *     a -- 待排序的數組
     *     len -- 數組的長度
     *     gap -- 子數組的長度
     */
    public static void mergeGroups(int[] a, int len, int gap) {
        int i;
        int twolen = 2 * gap;    // 兩個相鄰的子數組的長度

        // 將"每2個相鄰的子數組" 進行合併排序。
        for(i = 0; i+2*gap-1 < len; i+=(2*gap))
            merge(a, i, i+gap-1, i+2*gap-1);

        // 若 i+gap-1 < len-1，則剩餘一個子數組沒有配對。
        // 將該子數組合併到已排序的數組中。
        if ( i+gap-1 < len-1)
            merge(a, i, i + gap - 1, len - 1);
    }

    /*
     * 歸併排序(從下往上)
     *
     * 參數說明：
     *     a -- 待排序的數組
     */
    public static void mergeSortDown2Up(int[] a) {
        if (a==null)
            return ;

        for(int n = 1; n < a.length; n*=2)
            mergeGroups(a, a.length, n);
    }

    public static void main(String[] args) {
        int i;
        int a[] = {80,30,60,40,20,10,50,70};

        System.out.printf("before sort:");
        for (i=0; i<a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");

        mergeSortUp2Down(a, 0, a.length-1);        // 歸併排序(從上往下)
        //mergeSortDown2Up(a);                    // 歸併排序(從下往上)

        System.out.printf("after  sort:");
        for (i=0; i<a.length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("\n");
    }
}

上面3種實現的原理和輸出結果都是一樣的。

下面是它們的輸出結果：

before sort:80 30 60 40 20 10 50 70 
after  sort:10 20 30 40 50 60 70 80

七. 總結

歸併排序是穩定排序，它也是一種十分高效的排序，能利用完全二叉樹特性的排序一般性能都不會太差。java中Arrays.sort()採用了一種名爲TimSort的排序算法，就是歸併排序的優化版本。從上文的圖中可看出，每次合併操作的平均時間複雜度爲O(n)，而完全二叉樹的深度爲|log2n|。總的平均時間複雜度爲O(nlogn)。而且，歸併排序的最好，最壞，平均時間複雜度均爲O(nlogn)。

八.例題

算法與數據結構實驗6: 逆序對。詳解請見下篇博客。

參考資料：

https://www.cnblogs.com/chengxiao/p/6194356.html

https://www.cnblogs.com/skywang12345/p/3602369.html

排序(一) —— 歸併排序

歡迎訪問https://blog.csdn.net/lxt_Lucia～～

宇宙第一小仙女\(^o^)/～～萌量爆表求帶飛=≡Σ((( つ^o^)つ~ dalao們點個關注唄～～

一. 概念描述

二. 圖解

三. 過程

四. 代碼實現

1）(從上往下)

2）從下往上

五. 時間複雜度和穩定性

1）複雜度

2）穩定性

六. 多語言代碼實現

七. 總結

八.例題

Pisano Periods (找規律)

A Rational Sequence（思維）

6469 Deranged Exams (排列組合 + 容斥原理)

第15屆浙江省賽E題 - LIS（ZOJ 4028）

心與心的距離 (思維)

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結