37、【排序】归并排序（C++/Python版）

基本思想

分而治之的思想，将该问题划分为各个子问题，通过求解子问题，进而得到原问题的解。将序列先进行分解，分解为1个单位后，将子序列进行两两合并，进行归并排序，合并后的子序列为有序子序列。然后依次类推，将得到的新的子序列再进行两两合并，直至得到一个完整的序列后，便可确定已得到的序列为有序序列。

算法实现

全分解，再排序合并
四步：

1. 取中位数，分解
2. 获取两区间起始点，对比合并于一个数组中
3. 扫尾
4. 将顺序数组按原数组起始存储至原数组中

C++

#include <stdio.h>
// 设置可排序数量范围
const int M = 1e5 + 10;
// 存放有序序列的临时数组
int tmp[M];

void merge_sort(int q[], int l, int r){
	// 边界终止条件
    if(l >= r)      return ;
    
    int mid = l + r >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1 ,r);
    
    // 进行合并，设置k为存放有序序列的数组下标；i为待比较序列中第一个子序列的起始下标，j为待比较序列中第二个子序列的起始下标。
    int k = 0, i = l, j = mid + 1;
    while(i <= mid && j <= r)
        if(q[i] <= q[j])        tmp[k++] = q[i++];
        else                    tmp[k++] = q[j++];
    // 比较完后，若第一个子序列还有剩余，将剩余的值添加到tmp中；第二个子序列剩余同理。
    while(i <= mid)             tmp[k++] = q[i++];
    while(j <= r)               tmp[k++] = q[j++];
    // 将有序序列存放至原数组中，相当于完成一轮合并
    for(k = 0, i = l; i <= r; k++, i++)     q[i] = tmp[k];
}

int main(){
    
    int n;          scanf("%d",&n);
    int q[M];       for(int i = 0; i < n; i++)      scanf("%d",&q[i]);
    
    merge_sort(q, 0, n-1);
    for(int i = 0; i < n; i++)                      printf("%d ",q[i]);
    
    return 0;
}

注

1. 边界选择mid = (l + r) / 2，merge_sort(q, l, mid); merge_sort(q, mid + 1, r); i = l, j = mid + 1，即可。
2. 也可以用mid = (l + r + 1) / 2，不过这时需要merge_sort(q, l, mid - 1); merge_sort(q, mid, r); i = l, j = mid，i <= mid -1 (或i < mid)。
   不过，通常用第一种mid写起来更对称，通顺一些

Python
版本一

def merge_sort(arr, l, r, tmp):
    if l >= r:
        return 
    mid = (l + r) // 2
    merge_sort(arr, l, mid, tmp)
    merge_sort(arr, mid + 1, r, tmp)
    
    
    k, i, j = 0, l, mid + 1
    while i <= mid and j <= r:
        if arr[i] <= arr[j]:
            tmp[k] = arr[i]
            i += 1
        else:
            tmp[k] = arr[j]
            j += 1
        k += 1
    while i <= mid:
        tmp[k] = arr[i]
        k += 1
        i += 1
    while j <= r:
        tmp[k] = arr[j]
        k += 1
        j += 1
    
    k = 0
    for i in range(l, r + 1):
        arr[i] = tmp[k]
        k += 1
    
    return ;
    
        

if __name__ == '__main__':
    n = int(input())
    arr = list(map(int, input().strip().split()))
    tmp = [0] * len(arr)
    merge_sort(arr, 0, n - 1, tmp)
    print(' '.join(map(str, arr)))

注：如果将tmp变成def中的局部变量会超时。

版本二

def merge_sort(arr, l, r):
    if l >= r:
        return 
    mid = (l + r) // 2
    merge_sort(arr, l, mid)
    merge_sort(arr, mid + 1, r)
    
    tmp = []
    i, j = l, mid + 1
    while i <= mid and j <= r:
        if arr[i] <= arr[j]:
            tmp.append(arr[i])
            i += 1
        else:
            tmp.append(arr[j])
            j += 1
    tmp += arr[i:mid + 1]
    tmp += arr[j:r + 1]
    
    arr[l:r + 1] = tmp
    
    return ;
    
        

if __name__ == '__main__':
    n = int(input())
    arr = list(map(int, input().strip().split()))
    tmp = [0] * len(arr)
    merge_sort(arr, 0, n - 1)
    print(' '.join(map(str, arr)))

注：此方式是让列表动态增长，然后直接赋值。

算法复杂度

• 平均时间复杂度为O(nlog n)
• 最坏时间复杂度为O(nlog n)
• 最好时间复杂度为O(nlog n)
• 空间复杂度为O(n)
• 具有稳定性，即同一序列经排序后位置一定确定

参考文章：
AcWing 787. 归并排序的证明与边界分析

AcWing 787. 归并排序（纯手写）