【基础算法】02：归并排序

归并排序

---

1.归并排序

（1）基本思想

1. 确定分界点mid = (low + high) / 2
2. 先对左边进行归并排序，然后对右边进行归并排序
3. 将两个有序子序列归并为一个有序序列

（2）归并排序特性

1. 归并排序时间效率为O（nlog₂n）
2. 归并排序空间效率为O（n）
3. 归并排序是一个稳定的排序算法

注：关于2路归并的归并树（倒立的二叉树）

1. 二叉树的第h层最多有2^h-1个结点，即满足 n ≤ 2^h-1 即为 h - 1 = $\lceil lo{g}_{2}n\rceil$
2. n个元素进行2路归并，归并趟数为$\lceil lo{g}_{2}n\rceil$

（3）归并排序模板

// for循环写法
void merge_sort(SqList &sqlist, int low, int high) {
    if (low >= high) return;
    int mid = (low + high) / 2;
    merge_sort(sqlist, low, mid);
    merge_sort(sqlist, mid + 1, high);

    int i, j, k;
    SqList sqlistB;
    sqlistB.length = sqlist.length;
    for (i = low; i <= high; ++i) sqlistB.data[i] = sqlist.data[i];
    for (i = low, j = mid + 1, k = low; i <= mid && j <= high; ++k) {
        if (sqlistB.data[i] <= sqlistB.data[j]) {
            sqlist.data[k] = sqlistB.data[i++];
        } else {
            sqlist.data[k] = sqlistB.data[j++];
        }
    }
    while (i <= mid) sqlist.data[k++] = sqlistB.data[i++];
    while (j <= high) sqlist.data[k++] = sqlistB.data[j++];    
}

// while循环写法
void merge_sort(SqList &sqlist, int low, int high) {
    if (low >= high) return;
    int mid = (low + high) / 2;
    merge_sort(sqlist, low, mid);
    merge_sort(sqlist, mid + 1, high);

    int i, j, k;
    SqList sqlistB;
    sqlistB.length = sqlist.length;
    for (i = low; i <= high; ++i) sqlistB.data[i] = sqlist.data[i];
    i = low, j = mid + 1, k = low;
    while (i <= mid && j <= high) {
        if (sqlistB.data[i] <= sqlistB.data[j]) {
            sqlist.data[k++] = sqlistB.data[i++];
        } else {
            sqlist.data[k++] = sqlistB.data[j++];
        }
    }    
    while (i <= mid) sqlist.data[k++] = sqlistB.data[i++];
    while (j <= high) sqlist.data[k++] = sqlistB.data[j++];    
}

2.AcWing787.归并排序

#include <iostream>
using namespace std;

typedef struct {
    int data[100005];  //表数据
    int length;     //顺序表长度
} SqList;

void merge_sort(SqList &sqlist, int low, int high);

int main() {
    SqList sqlist;
    cin >> sqlist.length;
    for (int i = 0; i < sqlist.length; ++i) cin >> sqlist.data[i];
    // sqlist.length = 5;
    // int nums[5] = {3, 1, 2, 4, 5};
    // for (int i = 0; i < sqlist.length; ++i) sqlist.data[i] = nums[i];

    merge_sort(sqlist, 0, sqlist.length - 1);

    for (int i = 0; i < sqlist.length; ++i) cout << sqlist.data[i] << " ";
    cout << endl;
}

// 归并排序算法
void merge_sort(SqList &sqlist, int low, int high) {
    if (low >= high) return;
    int mid = (low + high) / 2;
    merge_sort(sqlist, low, mid);
    merge_sort(sqlist, mid + 1, high);

    int i, j, k;
    SqList sqlistB;
    sqlistB.length = sqlist.length;
    for (i = low; i <= high; ++i) sqlistB.data[i] = sqlist.data[i];

    i = low, j  = mid + 1, k = low;
    while (i <= mid && j <= high) {
        if (sqlistB.data[i] < sqlistB.data[j]) {
            sqlist.data[k++] = sqlistB.data[i++];
        } else {
            sqlist.data[k++] = sqlistB.data[j++];
        }
    }

    while (i <= mid) sqlist.data[k++] = sqlistB.data[i++];
    while (j <= high) sqlist.data[k++] = sqlistB.data[j++];
}

3.AcWing788.逆序对的数量

逆序对的定义：

对于数列的第 i 个和第 j 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对。

分治法解决，将序列从中间分开，将逆序对分成三类：

• 两个元素都在左边；
• 两个元素都在右边；
• 两个元素一个在左一个在右；

这个时候我们注意到一个很重要的性质，左右半边的元素在各自任意调换顺序，是不影响第三步计数的。因此我们可以数完就给它排序，这么做的好处在于，如果序列是有序的会让第三步计数很容易。如果无序暴力数的话这一步是O(n^2)的。

比如序列是这样的 4 5 6 | 1 2 3

当你发现 4 比 3 大的时候，也就是说右边最大的元素都小于左边最小的元素，那么左边剩下的5和6都必然比右边的所有元素大，因此就可以不用数5和6的情形了，直接分别加上右半边的元素个数就可以了，这一步就降低到了O(n), 我们知道递归式 T(n) = 2T(n/2)+O(n) = O(nlogn)的，所以排序的成本是可以接受的，并且这一问题下，可以很自然地使用归并排序。

#include<iostream>
using namespace std;

const int MAX = 1e6 + 10;

int n, arrA[MAX], arrB[MAX];

long long my_merge_sort(int low, int high) {
    if (low >= high) return 0;
    int mid = (low + high) / 2;
    long long res = my_merge_sort(low, mid) + my_merge_sort(mid + 1, high);

    int i = low, j = mid + 1, k = 0;
    while (i <= mid && j <= high) {
        if (arrA[i] <= arrA[j]) {
            arrB[k++] = arrA[i++];
        } else {//arrA[i] > arrA[j]满足逆序数的定义
            arrB[k++] = arrA[j++];
            res += (mid - i + 1);
        }
    }
    while (i <= mid) arrB[k++] = arrA[i++];
    while (j <= high) arrB[k++] = arrA[j++];
    for (int i = low, j = 0; i <= high; ++i, ++j) arrA[i] = arrB[j];
    return res;
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) scanf("%d", &arrA[i]);
    cout << my_merge_sort(0, n - 1) << endl;
    return 0;
}

tips：文章内容参考acwing算法刷题课程，题解图示内容及代码根据老师课程、以及自己对知识的理解，进行二次整理和部分补充，仅供学习参考使用，不可商业化。