算法--归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

例如:
设有数列{6，202，100，301，38，8，1}

初始状态：6,202,100,301,38,8,1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；

总的比较次数为：3+4+4=11；

逆序数为14；

归并排序的算法原理：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并
移动指针到下一位置

重复步骤三直到某一指针超出序列尾

最后将另一序列剩下的所有元素直接复制到合并序列尾

稳定性：

归并排序是稳定的排序，即相等的元素的顺序不会改变。

算法复杂度：

时间复杂度为O(nlog n) 这是该算法中最好、最坏和平均的时间性能。

空间复杂度为 O(n)。

比较操作的次数介于(nlogn) / 2和nlogn - n + 1。

赋值操作的次数是(2nlogn)。归并算法的空间复杂度为：0 (n)。

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

代码实现（自顶向下）：

public class Merge {
	private static int[] aux;
	public static void sort(int[] arr) {
		aux = new int[arr.length];
		sort(arr,0,arr.length - 1);
	}
	
	private static void sort(int[] a,int fir,int las) {
		if (las <= fir) {
			return;
		}
		int mid = fir + (las - fir)/2;
		sort(a,fir,mid);//将左半边排序
		sort(a,mid+1,las);//将右半边排序	
		merge(a,fir,mid,las);//归并
	}

	public static void merge(int[] a, int fir, int mid, int las) {
		int i = fir;
		int j = mid + 1;
		
		for (int k = fir; k <= las;k++) {
			aux[k] = a[k];	
		}
		
		for (int k = fir;k <= las;k++) {
			if (i > mid) {
				a[k] = aux[j++];
			}else if (j > las) {
				a[k] = aux[i++];
			}else if (less(aux[j],aux[i])) {
				a[k] = aux[j++];
			}else {
				a[k] = aux[i++];
			}
		}
		
	}
	
	private static boolean less(int i, int j) {	
		return i < j;
	}

	public static void main(String[] args) {
		int[] arr = {8,5,2,4,6,7,1,3,9,0};
		System.out.println("排序前：");
		for (int i : arr) {
			System.out.print(i + " ");
		}
		System.out.println();
		
		sort(arr);
		
		System.out.println("排序后：");
		for (int i : arr) {
			System.out.print(i + " ");
		}
		System.out.println();
	}
}

运行结果：

改进：

上面的代码实现归并排序是先将数组分为左右两个大的子数组，再分别对子数组排序，最后将两个子数组归并。

其实我们还可以先归并最小的子数组（即只含一个元素的数组），然后再成对归并得到的子数组，直到整个数组归并成有序的数组，这种方法叫自底向上的归并排序。

public class Merge2 {
	private static int[] aux;
	public static void sort(int[] arr) {
		int N = arr.length;
		aux = new int[N];
		for(int sz = 1;sz < N;sz = sz+sz) {
			for (int lo = 0;lo < N - sz;lo += sz+sz) {
				merge(arr,lo,lo+sz-1,Math.min(lo+sz+sz-1, N-1));
			}
		}
	}
	
	public static void merge(int[] a, int fir, int mid, int las) {
		int i = fir;
		int j = mid + 1;
		
		for (int k = fir; k <= las;k++) {
			aux[k] = a[k];	
		}
		
		for (int k = fir;k <= las;k++) {
			if (i > mid) {
				a[k] = aux[j++];
			}else if (j > las) {
				a[k] = aux[i++];
			}else if (less(aux[j],aux[i])) {
				a[k] = aux[j++];
			}else {
				a[k] = aux[i++];
			}
		}	
	}
	
	private static boolean less(int i, int j) {	
		return i < j;
	}

	public static void main(String[] args) {
		int[] arr = {8,5,2,4,6,7,1,3,9,0};
		System.out.println("排序前：");
		for (int i : arr) {
			System.out.print(i + " ");
		}
		System.out.println();
		
		sort(arr);
		
		System.out.println("排序后：");
		for (int i : arr) {
			System.out.print(i + " ");
		}
		System.out.println();
	}
}