快速排序

        快速排序（Quick Sort）是由图灵奖获得者Tony Hoare设计出来，被列为20世纪十大算法之一，以“快速”命名表明该算法在整体性能上是排序算法的王者。

        核心思想是：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。一趟排序过程示意图如下。

        一趟排序中需要选择一个关键字，使得其左边的值都比它小，右边的值比它大 ，这个关键字称为枢轴（pivot）。示意图中选择下标low所表示key作为pivot，可以进行优化，即三数取中法（median-of-three），一般取左端、右端和中间三个数中的进行排序，取中间数作为枢轴，这样从概率上讲中间数位于中间的值的可能性大大提高，从后面的性能分析中可知，pivot取值越是位于中间其排序性能越好。再者其交换过程可以进行优化，示意图是交换，可以用替换代替交换。一趟排序代码如下。

	/**
	 * 一趟快速排序
	 * 
	 * @Title: partition
	 * @Description:一趟快速排序实现
	 * @param array
	 *            待排序数组
	 * @param low
	 *            起始下标
	 * @param high
	 *            结束下标
	 * @return int pivot所在下标
	 */
	private int partition(int[] array, int low, int high)
	{
		int pivot;

		// ----------------------median-of-three--------------------------//
		int mid = (low + high) / 2;
		if (array[low] > array[high])
		{
			swap(array, low, high);
		}
		if (array[mid] > array[high])
		{
			swap(array, mid, high);
		}
		if (array[mid] > array[low])
		{
			swap(array, mid, low);
		}
		// ---------------------------------------------------------------//

		pivot = array[low]; // first element as pivot

		while (low < high)
		{
			while ((low < high) && (array[high] >= pivot))
			{
				high--;
			}
			// swap(array, low, high);
			array[low] = array[high];
			while ((low < high) && (array[low] <= pivot))
			{
				low++;
			}
			// swap(array, low, high);
			array[high] = array[low];
		}
		array[low] = pivot;
		return low;
	}

快速排序算法的代码如下：

	/**
	 * 快速排序
	 * 
	 * @Title: qucikSort
	 * @Description: 快速排序实现函数
	 * @param array
	 *            待排序数组 void
	 */
	public void qucikSort(int[] array)
	{
		qSort(array, 0, array.length - 1);
	}

	private void qSort(int[] array, int low, int high)
	{
		int pivot;
		if (low < high)
		{
			pivot = partition(array, low, high);
			qSort(array, low, pivot - 1);
			qSort(array, pivot + 1, high);
		}
	}

可以进行优化，减少一次递归操作，实现代码如下：

	private void qSort(int[] array, int low, int high)
	{
		int pivot;
		while (low < high)
		{
			pivot = partition(array, low, high);
			qSort(array, low, pivot - 1);
			low = pivot + 1;
		}
	}

性能分析：

        快速排序的时间性能取决于递归的深度，最优的情况是Partition每次都划分得比较均匀，如果排序n个关键字，其递归树的深度为，即仅需递归次，每次需要遍历整个序列，需要O(n)的时间，所以整个快速排序算法在最优的情况下时间复杂度为O(nlogn)。最坏的情况是一颗斜树，其深度为n，所以最坏的情况其时间复杂度为。平均的情况下，可以证明其数量级为。由于其关键字比较和交换是跳跃式的，因此快速排序是一种不稳定的排序算法。