1 基本介绍

1.1 概述

归并排序（Merge Sort）是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

1.2 算法详解

下面通过图来了解归并排序算法的思想：

上图中，分和合并的过程特别像递归，都是按照一定的终止条件一直执行下去。所以这就暗示了归并排序是可以通过递归的思想来编写的。

归并排序的特点：

• 归并排序是稳定的,这个看过上面的图解过程就能看出来。
• 归并排序需要消耗大量的内存空间。这个内存空间是对比冒泡排序之类的排序算法而言的，因为它们的内存空间都是只存在于常量级别的，但是归并排序却是需要消耗线性级别的内存空间，所以才会使用大量这个形容词。消耗的内存空间就是等同于待排序序列的长度。即O(n)的复杂度。

算法图解：

动画展示

2 代码实现

代码实现：

/**
 * 归并排序
 */
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8, 4, 5, 7, 2, 2, 2, 1, 3, 6, 2};
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println(Arrays.toString(arr));

    }


    // 分+合方法
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            // 中间索引
            int mid = (left + right) / 2;
            // 向左递归进行分解
            mergeSort(arr, left, mid, temp);
            // 向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);
            // 合并
            merge(arr, left, mid, right, temp);
        }
    }


    /**
     * 合并方法
     *
     * @param arr   排序的原始数组
     * @param left  左边有序序列的初始索引
     * @param mid   中间索引
     * @param right 右边索引
     * @param temp  做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        // 初始化 i，左边有序序列的初始索引
        int i = left;
        // 初始化 j，右边有序序列的初始索引
        int j = mid + 1;
        // 指向 temp 数组的当前索引
        int t = 0;

        // 先把左右两边（有序）的数据，按照规则填充到 temp 数组，直到左右两边的有序序列有一边处理完毕为止
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                // 如果发现左边的有序序列的当前元素，小于等于右边的有序序列的当前元素
                // 即将左边的当前元素，拷贝到 temp 数组
                // 然后 t++ i++
                temp[t] = arr[i];
                t++;
                i++;
            } else {
                // 反之，将右边有序列表的当前元素，填充到 temp 数组
                temp[t] = arr[j];
                t++;
                j++;
            }
        }

        // 把有剩余数据的一边的数据依次全部填充到 temp 中
        while (i <= mid) {
            // 左边的有序序列还有剩余的元素
            temp[t] = arr[i];
            t++;
            i++;
        }
        while (j <= right) {
            // 右边的有序序列还有剩余的元素
            temp[t] = arr[j];
            t++;
            j++;
        }

        // 将 temp 数组重新拷贝到 arr
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }

}

3 复杂度分析

• 时间复杂度
  从上面的算法中能明显看出来，没有使用for循环，而是通过递归的方式来解决循环问题的。所以更加的高效。
  这个执行的层数为2 * log N，并且每层操作的元素是N个，所以我们的时间复杂度即为2 * N * log N，但是常数可以忽略不计，所以时间复杂度就控制在了O(Nlog N)，对比之前算法的时间复杂度O(NN)，可以看到时间复杂度明显降低很多，并且这个时间复杂度不仅仅只是适用于平均情况，针对最坏的情况，同样也能适用。

• 空间复杂度
  整个排序的过程中需要增加一个等同于排序序列的长度的空间来存储为二次排序之后的序列，所以需要的空间复杂度就是线性级别的O(n)，这个复杂度对比之前的几种排序算法，可以看得出来的确是较为大了一点，但是也可以明显看出来整个的时间复杂度明显降低了很多，这就是一种跟明显通过牺牲空间换取时间的方法。

• 稳定性：稳定