排序算法总结之快速排序 Quick Sort

算法原理：

快速排序采用分治的思想 （divide and conquer）：

1. 首先将原数组根据pivot的值划分成两个字数组，一个数组的的值都小于pivot， 一个数组的值都大于pivot；

2. 对两个子数组分别进行排序

3. 把已经有序的子数组合并得到有序的数组。

算法伪代码：

伪代码出自算法导论快速排序算法部分

QUICKSORT (A, p, r)

if (p < r)

then q = patition (A, p, r)

QUICKSORT (A, p, q-1)

QUICKSORT (A, q+1, r)

PARTITION (A, p, r)

x = A[r]

i = p - 1

for j=p to r-1

do if A[j] < x

then i = i + 1

exchange A[i] - A[j]

exchange A[i + 1] - A[r]

return i + 1

算法性能分析：

时间复杂度：算法的时间复杂度取决于pivot的选择，因为pivot的选择决定了最终划分的两个字数组是否平均。

    1. 最坏情况 O(n^2)

最坏情况产生于每次选择的pivot都是最大的，即数组已经是排好序的，从而导致划分的子数组元素个数分别为n-1和n，算法时间复杂度可以用公式表示为：

T(n) = T(n-1) + T(0) + cn

    2. 最好情况 O(nlogn)

最好的情况产生于每次选择的pivot都可以把数组平均分成两个子数组， 算法时间复杂度的公式表示为：

T(n) = 2T(n/2) + cn

    3. 平均情况 O(nlogn)

使用算法导论中的方法，假设每次子数组的划分比例为9:1，算法的时间复杂度公式为：

T(n) = T(9n/10) + T(n/10) + cn

空间复杂度：快速排序算法的空间复杂度的产生源于递归调用时栈空间的使用。

      1. 最坏情况 O(n)

最坏情况下需要进行n-1次递归调用

      2. 最好情况和平均情况 O(logn)

最好情况和平均情况下需要 O(logn)次递归调用

稳定性：不稳定

快速排序的Java版本实现：

	private void quick(int[] A, int p, int r)
	{
<span style="white-space:pre">		</span>if(p < r)
		{
			int q = partition(A, p, r);
			quick(A, p, q-1);
			quick(A, q+1, r);
		}
	}
	
	private int partition(int[] A, int p, int r)
	{
		int x = A[r];
		int i = p - 1;
		for(int j=p;j<r;j++)
		{
			if(A[j] < x)
			{
				i++;
				int temp = A[i];
				A[i] = A[j];
				A[j] = temp;
			}
		}
		int temp = A[i+1];
		A[i+1] = A[r];
		A[r] = temp;
		return i+1;
	}