【排序】归并排序算法

归并排序算法

1.归并排序代码模板

void Msort(int SR[], int TR1[], int s, int t);
void Merge(int SR[], int TR[], int i, int m, int n);

void MergeSort(SqList *L) // 封装Msort
{
    Msort(L->arr, L->arr, 1, L->length);
}

void Msort(int SR[], int TR1[], int s, int t)  // 将SR[s...t]归并排序为 TR1[s...t]
{
    int m;
    int TR2[N + 1];
    if (s == t) TR1[s] = SR[s];
    else {
        m = (s + t) / 2;    // 将SR平分为SR[s...m]和SR[m+1...t]
        Msort(SR, TR2, s, m);      // 递归将SR[s...m]归并为有序的TR2[s...m]
        Msort(SR, TR2, m + 1, t);  // 递归将SR[m+1...t]归并为有序的TR2[m+1...t]
        Merge(TR2, TR1, s, m, t);    // 将TR2[s...m]和TR2[m+1...t]归并到TR1[s...t]
    }
}

void Merge(int SR[], int TR[], int i, int m, int n)  // 将TR2[s...m]和TR2[m+1...t]归并到TR[s...t]
{
    int j, k;  
    for (j = m + 1, k = i; i <= m && j <= n; k ++ ) {   // i从第一个序列的首地址(1)-->末尾(m)  j从第二个序列的首地址(m+1)->末尾(n)  k记录目标数组TR的下标，从1开始，每次加一
         if (SR[i] < SR[j])  TR[k] = SR[i++];      
         else  TR[k] = SR[j++];
     }

    if (i <= m) {   // 将剩余的SR[i...m]复制到TR
        for (int v = 0; v <= m - i; v ++ )
            TR[k + v] = SR[i + v];
    }
    if (j <= n) {   // 将剩余的SR[j...n]复制到TR
        for (int v = 0; v <= n - j; v ++ )
            TR[k + v] = SR[j + v];
    }
}

2.算法介绍

归并排序和堆排序一样，也是一种涉及完全二叉树的高效率的排序，不过相比于堆结构的复杂设计，归并排序的思想就要简单许多。归并，即合并、并入的意思，在数据结构中的定义是将两个和两个以上的有序表组合成一个新的有序表。

归并排序的基本思想是：假设初始序列含有n个元素，则可以看成是n个有序的长度为1的子序列，然后两两归并，得到n/2个长度为2或1的有序子序列，再两两归并，知道得到一个长度为n的有序的序列，称为二路归并。

归并排序的时间复杂度为O(nlogn)，最好，最坏，平均时间复杂度都是O(nlogn)，这点与堆排序相同，归并排序需要两两比较，不存在跳跃的比较，所以是一种稳定的排序算法，这是归并排序区别于其他进阶排序的一点。

3.实例

#include <iostream>
using namespace std;

const int N = 100;

typedef struct 
{
    int arr[N];  // 待排序的数组
    int length;  // 存储数组中元素的个数
} SqList;

void MergeSort(SqList *L);
void Msort(int SR[], int TR1[], int s, int t);
void Merge(int SR[], int TR[], int s, int m, int t);

void Msort(int SR[], int TR1[], int s, int t)
{
    int m;   // 记录中点
    int TR2[N];
    if (s == t)
        TR1[s] = SR[s];
    else {
        m = (s + t) / 2;
        Msort(SR, TR2, s, m);
        Msort(SR, TR2, m + 1, t);
        Merge(TR2, TR1, s, m, t);
    }
}

void Merge(int SR[], int TR[], int i, int m, int n)
{
    int j, k;
    for (j = m + 1, k = i; i <= m && j <= n; k ++ ) {
        if (SR[i] < SR[j])
            TR[k] = SR[i++];
        else
            TR[k] = SR[j++];
    }
    if (i <= m) {
        for (int v = 0; v <= m - i; v ++ ) 
            TR[k + v] = SR[i + v];
    }
    if (j <= n) {
        for (int v = 0; v <= n - j; v ++ )
            TR[k + v] = SR[j + v];
    }
    
}

void MergeSort(SqList *L)
{
    Msort(L->arr, L->arr, 1, L->length);
}

int main()
{
    SqList L;
    L.arr[1] = 50;
    L.arr[2] = 10;
    L.arr[3] = 90;
    L.arr[4] = 30;
    L.arr[5] = 70;
    L.arr[6] = 40;
    L.arr[7] = 80;
    L.arr[8] = 60;
    L.arr[9] = 20;
    L.length = 9;
    // Msort(L.arr, L.arr, 1, L.length);  // 也可以直接调用Msort
    MergeSort(&L);
    for (int i = 1; i <= L.length; i ++ )
        cout << L.arr[i] << ' ';
}

注：内容参考自《大话数据结构》