歸併排序非遞歸和遞歸實現

歸併排序就是將2個有序表組合成一個新的有序表。假定待排序表有n個元素，則可以看成是n個有序的子表，每個子表長度爲1，然後兩兩歸併…不停重複，直到合成一個長度爲n的有序序列爲止。

時間複雜度：每一趟歸併爲O(n),共log2n趟，所以時間爲O(nlog2n)
空間複雜度：O(n)
穩定性：穩定

歸併排序非遞歸實現:

#include <iostream>

using namespace std;

typedef int Type;

void Merge(Type c[], Type d[], int l, int m, int r)
{
    // 合併c[l:m]和c[m+1:r]到d[1:r]
    int i = l, j = m + 1, k = l;
    while (i <= m && j <= r) {
        if (c[i] <= c[j]) {
            d[k++] = c[i++];
        } else {
            d[k++] = c[j++];
        }
    }
    if (i > m) {
        for (int q = j; q <= r; q++) {
            d[k++] = c[q];
        }
    } else {
        for (int q = i; q <= m; q++) {
            d[k++] = c[q];
        }
    }
}

void MergePass(Type x[], Type y[], int s, int n)
{
    // 合併大小爲s的相鄰子組
    int i = 0;
    while (i <= n - 2 * s) {
        // 合併大小爲s的相鄰2段子數組
        Merge(x, y, i, i + s - 1, i + 2 * s - 1);
        i = i + 2 * s;
    }
    // 剩下的元素少於2s
    if ( i + s < n ) {
        Merge(x, y, i, i + s - 1, n - 1);
    } else {
        for (int j = i; j <= n - 1; j++) {
            y[j] = x[j];
        }
    }
}

void MergeSort(Type a[], int n)
{
    Type *b = new Type[n];
    int s = 1;
    while (s < n) {
        MergePass(a, b, s, n);      // 合併到數組b
        s += s;
        MergePass(b, a, s, n);      // 合併到數組a
        s += s;
    }
    delete[] b;
}

void print(Type a[], int n)
{
    for (int i=0; i<n; ++i) {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main(int argc, char *argv[])
{
    Type a[6] = {1, 5, 2, 3, 6, 4};

    MergeSort(a, 6);
    print(a, 6);

    return 0;
}

歸併排序遞歸實現:

#include <iostream>

using namespace std;

typedef int Type;

Type *B = new Type[6];         // 和數組A一樣大

void Merge(Type A[], int low, int mid, int high)
{
    int i, j, k;

    for (k = low; k <= high; ++k) {
        B[k] = A[k];                    // 將A中所有元素複製到B
    }

    for (i = low, j = mid + 1, k = i; i <= mid && j <= high; ++k) {
        if (B[i] <= B[j]) {
            // 比較B的左右兩段序列中的元素
            A[k] = B[i++];              // 將較小值複製到A中
        } else {
            A[k] = B[j++];
        }
    }
    while (i <= mid) {
        A[k++] = B[i++];                // 若第一個表未檢測完，複製    
    } 
    while (j <= high) {
        A[k++] = B[j++];                // 若第二個表未檢測完，複製
    }
}

void MergeSort(Type A[], int low, int high)
{

    if (low < high) {
        int mid = (low + high) / 2;
        MergeSort(A, low, mid);         // 對左側子序列進行遞歸排序
        MergeSort(A, mid+1, high);      // 對右側子序列進行遞歸排序
        Merge(A, low, mid, high);       // 歸併
    }
}

void print(Type A[], int n)
{
    for (int i=0; i<n; ++i) {
        cout << A[i] << " ";
    }
    cout << endl;
}

int main(int argc, char *argv[])
{
    Type a[6] = {1, 5, 2, 3, 6, 4};

    MergeSort(a, 0, 5);
    print(a, 6);

    delete[] B;    

    return 0;
}