排序（二）

总结一下归并排序和快排

归并排序：非原地排序，稳定排序，时间复杂度O(nlogn)，空间复杂度O(n)。

public static void mergeSort(int[] list, int[] tempList, int head, int tail) {
	if (head < tail) {
		// 取分割位置
		int middle = (head + tail) / 2;
		// 递归划分列表的左序列
		mergeSort(list, tempList, head, middle);
		// 递归划分列表的右序列
		mergeSort(list, tempList, middle + 1, tail);
		// 列表的合并操作
		merge(list, tempList, head, middle + 1, tail);
	}
}
public static void merge(int[] list, int[] tempList, int head, int middle, int tail) {
	// 左指针尾
	int headEnd = middle - 1;
	// 右指针头
	int rearStart = middle;
	// 临时列表的下标
	int tempIndex = head;
	// 列表合并后的长度
	int tempLength = tail - head + 1;

	// 先循环两个区间段都没有结束的情况
	while ((headEnd >= head) && (rearStart <= tail)) {
		// 如果发现右序列大，则将此数放入临时列表
		if (list[head] < list[rearStart]) {
			tempList[tempIndex++] = list[head++];
		} else {
			tempList[tempIndex++] = list[rearStart++];
		}
	}

	// 判断左序列是否结束
	while (head <= headEnd) {
		tempList[tempIndex++] = list[head++];
	}

	// 判断右序列是否结束
	while (rearStart <= tail) {
		tempList[tempIndex++] = list[rearStart++];
	}

	// 复制到原数组
	for (int i = 0; i < tempLength; i++) {
		list[tail] = tempList[tail];
		tail--;
	}
}

快排：原地排序，不稳定排序，最好时间复杂度O(nlogn)，最坏时间复杂度O(n2），平均时间复杂度O(nlogn）。

public static void quickSort(int[] list, int left, int right) {
	if (left < right) {
		// 分割数组，找到分割点
		int point = partition(list, left, right);

		// 递归调用，对左子数组进行快速排序
		quickSort(list, left, point - 1);
		// 递归调用，对右子数组进行快速排序
		quickSort(list, point + 1, right);
	}
}
public static int partition(int[] list, int left, int right) {
	// 用数组的第一个元素作为基准数
	int first = list[left];
	while (left < right) {
		while (left < right && list[right] >= first) {
			right--;
		}
		// 交换
		swap(list, left, right);

		while (left < right && list[left] <= first) {
			left++;
		}
		// 交换
		swap(list, left, right);
	}
	// 返回分割点所在的位置
	return left;
}
public static void swap(int[] list, int left, int right) {
	int temp;
	if (list != null && list.length > 0) {
		temp = list[left];
		list[left] = list[right];
		list[right] = temp;
	}
}