归并排序

之前讲了一些基础的排序算法，以及堆排序，现在给大家讲讲高级排序算法——归并排序，归并排序有自顶向下的归并排序以及自底向上的归并排序。排序按照从小到大的顺序。

自顶向下的归并排序

 算法思想：将整个数组按照一半划分，再对子数组对半分，直到子数组的元素个数为1。然后再对数组进行归并，归并的过程对数组进行排序。排序需要使用额外的空间进行。算法思想使用了递归的思想，“递”的过程是对数组对半划分，“归”的过程是对子数组进行排序，直到整体有序为止。

1.对数组进行对半划分

2.对子数组进行归并排序

算法分析：时间复杂度为O(nlogn)，空间复杂度为O(n)。归并排序的重点就是对两个子数组进行排序的过程，这个子过程需要将两个数组进行复制，用两个指针分别指向两个复制的子数组的起始位置，比较这两个位置元素的大小，将小的元素放到数组的最左边，依次进行这样的过程。

代码

public class Sort{
    public static void mergeSort(int[] arr){
        mergeSort(arr,0,arr.length-1);
    }
    private static void mergeSort(int[] arr, int l, int r){
        if(l>=r) return;
        int mid = l+(r-l)/2;
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        merge(arr,l,mid,r);
    }
    private static void merge(int[] arr, int l, int mid, int r){
	        int[] copy = new int[r-l+1];
	        //for(int i=l;i<=r;i++) copy[i-l] = arr[l];
	        //左数组[l,mid],右数组[mid+1,r]
	        int i = l, j = mid+1;
	        int k;
	        for(k=0;k<copy.length;k++){
	        	if(i>mid || j >r) break;
	            if(arr[i] <= arr[j]) {//有等号，这样才是稳定的
	            	copy[k] = arr[i];
	            	i++;
	            }
	            else{
	            	copy[k] = arr[j];
	            	j++;
	            } 
	        }
	        while(i<=mid){copy[k] = arr[i];k++;i++;}
	        while(j<=r){copy[k] = arr[j];j++;k++;}
	        for(int r1=0;r1<copy.length;r1++) arr[r1+l] = copy[r1];
	}
  
}

上述实现的归并排序对于近乎有序的数组而言，效果并不理想，这里我们可以进行优化。

优化

归并排序算法中，归并操作的结果是每个子数组是有序的，但对整体数组而言是大致有序。可以通过比较mid位置左右两边的元素，如果arr[mid]<=arr[mid+1]，那么就不必进行归并操作了，这样一步优化，对于近乎有序的数组的排序时间会大大降低。

 private static void mergeSort(int[] arr, int l, int r){
        if(l>=r) return;
        int mid = l+(r-l)/2;
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        if(arr[mid] > arr[mid+1])//对于近乎有序数组的优化
            merge(arr,l,mid,r);
    }

对于近乎有序的数组排序而言，插入排序的性能比优化过的归并排序还要快，如果数组元素很少的情况下。这是因为归并排序的递归操作需要对栈进行读写，虽然归并排序的时间复杂度是O(nlogn)，但插入排序是O(n*n)，但对于元素个数较少的情况下，插入排序更快。所以递归不必在递归到元素个数为1，但元素个数小于一定值时，改为插入排序。

 private static void mergeSort(int[] arr, int l, int r){
        //if(l>=r) return;
        if(r-l <= 15) {
            insertSort(arr,l,r);
            return;
        }
        int mid = l+(r-l)/2;
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        if(arr[mid] > arr[mid+1])//对于近乎有序数组的优化
            merge(arr,l,mid,r);
    }
private static void insertSort(int[] arr, int l,int r){
		 for(int i=l+1;i<=r;i++){
			 int temp = arr[i];
			 int j;
			 for(j=i;j>l && temp<arr[j-1];j--){
				 arr[j] = arr[j-1];
			 }
			 arr[j] = temp;
		 }
	 }

自底向上的归并排序

算法思想：将数组从左到右依次将数组划分为小段，如果2个元素划分为一个小段，然后进行归并排序的过程，再用4个元素为一个小段划分，进行归并排序，再用4*2个元素划分，直到大于等于整个数组的元素个数。

该过程不需要使用递归，只需要进行迭代即可完成z。代码加上了之前的两个优化

代码

public Class Sort{
 public static void mergeSortButtomToUp(int[] arr){
        int n=arr.length;
         for(int sz=1;sz<=n;sz+=sz){
            for(int j=0; j+sz<n; j+=sz+sz){
                //对arr[l...l+sz-1]和arr[l+sz...l+sz+sz-1]进行归并  \
            	if(arr[j+sz-1] > arr[j+sz]){
            		if(sz+sz<=15) insertSort(arr,j,Math.min(j+sz+sz-1,n-1));
            		else merge(arr,j,j+sz-1,Math.min(j+sz+sz-1,n-1)); 
            	}
            }
        }
    } 
     private static void merge(int[] arr, int l, int mid, int r){
	        int[] copy = new int[r-l+1];
	        //for(int i=l;i<=r;i++) copy[i-l] = arr[l];
	        //左数组[l,mid],右数组[mid+1,r]
	        int i = l, j = mid+1;
	        int k;
	        for(k=0;k<copy.length;k++){
	        	if(i>mid || j >r) break;
	            if(arr[i] <= arr[j]) {
	            	copy[k] = arr[i];//有等号，这样才是稳定的
	            	i++;
	            }
	            else{
	            	copy[k] = arr[j];
	            	j++;
	            } 
	        }
	        while(i<=mid){copy[k] = arr[i];k++;i++;}
	        while(j<=r){copy[k] = arr[j];j++;k++;}
	        for(int r1=0;r1<copy.length;r1++) arr[r1+l] = copy[r1];
	}
      
}

自顶向下的归并排序与自底向上的归并排序的比较

自底向下的归并排序要比自顶向下的归并排序快很多，原因是自顶向下的归并排序使用了递归，递归需要对java栈进行读写，在大规模数据面前，很浪费时间，多以自底向下的归并排序要更快，对空间要求也更小一些。