改进排序算法：归并排序

堆排序：利用了完全二叉树的特性，深度是[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 <= end)
            arrTemp[k++] = arr[j++];
        while (m <= end)
            arr[m] = arrTemp[m++];
    }*/

    private void Merge(int[] arr, int start, int middle, int end)
    {
        int[] arrTemp = new int[end - start + 1];
        int i = start;
        int j = middle + 1;
        int k = 0;
        int m = 0;
        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 <= end)
            arrTemp[k++] = arr[j++];
        for (m = 0; m < arrTemp.length; m++)
            arr[m + start] = arrTemp[m];
    }
}

如果每个Merge的每个递归调用均局部声明一个临时数组，那么在任意时刻就可能有logN个临时数组处在活动期。由于Merge是MSort的最后一行，因此在任一时刻只需要一个临时数组在活动，而且这个临时数组可以在MergeSort驱动程序中建立。不仅如此，我们还可以使用该临时数组的任意部分，使用与输入数组相同的部分。

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)
    {
        int[] arrTmp = new int[arr.length];
        MSort(arr, arrTmp, 0, arr.length - 1);
    }

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

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

归并排序复杂度分析：

时间复杂度：

一次归并需要将相邻的长度为k的有序序列进行两两归并，需要将待排序序列中的记录扫描一遍，耗费O(n)时间，由完全二叉树的深度可知整个归并排序需要进行[log2n]次。总的时间复杂度为O(nlogn)，这是归并排序算法中最好、最坏和平均的时间性能。

空间复杂度：

由于归并在归并过程中需要与原始记录序列同样数量的存储空间存放归并结果以及递归时深度为log2n的栈空间，空间复杂度为O(n+logn)。

Merge函数需要两两比较，不存在跳跃，因此归并排序是一种稳定的排序算法。

归并是一种比较占用内存，但却效率高且稳定的算法。

二：非递归实现归并排序

将递归转化成迭代。

非递归的迭代做法：从最小的序列开始归并，直至完成。

递归做法：先拆分递归，再归并退出递归。

非递归的迭代方法，避免了递归深度为log2n的栈空间，空间复杂度只是O(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,10,11,7,3,8,8,4};
        s.MergeSort2(arr);
        System.out.println(Arrays.toString(arr));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8, 10, 11]
    }

    private void MergeSort2(int[] arr)
    {
        int k = 1;
        while (k <= arr.length)
        {
            MergePass(arr, k, arr.length);
            k = 2 * k;
        }
    }

    private void MergePass(int[] arr, int s, int n)//将arr数组中，两个相邻长度为s的子序列两两归并进长度为n的序列中
    {
        int i = 0;
        while (i <= n - 2 * s - 1)
        {
            Merge(arr, i, i + s - 1, i + s * 2 - 1); //首i，尾i+2s-1，长2s，中间i+s-1
            i = i + 2 * s;
        }
        if (i <= n - s - 1)
            Merge(arr, i, i + s - 1, n - 1);
    }

    private void Merge(int[] arr, int start, int middle, int end)
    {
        int[] arrTemp = new int[end - start + 1];
        int i = start;
        int j = middle + 1;
        int k = 0;
        int m = 0;
        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 <= end)
            arrTemp[k++] = arr[j++];
        for (m = 0; m < arrTemp.length; m++)
            arr[m + start] = arrTemp[m];
    }
}

import java.util.Arrays;

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

    private void MergeSort2(int[] arr)
    {
        int k = 1;
        int[] arrTmp = new int[arr.length];
        while (k <= arr.length)
        {
            MergePass(arr, arrTmp, k, arr.length);
            k = 2 * k;
        }
    }

    private void MergePass(int[] arr, int[] arrTmp, int s, int n)//将arr数组中，两个相邻长度为s的子序列两两归并进长度为n的序列中
    {
        int i = 0;
        while (i <= n - 2 * s - 1)
        {
            Merge(arr, arrTmp, i, i + s - 1, i + s * 2 - 1); //首i，尾i+2s-1，长2s，中间i+s-1
            i = i + 2 * s;
        }
        if (i <= n - s - 1)
            Merge(arr, arrTmp, i, i + s - 1, n - 1);
    }

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