归并排序解析（java版）

归并（Merge）排序：

将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

实现：

public static <T extends Comparable<? extends T>> 
		void mergeSort0(T[] arrays, T[] tmpArr, int low, int high) {		
		
		if (low+1 < high) {
			int middle = (low + high) >>> 1;
			mergeSort0(arrays, tmpArr, low, middle);
			mergeSort0(arrays, tmpArr, middle, high);
//			当两个子列表连接有序，直接返回
			if (((Comparable)arrays[middle - 1]).compareTo(arrays[middle]) <= 0) {
				return;
			}
			
			int start1 = low;	//子序列1的起点
			int start2 = middle;	//子序列2的起点
			int startTmpArr = low;  //缓存数组起点
			//将两个已排序的子列表合并（当两个子序列均未到尾部时）
			while (start1 < middle && start2 < high) {
				if (((Comparable)arrays[start1]).compareTo(arrays[start2]) < 0) {
					tmpArr[startTmpArr] = arrays[start1++];
				}else {
					tmpArr[startTmpArr] = arrays[start2++];
				}
				startTmpArr++;
			}
			//若子序列2数据已到尾，直接插入子序列1数据
			while (start1 < middle) {
				tmpArr[startTmpArr++] = arrays[start1++];
			}
			//若子序列1数据已到尾，直接插入子序列2数据
			while (start2 < middle) {
				tmpArr[startTmpArr++] = arrays[start2++];
			}
			//从缓存数组中复制已排序的数据
//			for (;low < high; low++) {
//				arrays[low] = tmpArr[low];
//			}		
			System.arraycopy(tmpArr, low, arrays, low, high-low);
		}
	}

JDK自带：

//	JDK自带归并排序
	 private static final int INSERTIONSORT_THRESHOLD = 7; 
	  private static void mergeSort(Object[] src,
              Object[] dest,
              int low,
              int high,
              int off) {
		int length = high - low;
		
		// Insertion sort on smallest arrays
		if (length < INSERTIONSORT_THRESHOLD) {
			for (int i=low; i<high; i++)
			for (int j=i; j>low &&
			     ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
				swap(dest, j, j-1);
			return;
		}
			
		// Recursively sort halves of dest into src
		int destLow  = low;
		int destHigh = high;
		low  += off;
		high += off;
		int mid = (low + high) >>> 1;
		mergeSort(dest, src, low, mid, -off);
		mergeSort(dest, src, mid, high, -off);
			
		// If list is already sorted, just copy from src to dest.  This is an
		// optimization that results in faster sorts for nearly ordered lists.
		if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
			System.arraycopy(src, low, dest, destLow, length);
			return;
		}
			
		// Merge sorted halves (now in src) into dest
		for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
			if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
			dest[i] = src[p++];
			else
			dest[i] = src[q++];
		}
	}
	 
	  
	  private static void swap(Object[] x, int a, int b) {
	        Object t = x[a];
	        x[a] = x[b];
	        x[b] = t;
	    }

结论和感触：

JDK自带实现比较简单，而且是一种新的思路，值得我们学习，所以阅读源码真的是一件快速提升自己的方式，不仅能学习到大师的思想，而且可以扩宽自己的思路，对java的学习也更加深入，不至于坐进观天，沾沾自喜。有人说C++比java难，比java好，看到很多前辈说：语言实际无所谓好坏，只是工具而已，重要的是你要理解工具的用途和用法，尺有所长，寸有所短。没有最好的语言，只有当你在特定的模式格局下，最适合的语言。然而更重要的是你自身，语言是死的，语法是固定的，人是活的，思想是无拘束的，学而不思则罔，思而不学则殆。所以多学、多思、多想方为上策，总结知识和自己的优缺得失也是很重要的，加油。