归并排序算法

算法思想

      该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
      假设初始序列含有n个记录，则可看成是n个有序的子序列，每个子序列的长度为1，然后两两合并，得到⌈n/2⌉个长度为2或1的有序子序列；在两两合并，……，如此重复，知道得到一个长度为n的有序序列为止。

图解

每次合并过程中，是将两个分组里的数从第一个数开始比较，把数字较小的放入容器(升序排列)。这里我们以第二次合并为例进行细化，

代码一(Python)

def merge_sort(arr):
    divide(arr, 0, len(arr)-1)

def divide(arr, low, high):
    if low < high:
        mid = (low + high) // 2
        divide(arr, low, mid)
        divide(arr, mid+1, high)
        merge(arr, low, mid, high)

def merge(arr, low, mid, high):
    container = []    # 用于存储有序数字
    i, j = low, mid+1
    while i <= mid and j <= high:
        if arr[i] <= arr[j]:
            container.append(arr[i])
            i += 1
        else:
            container.append(arr[j])
            j += 1
    if i <= mid:
        container.extend(arr[i:mid+1])
    elif j <= high:
        container.extend(arr[j:high+1])
    arr[low:high+1] = container

# 做10次测试
import random as r
for i in range(0,10):
    arr = [r.randint(-10, 100) for i in range(0,10)]
    print(arr, end='\n')
    merge_sort(arr)
    print(arr, end='\n\n')

代码二(Java)

public static void mergeSort(int[] nums) {
    divide(nums, 0, nums.length - 1);
}

public static void divide(int[] nums, int left, int right) {
    if (left >= right) return;

    int mid = (left + right) / 2;
    divide(nums, left, mid);
    divide(nums, mid + 1, right);
    merge(nums, left, mid, right);
}

public static void merge(int[] nums, int left, int mid, int right) {
    int[] orderedNums = new int[right - left + 1];  // 申请一个数组存储排好序的数据
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (nums[i] <= nums[j]) {
            orderedNums[k++] = nums[i++];
        } else {
            orderedNums[k++] = nums[j++];
        }
    }
    // 经过上面的操作后，两个区间中的一个可能还剩余数据，把剩余的数据填入有序数组中
    while (i <= mid) {
        orderedNums[k++] = nums[i++];
    }
    while (j <= right) {
        orderedNums[k++] = nums[j++];
    }

    // 用排好序的数据替换掉原数组中无序的数据
    for (i = 0; i < orderedNums.length; i++) {
        nums[left + i] = orderedNums[i];    // 注意这里用的是nums[left + i]
    }
}

算法分析

      时间复杂度
      当有n个记录是，需进行⌈⌉轮归并排序，每一轮归并，其估计值比较次数不超过n，元素移动次数都是n，因此，归并排序的时间复杂度为O()。

      空间复杂度
      用容器实现归并排序时，需要和待排序记录个数相等的存储空间，所以空间复杂度为O(n)。

      该算法是稳定排序。