7、归并排序-基础算法

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

• 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
• 自下而上的迭代；

在《数据结构与算法 JavaScript 描述》中，作者给出了自下而上的迭代方法。但是对于递归法，作者却认为：

However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.

然而，在 JavaScript 中这种方式不太可行，因为这个算法的递归深度对它来讲太深了。

说实话，我不太理解这句话。意思是 JavaScript 编译器内存太小，递归太深容易造成内存溢出吗？还望有大神能够指教。

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

2. 算法步骤

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
4. 重复步骤 3 直到某一指针达到序列尾；
5. 将另一序列剩下的所有元素直接复制到合并序列尾。

3. 动图演示

归并排序动态图

代码实现

package com.data.algorithm;

/**
 * 排序类型： 并归排序
 * 最优：O(n)  
 * 最差时间复杂度：O(nlogn) 
 * 平均时间复杂度：O(nlogn) 
 * 空间复杂度：O(n)
 * 算法点评：结构复杂，效率一般
 * */
public class MergeSortDEMO {

	public static void main(String[] args) {
		int[] ins = {100,2,3,5,1,23,6,78,34,2345,4,67,1,1,467,56};
		mergeSort(ins);
		for(int in: ins){
			System.out.print(in+",");
		}
	}
	
	/**
	 * 归并排序入口
	 * */
	public static void mergeSort(int[] array) {
	        if (array == null || array.length == 0)
	            return;
	        //申请缓存空间
	        int[] temp = new int[array.length];
	        mergeSort(array, 0, array.length - 1, temp);
	 }
	    
	
	//三次归并
	private static void mergeSort(int array[], int first, int last, int temp[]) {
	        if (first < last) {
	            int mid = (first + last) / 2;
	            //1.递归归并左边元素
	            mergeSort(array, first, mid, temp); 
	            //2.递归归并右边元素
	            mergeSort(array, mid + 1, last, temp); 
	            //3.再将二个有序数列合并
	            mergeArray(array, first, mid, last, temp); 
	        }
	}
	 
    /**
     * 合并两个有序数组
     * array[first]~array[mid]为第一组
     * array[mid+1]~array[last]为第二组
     * temp[]为存放两组比较结果的临时数组
     */
    private static void mergeArray(int array[], int first, int mid, int last, int temp[]) {
        int i = first, j = mid + 1; //i为第一组的起点, j为第二组的起点
        int m = mid, n = last; //m为第一组的终点, n为第二组的终点
        int k = 0; //k用于指向temp数组当前放到哪个位置
        
        //1.将两个有序序列循环比较, 填入数组temp
        while (i <= m && j <= n) { 
            if (array[i] <= array[j])
                temp[k++] = array[i++];
            else
                temp[k++] = array[j++];
        }
        
       //2.如果比较完毕, 第一组还有数剩下, 则全部填入temp
        while (i <= m) { 
            temp[k++] = array[i++];
        }
        
        //3.如果比较完毕, 第二组还有数剩下, 则全部填入temp
        while (j <= n) {
            temp[k++] = array[j++];
        }
        
        //4.将排好序的数填回到array数组的对应位置
        for (i = 0; i < k; i++) {
            array[first + i] = temp[i];
        }
    }

}