归并排序

• 归并排序体现了分治的思想
• 实现方法：
• 将数据分为两组，再比较两组的第一个元素，较小的放入我们最终要输出的数组中，较大的放回原数组，再进行下一次比较。
• 这时候我们会发现比较出来的元素不符合我们的顺序的需求
• 这是因为归并排序的分组要求两个组是有序的
• 那么怎么办呢，我们将原数组再度分组，一直到一组里只有一个元素为止，此时就可以确保组内有序

归并排序

自底向上的归并排序：

自顶向下的归并排序

public class MergeBU {
//自底向上的实现
	private static Comparable[] aux;

	public static void merge(Comparable[] a, int lo, int mid, int hi) {
		int i = lo, j = mid + 1;
		for (int k = lo; k <= hi; k++) {
			aux[k] = a[k];
		}
		for (int k = lo; k <= hi; k++) {
			if (i > mid) {
				a[k] = aux[j++];
			} else if (j > hi) {
				a[k] = aux[i++];
			} else if (less(aux[j], aux[i])) {
				a[k] = aux[j++];
			} else {
				a[k] = aux[i++];
			}
		}
	}

	public static void sort(Comparable[] a) {
		int N = a.length;
		aux = new Comparable[N];
		for (int sz = 1; sz < N; sz = sz + sz) {
			for (int lo = 0; lo < N - sz; lo += sz + sz) {
				merge(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
			}
		}
	}

	private static boolean less(Comparable v, Comparable w) {
		return v.compareTo(w) < 0;
	}

	private static void exch(Comparable[] a, int i, int j) {
		Comparable t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
}

public class MergeSortTopToDown {
//自顶向下
	private static Comparable[] aux;

	public static void merge(Comparable[] a, int lo, int mid, int hi) {
		int i = lo, j = mid + 1;
		for (int k = lo; k <= hi; k++) {
			aux[k] = a[k];
		}
		for (int k = lo; k <= hi; k++) {
			if (i > mid) {
				a[k] = aux[j++];
			} else if (j > hi) {
				a[k] = aux[i++];
			} else if (less(aux[j], aux[i])) {
				a[k] = aux[j++];
			} else {
				a[k] = aux[i++];
			}
		}
	}

	public static void sort(Comparable[] a) {
		aux = new Comparable[a.length];
		sort(a, 0, a.length - 1);
	}

	private static void sort(Comparable[] a, int lo, int hi) {
		if (hi <= lo) {
			return;
		}
		int mid = lo + (hi - lo) / 2;
		sort(a, lo, mid);
		sort(a, mid + 1, hi);
		merge(a, lo, mid, hi);
	}

	private static boolean less(Comparable v, Comparable w) {
		return v.compareTo(w) < 0;
	}

	private static void exch(Comparable[] a, int i, int j) {
		Comparable t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
}

public class ImproveMergeSort {
//归并排序的改进方案
	private static int CUTOFF = 15;
//	1.加快小数组的排序速度（小的话用插入排序）
//	2.检测数组是否已经有序
//	3.递归中交换参数避免数组复制
	public static void merge(Comparable[] src, Comparable[] dest, int lo, int mid, int hi) {
		int i = lo, j = mid + 1;
		//没有在这里每次创建一个辅助数组，然后复制原数组的一部分到这里，使数组原地排序
		for (int k = lo; k <= hi; k++) {
			if (i > mid) {
				dest[k] = src[j++];
			} else if (j > hi) {
				dest[k] = src[i++];
			} else if (less(src[j], src[i])) {
				dest[k] = src[j++];
			} else {
				dest[k] = src[i++];
			}
		}
	}

	public static void sort(Comparable[] a) {
		Comparable[] aux = a.clone();
		//数组在这里直接克隆，没有在merge方法里循环复制，节省了复制数组的开销
		sort(aux, a, 0, a.length - 1);
	}

	private static void sort(Comparable[] src, Comparable[] dest, int lo, int hi) {
		if (hi - lo < CUTOFF) {
			insertionSort(dest, lo, hi);
			return;
		}
		int mid = lo + (hi - lo) / 2;
		sort(dest, src, lo, mid);
		sort(dest, src, mid + 1, hi);
		if (less(src[mid + 1], src[mid])) {
			//我们认为如果mid+1大于mid的元素值的话，该数组即有序
			//小的话就继续归并
			merge(src, dest, lo, mid, hi);
		}
	}

	public static void insertionSort(Comparable[] a, int lo, int hi) {
		for (int i = lo; i <= hi; i++) {
			for (int j = i; j > lo && less(a[j], a[j - 1]); j--) {
				exch(a, j, j - 1);
			}
		}
	}

	private static boolean less(Comparable v, Comparable w) {
		return v.compareTo(w) < 0;
	}

	private static void exch(Comparable[] a, int i, int j) {
		Comparable t = a[i];
		a[i] = a[j];
		a[j] = t;
	}

• 复杂度分析：

  平均时间复杂度：O(nlogn)
  最佳时间复杂度：O(n)
  最差时间复杂度：O(nlogn)
  空间复杂度：O(n)
  排序方式：In-place
  稳定性：稳定