Day30——快速排序

快速排序的基本思想：在待排序表中任何一个元素作为枢轴，一趟排序结束后，通过枢轴元素的最终位置，将待排序序列分成两个子序列，然后对这两个子序列进行上述过程，直到确定所有元素的位置。

不难发现在快速排序过程中，是在不断缩小问题规模的，所以说快速排序基于分治思想。

标准算法思想实现第一趟排序过程：


标准算法思想整个排序过程：

标准算法思想过程代码实现：

/**
	 *********************
	 * Quick sort recursively.
	 * 
	 * @param paraStart The start index.
	 * @param paraEnd   The end index.
	 *********************
	 */
	public void quickSortRecursive(int paraStart, int paraEnd) {
		// Nothing to sort.
		if (paraStart >= paraEnd) {
			return;
		} // Of if

		int tempPivot = data[paraEnd].key;
		DataNode tempNodeForSwap;

		int tempLeft = paraStart;
		int tempRight = paraEnd - 1;

		// Find the position for the pivot.
		// At the same time move smaller elements to the left and bigger one to the
		// right.
		while (true) {
			while ((data[tempLeft].key < tempPivot) && (tempLeft < tempRight)) {
				tempLeft++;
			} // Of while

			while ((data[tempRight].key >= tempPivot) && (tempLeft < tempRight)) {
				tempRight--;
			} // Of while

			if (tempLeft < tempRight) {
				// Swap.
				System.out.println("Swapping " + tempLeft + " and " + tempRight);
				tempNodeForSwap = data[tempLeft];
				data[tempLeft] = data[tempRight];
				data[tempRight] = tempNodeForSwap;
			} else {
				break;
			} // Of if
		} // Of while

		// Swap
		if (data[tempLeft].key > tempPivot) {
			tempNodeForSwap = data[paraEnd];
			data[paraEnd] = data[tempLeft];
			data[tempLeft] = tempNodeForSwap;
		} else {
			tempLeft++;
		} // Of if

		System.out.print("From " + paraStart + " to " + paraEnd + ": ");
		System.out.println(this);

		quickSortRecursive(paraStart, tempLeft - 1);
		quickSortRecursive(tempLeft + 1, paraEnd);
	}// Of quickSortRecursive

	/**
	 *********************
	 * Quick sort.
	 *********************
	 */
	public void quickSort() {
		quickSortRecursive(0, length - 1);
	}// Of quickSort

空穴法实现第一趟排序过程：

代码：

 /**
	 * 
	 *********************
	 * @Title: quickSortRecursive
	 * @Description: TODO(Quick sort recursively.)
	 *
	 * @param paraStart The start index.
	 * @param paraEnd The end index.
	 *********************
	 *
	 */
	public void quickSortRecursive(int paraStart, int paraEnd) {
		// Nothing to sort.
		if (paraStart >= paraEnd)
			return;

		int tempPivot = data[paraEnd].key;
		DataNode tempPivotNode = data[paraEnd];

		int tempLeft = paraStart;
		int tempRight = paraEnd;
		// Find the position for the pivot.
		while (tempLeft < tempRight) {
			while ((data[tempLeft].key <= tempPivot) && (tempLeft < tempRight))
				tempLeft++;
			data[tempRight] = data[tempLeft];
			while ((data[tempRight].key >= tempPivot) && (tempLeft < tempRight))
				tempRight--;
			data[tempLeft] = data[tempRight];

		} // Of while

		data[tempLeft] = tempPivotNode;

		System.out.print("From " + paraStart + " to " + paraEnd + ": ");
		System.out.println(this);

		quickSortRecursive(paraStart, tempLeft - 1);
		quickSortRecursive(tempLeft + 1, paraEnd);
	}// Of quickSortRecursive

	/**
	 *********************
	 * Quick sort.
	 *********************
	 */
	public void quickSort() {
		quickSortRecursive(0, length - 1);
	}// Of quickSort

测试代码：

	/**
	 *********************
	 * Test the method.
	 *********************
	 */
	public static void quickSortTest() {
		int[] tempUnsortedKeys = { 1, 3, 12, 10, 5, 7, 9 };
		String[] tempContents = { "if", "then", "else", "switch", "case", "for", "while" };
		DataArray tempDataArray = new DataArray(tempUnsortedKeys, tempContents);

		System.out.println(tempDataArray);

		tempDataArray.quickSort();
		System.out.println("Result\r\n" + tempDataArray);
	}// Of quickSortTest

运行结果（空穴法）：

复杂度分析：
整个序列的快速排序过程可以表示为：

不难从图中发现，树的高度等于排序的趟数等于递归深度。对n个元素的待排序序列来说，每一趟进行元素比较和交换的时间复杂度为$O(n)$，在最好的情况下（每次都对称划分列表），总的时间复杂度为$O(n{\log }_{2}n)$趟排序，空间复杂度为$O({\log }_{2}n)$；在最坏的情况下（序列基本有序或逆序），则总的时间复杂度为$O(n^2)$，空间复杂度为$O(n)$。但由于快速排序算法平均情况下的运算时间与最佳情况下的运行时间接近，所以快速排序的平均空间复杂度为$O({\log }_{2}n)$，平均时间复杂度为$O(n{\log }_{2}n)$，也因此快速排序算法被称为是排序算法中平均性能最优的排序算法。