优秀的归并排序算法及其优化(思想+代码)Java实现

归并排序是面试中比较常见的一种排序算法，之前面试官问的时候，答得总是很浅，今天将其总结如下，希望下次回答的令人满意。

归并排序的思想:采用分治的思想，具体步骤如下

归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。

如　设有数列{10,4,6,3,8,2,5,7}

初始状态：10,4,6,3,8,2,5,7

第一次归并后：{4,10},{3,6},{2,8},{5,7}

第二次归并后：{3,4,6,10}，{2,5,7,8}

第三次归并后：{2,3,4,5,6,7,8,10}

归并排序的代码实现，具体可以从下面几个方面来答:

最基础的实现:

public class MergeSort1 {
    public static void main(String[] args) {
        int[] a = {3, 1, 7, 8, 9, 2, 3, 1, 10, -1};
        mergeSort(a, 0, a.length - 1);
        for (int i : a) {
            System.out.print(i + " ");
        }
    }

    /**
     * 分的时候，直到当前分的段中只剩一个元素
     * @param a
     * @param l
     * @param r
     */

    private static void mergeSort(int[] a, int l, int r) {
        if (l >= r) {
            return;
        }
        int mid = (l + r) / 2;
        mergeSort(a, l, mid);
        mergeSort(a, mid + 1, r);
        merge(a, l, mid, r);
    }

    /**
     * 合并，相当于是两个升序有序数组合并为一个升序数组，在这里需要借助一个辅助的数组，保存排好序的数组
     * 最后将其赋值到原数组对应的位置
     * @param a
     * @param l
     * @param mid
     * @param r
     */

    private static void merge(int[] a, int l, int mid, int r) {
        int[] temp = new int[r - l + 1];
        int i = l, j = mid + 1;
        int p = 0;
        while (i <= mid && j <= r) {
            temp[p++] = a[i] < a[j] ? a[i++] : a[j++];
        }
        while (i <= mid) {
            temp[p++] = a[i++];
        }
        while (j <= r) {
            temp[p++] = a[j++];
        }
        int tempIndex = 0;
        while (tempIndex < temp.length) {
            a[l++] = temp[tempIndex++];
        }

    }
}

简单优化1--合并时加if条件判断

在这里对于mergeSort函数加上了if条件的判断，因为当两个数组本身就是有序的情况下，合并后的结果不变，所以这种情况可以不用做合并

优化2--对于一定长度的段，使用插入排序

虽然插入排序的时间复杂度是o(n^2),归并排序的时间复杂度是o(nlogn),但是这个个时间复杂度本身的基数是不一样的，详细地说，插入排序的时间复杂度是o(n^2/4+n/2-1/2),归并排序的时间复杂度是o(nlogn+n),关于其时间复杂度求解:

https://www.cnblogs.com/zhangtebie/p/11185874.html          https://www.cnblogs.com/sheeva/p/6600666.html

有这两个表达式可见，当n较小的时候，插入的时间复杂度小于归并排序，下面的代码中，对于长度小于等于15的段，使用了插入排序(不一定是15，可以自行计算)

public class MergeSort2 {
    public static void main(String[] args) {
        int[] a = {3, 1, 7, 8, 9, 2, 3, 1, 10, -1, 1, 8, 7, 4, 3, 2,1};
        mergeSort(a, 0, a.length - 1);
        for (int i : a) {
            System.out.print(i + " ");
        }
    }

    /**
     * 当分段后的当前数组的长度小于等于15的时候，采用插入排序
     * @param a
     * @param l
     * @param r
     */
    private static void mergeSort(int[] a, int l, int r) {
        if (r - l <= 15) {
            InsertSort(a, l, r);
            return;
        }
        int mid = (l + r) / 2;
        mergeSort(a, l, mid);
        mergeSort(a, mid + 1, r);
        merge(a, l, mid, r);
    }
    

    /**
     * 两个升序数组合并为一个升序数组
     * @param a
     * @param l
     * @param mid
     * @param r
     */
    public static void merge(int[] a, int l, int mid, int r) {
        int i = l, j = mid + 1;
        int[] temp = new int[r - l + 1];
        int p = 0;
        while (i <= mid && j <= r) {
            temp[p++] = a[i] < a[j] ? a[i++] : a[j++];
        }
        while (i <= mid) {
            temp[p++] = a[i++];
        }
        while (j <= r) {
            temp[p++] = a[j++];
        }
        int tempIndex = 0;
        while (tempIndex < temp.length) {
            a[l++] = temp[tempIndex++];
        }
    }
   

    /**
     * 直接插入排序
     * @param a
     * @param start
     * @param end
     */
    private static void InsertSort(int[] a, int start, int end) {
        int i, j;
        for (i = start + 1; i <= end; i++) {
            int temp = a[i];
            for (j = i - 1; j > -1 && a[j] > temp; j--) {
                a[j + 1] = a[j];
            }
            a[j + 1] = temp;
        }
    }


}

优化三--不使用递归，采用自底向上的方法

对于自定向上的方法，基本思想是给定一个size，初始值为0，第一次对[0,1][1,2][3,4]所在的坐标对应的元素进行排序，然后size依次增大为2,4,8,...（这种思想相当于没有分的过程，借用size，直接进行合并的过程）

public class MergeSort3 {
    public static void main(String[] args) {
        int[] a = {3, 1, 7, 8, 9, 2, 3, 1, 10, -1, 1, 8, 7, 4, 3, 2};
        mergeSort(a);
        for (int i : a) {
            System.out.print(i + " ");
        }
    }

    private static void mergeSort(int[] a) {
        //size依次增大为1,2,4,8,...要保证小于等于数组的长度
        for (int size = 1; size <= a.length; size *= 2) {
            //要考虑到i+size越界的情况，所以i+size<length,考虑到i+size+size-1越界的情况，所以求其与a.length-1的最小值
            for (int i = 0; i + size < a.length; i += 2 * size) {
                MergeSort2.merge(a, i, i + size - 1, Math.min(i + size + size - 1, a.length - 1));
            }
        }
    }
}