内部排序之快速排序、归并排序、堆排序

公共方法

public static void swap(int[] data, int i, int j) {

	int tmp = data[i];
	data[i] = data[j];
	data[j] = tmp;
}

public static void assertSuccess(String clazzName) {

	Runtime runtime = Runtime.getRuntime();
	runtime.gc();

	boolean success = true;
	long startTime = System.currentTimeMillis();
	long startMem = runtime.freeMemory();
	try {
		Class clazz = Class.forName(clazzName);
		@SuppressWarnings("unchecked")
		Method method = clazz.getMethod("sort", int[].class);

		for (int i = 0; i < 1_000; i++) {
			int[] data = random.ints(0, 1_000).limit(1_000).toArray();
			int[] copyData = Arrays.copyOf(data, data.length);
			method.invoke(null, data);
			Arrays.sort(copyData);

			Assert.assertArrayEquals(copyData, data);
		}
	}
	catch (Exception e) {
		success = false;
	}
	long consumedTime = (System.currentTimeMillis() - startTime) / 1000;
	long orz = (startMem - runtime.freeMemory()) / 1024;

	if (success) {
		System.out.println("测试通过！！！, 花费的时间是: " + consumedTime + "秒, 消耗的内存是: " + orz + "KB");
	}
	else {
		System.out.println("测试不通过！！！");
	}
}

快速排序

public static void sort(int[] data) {

	if (data == null || data.length < 2) {
		return;
	}

	sort(data, 0, data.length - 1);
}

private static void sort(int[] data, int start, int end) {
	
	if (start >= end) {
		return;
	}
	
	int pi = partition(data, start, end);
	sort(data, start, pi - 1);
	sort(data, pi + 1, end);
}

private static int partition(int[] data, int start, int end) {

	int ri = start + (int)(Math.random() * (end - start + 1));
	swap(data, ri, end);
	
	int small = start - 1;
	for (int i = start; i < end; i++) {
		if (data[i] < data[end] && ++small < i) {
			swap(data, small, i);
		}
	}

	swap(data, ++small, end);
	
	return small;
}

归并排序

public static void sort(int[] data) {

	if (data == null || data.length < 2) {
		return;
	}

	sort(data, 0, data.length - 1, new int[data.length]);
}

private static void sort(int[] data, int start, int end, int[] temp) {

	if (start >= end) {
		return;
	}

	int mid = (start + end) / 2;
	sort(data, start, mid, temp);
	sort(data, mid + 1, end, temp);
	merge(data, start, mid, end, temp);
}

private static void merge(int[] data, int start, int mid, int end, int[] temp) {

	int left = start, right = mid + 1, t = 0;

	while (left <= mid && right <= end) {
		temp[t++] = data[left] < data[right] ? data[left++] : data[right++];
	}
	while (left <= mid) {
		temp[t++] = data[left++];
	}
	while (right <= end) {
		temp[t++] = data[right++];
	}

	t = 0;
	while (start <= end) {
		data[start++] = temp[t++];
	}
}

堆排序

public static void sort(int[] data) {

	if (data == null || data.length < 2) {
		return;
	}

	for (int cur = data.length / 2 - 1; cur >= 0; cur--) {

		sink(data, cur, data.length);
	}

	for (int bound = data.length - 1; bound > 0; bound--) {
		swap(data, 0, bound);
		sink(data, 0, bound);
	}
}

private static void sink(int[] data, int cur, int bound) {
	int left = 2 * cur + 1;
	int right = left + 1;
	while (left < bound) {
		int max = (right < bound && data[left] < data[right]) ? right : left;
		if (data[cur] >= data[max]) {
			return;
		}

		swap(data, cur, max);
		cur = max;
		left = 2 * cur + 1;
		right = left + 1;
	}
}