快速排序解剖（递归）

算法介绍和思想

快速排序是对冒泡排序的一种改进，它也是“交换”类排序的一种。它的基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法过程和步骤

一趟快速排序的具体做法是：附设两个指针low和high，它们的初值分别为low和high，设枢轴记录的关键字为pivotkey，则首先从high所指位置起镶嵌搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换，然后从low所指位置起向后搜索，找到第一个关键字大于pivotkey的记录和枢轴记录互相交换，重复这两步直至low=high为止。

实质上，快速排序就三个步骤：

第一步：将待排序序列一分为二

第二步：对小于pivotkey的低子表递归排序

第三步：对大于pivotkey的高子表递归排序

算法代码(Java)

/**
 * 第一步：将待排序序列一分为二
 * 第二步： 对低子表递归排序
 * 第三步：对高子表递归排序
 * @author 卡罗-晨
 */
public class QuickSort {
	
	/**
	 * 将序列一分为二，并返回枢轴位置
	 * @param a
	 * @param low
	 * @param high
	 * @return
	 */
	private static <T extends Comparable<? super T>> int partition(T[] a,int low,int high) {
		T pivotkey = a[low];
		while(low<high) {
			while(low<high && a[high].compareTo(pivotkey)>=0) --high;
			a[low] = a[high];
			while(low<high && a[low].compareTo(pivotkey)<=0) ++low;
			a[high] = a[low];
		}
		a[low] = pivotkey;
		return low;
	}
	
	/**
	 * 快速排序三步走
	 * @param a
	 * @param low
	 * @param high
	 */
	private static <T extends Comparable<? super T>> void qSort(T[] a,int low,int high) {
		if(low<high) {
			int pivotloc = partition(a, low, high);
			qSort(a, low, pivotloc-1);
			qSort(a, pivotloc+1, high);
		}
	}
	
	public static <T extends Comparable<? super T>> void quickSort(T[] a) {
		qSort(a, 0, a.length-1);
	}

}

算法分析

时间复杂度

快速排序最好情况下的时间复杂度为O()，待排序列越接近无序，本算法效率越高。最坏情况下的时间复杂度为O(n^2)，待排序列越接近有序，本算法效率越低。平均时间复杂度为O()。就平均时间而言，快速排序是所有排序算法中最好的。快速排序的排序躺数和初始序列有关。

空间复杂度

本算法空间复杂度为O()。快速排序是递归进行的，递归需要栈的辅助，因此它需要的辅助空间比前面几类排序算法多。

一个方法实现快速排序

public static void quickSort(int[] a,int low,int high) {
		int temp;
		int i = low,j = high;
		if(low < high) {
			temp = a[low];
			while(i != j) {
				while(j>i&&a[j]>=temp) --j;
				if(i<j) {
					a[i] = a[j];
					++i;
				}
				while(i<j&&a[i]<=temp) ++i;
				if(i<j) {
					a[j] = a[i];
					--j;
				}
				a[i] = temp;
				quickSort(a, low, i-1);
				quickSort(a, i+1, high);
			}
		}
	}