改进排序算法：归并排序

堆排序：利用了完全二叉树的特性，深度是[log2n]+1，所以效率比较高。

一般，涉及到完全二叉树结构的排序算法，效率都不低。

归并：将两个或两个以上的有序表组合成一个新的有序表。

归并排序（2路归并排序）：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]（[x]表示不小于x的最小整数）个长度为2或1的有序子序列；再两两归并，...，如此重复，直至得到一个长度为n的有序序列为止。

一：递归实现归并排序

import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] arr = {4,5,1,6,2,7,3,8,8,4};
        s.MergeSort(arr);
        System.out.println(Arrays.toString(arr));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]
    }

    private void MergeSort(int[] arr)
    {
        MSort(arr,0, arr.length - 1);
    }

    private void MSort(int[] arr, int start, int end)
    {
        if (start >= end) return;
        else
        {
            int middle = start + (end - start) / 2;
            MSort(arr, start, middle);
            MSort(arr, middle + 1, end);
            Merge(arr, start, middle, end);
        }
    }

    /*private void Merge(int[] arr, int start, int middle, int end)
    {
        int[] arrTemp = new int[arr.length];
        int i = start;
        int j = middle + 1;
        int k = start;
        int m = start;
        while (i <= middle && j <= end)
        {
            if (arr[i] <= arr[j])
                arrTemp[k++] = arr[i++];
            else
                arrTemp[k++] = arr[j++];
        }
        while (i <= middle)
            arrTemp[k++] = arr[i++];
        while (j <=