【排序】归并排序（Merging Sort）

归并排序（Merging sort）

原理：分治思想—如果一个数组有n个数据，则可以把这个数组看作n个有序的子序列，每个子序列的长度为1，然后两两归并，就能得到[n/2]个长度为2（或者1，落单的)的字序列，再不断地两两归并，直到得到一个长度为n的有序数组。

时间复杂度：$\mathrm{O}(n\log n)$

参考链接

递归的归并排序

import java.util.Arrays;
public class test {
	 public static void MergeSort2(int[] arr, int low, int high)
	    {
	        //使用递归的方式进行归并排序，所需要的空间复杂度是O（N+logN）
	        int mid = (low + high)/2;
	        if(low < high)
	        {
	            //递归地对左右两边进行排序
	            MergeSort2(arr, low, mid);
	            MergeSort2(arr, mid+1, high);
	            //合并
	            merge(arr, low, mid, high);
	        }
	    }
	    
	    //merge函数实际上是将两个有序数组合并成一个有序数组
	    //因为数组有序，合并很简单，只要维护几个指针就可以了
	    private static void merge(int[] arr, int low, int mid, int high)
	    {
	        //temp数组用于暂存合并的结果
	        int[] temp = new int[high - low + 1];
	        //左半边的指针
	        int i = low;
	        //右半边的指针
	        int j = mid+1;
	        //合并后数组的指针
	        int k = 0;
	        
	        //将记录由小到大地放进temp数组
	        for(; i <= mid && j <= high; k++)
	        {
	            if(arr[i] < arr[j])
	                temp[k] = arr[i++];
	            else
	                temp[k] = arr[j++];
	        }
	        
	        //接下来两个while循环是为了将剩余的（比另一边多出来的个数）放到temp数组中
	        while(i <= mid)
	            temp[k++] = arr[i++];
	        
	        while(j <= high)
	            temp[k++] = arr[j++];
	        
	        //将temp数组中的元素写入到待排数组中
	        for(int l = 0; l < temp.length; l++)
	            arr[low + l] = temp[l];
	    }
	public static void main(String[] args) {
		int [] nums = {9, 1, 5, 8, 3, 7, 4, 6, 2};
		MergeSort2(nums, 0, nums.length-1);
		System.out.println(Arrays.toString(nums));
	}
}

非递归的（迭代）归并排序

避免了递归方法时深度为${\log }_{2}n$空间，推荐非递归方法实现

import java.util.Arrays;
public class test {
	public static void MergeSort2(int[] arr)
    {
        //使用非递归的方式来实现归并排序
        int len = arr.length;
        int k = 1;
        while(k < len)
        {
            MergePass(arr, k, len);
            k *= 2;            
        }
    }

    //MergePass方法负责将数组中的相邻的有k个元素的字序列进行归并
    private static void MergePass(int[] arr, int k, int n)
    {
        int i = 0;
        //从前往后,将2个长度为k的子序列合并为1个
        //理解为i+2*k-1<n  --> i < n-2*k+1
        while(i + 2*k -1 < n)
        {
            merge(arr, i, i + k-1, i + 2*k - 1);
            //注意i的更新步长
            i += 2*k;
        }

        //这段代码保证了，将那些“落单的”长度不足两两merge的部分和前面merge起来。
        //理解为i+k<n，也就是至少剩下k个数，这样merge函数左半部分长度保证为k，右半部分长度保证>=1
        //如果剩下的数字个数小于k，不用管了，直接在原数组的最后即可
        if(i + k - 1 + 1 < n)
        {
            merge(arr, i, i+k-1, n-1);
        }
    }

    //merge函数实际上是将两个有序数组合并成一个有序数组
    //一个是arr[low......mid]，一个是arr[mid+1.....high]
    //因为数组有序，合并很简单，只要维护几个指针就可以了
    private static void merge(int[] arr, int low, int mid, int high)
    {
        //temp数组用于暂存合并的结果
        int[] temp = new int[high - low + 1];
        //左半边的指针
        int i = low;
        //右半边的指针
        int j = mid+1;
        //合并后数组的指针
        int k = 0;

        //将记录由小到大地放进temp数组，注意指针更新
        for(; i <= mid && j <= high; k++)
        {
            if(arr[i] < arr[j])
                temp[k] = arr[i++];
            else
                temp[k] = arr[j++];
        }

        //接下来两个while循环是为了将剩余的（比另一边多出来的个数）放到temp数组中
        while(i <= mid)
            temp[k++] = arr[i++];

        while(j <= high)
            temp[k++] = arr[j++];

        //将temp数组中的元素写入到待排数组中
        for(int p = 0; p < temp.length; p++)
            arr[low + p] = temp[p];
    }

		
	public static void main(String[] args) {
		int [] nums = {9, 1, 5, 8, 3, 7, 4, 6, 2};
		MergeSort2(nums);
		System.out.println(Arrays.toString(nums));
	}
}