快速排序算法解析与实现

 每日一算法，今天我们来谈谈快速排序算法。为什么叫它快速排序呢？因为它快呗。也许有人会笑，其实这里说的也没错，目前的数据规模来看，它是最快的，而且是原址排序，就是不需要额外的空间来存放数据（归并排序就是非原址的）。但是这里要明确的是它的最坏时间复杂度确是O（n^2）。这个和堆排序还有归并排序不一样，它们即使最坏情况也是O（nlogn）。因为快速排序的平均时间复杂度是O(nlogn)，并且常数因子很小，所以它可以达到很快的速度。

  下面来看看快速排序的实现原理：

 

原理说明：可以看到，就是在数据集中，选择任意一个元素key，然后将集合一分为二，左边数据集是小于key，而右边数据集是大于等于key的。

然后再分别对左右两个数据集做递归处理，因为key的位置就是最终排序好的位置，所以递归结束后就全部排序好了！！！

这就是快速排序的基本思想。

     但是需要注意的是，key的选择至关重要，它决定了排序的快慢。如果key选择最大的元素或者最小的元素，就可能导致分拆的最差情况，左边是n-1个数，右边是0个数。写成递归公式则是T(n) = T(n-1) + O(n)。这个公式计算一下可以发现T(n)=O(n^2)。这是最糟糕的情况。当然，我们希望最好是两边数量均衡，为T(n) = 2*T(n/2) + O(n)的形式。但是一般很难达到，如果是事先进行过预排序后的数据，我们更不能随意选择第一个或者最后一个作为key了。更好的做法是三元中位数法，简单来说就是在数据中随意挑出三个数据，去中位数作为key，一般我们选择第一个，最后一个，和中间一个来挑选中位数。

    这是用java实现的int[]快速排序算法：

<span style="font-size:18px;">package charp_1;


public class QuickSort {
	public static void main(String[] args)
	{
		int[] b = new int[]{10, 2, 3, 5, 7, 6, 100, 0, -3, 16};
		System.out.println("before quickSort:");
		print(b);
		quickSort(b);
		System.out.println("after quickSort:");
		print(b);
		
	}
	
	public static void print(int[] a)
	{
		for (int i = 0; i < a.length; i++) {
			System.out.printf("%d ", a[i]);
		}
		System.out.println();
	}
	
	public static void quickSort(int[] a)
	{
		subQuickSort(a, 0, a.length - 1);
	}
	
	private static void subQuickSort(int[] a, int p, int r)
	{
		if (p < r) {
			int q = partition(a, p, r);
			subQuickSort(a, p, q-1);
			subQuickSort(a, q+1, r);
		}
	}
	
	private static void swap(int[] a, int i, int j)
	{
		int tmp = a[i];
		a[i] = a[j];
		a[j] = tmp;
	}
	
	private static int partition(int[] a, int p, int r)
	{
		int key = a[r];
		int i = p - 1;
		for (int j = p; j < r; j++) {
			if (a[j] <= key) {
				i++;
				swap(a, i, j);
			}
		}
		swap(a, i+1, r);
		return i+1;
	}

	
}
</span>

运行的结果是：

细心的你会发现这里我并没有用刚刚提到的三元中位数法，所以这个算法很可能会在预处理数据面前变的不那么高效！！！

我们可以将上面的partition函数换成下面的partition2函数：

<span style="font-size:18px;">	private static int partition2(int[] a, int p, int r)
	{
		int mid = (p + r) / 2;
		int med;
		if (a[p] <= a[mid] && a[mid] <= a[r])
			med = mid;
		else if (a[mid] <= a[p] && a[p] <= a[r])
			med = p;
		else {
			med = r;
		}
		int key = a[med];
		swap(a, med, r);
		int i = p - 1;
		for (int j = p; j < r; j++) {
			if (a[j] <= key) {
				i++;
				swap(a, i, j);
			}
		}
		swap(a, i+1, r);
		return i+1;
	}</span>

运行结果是一样的，但是很显然下面的算法会更高效一下。

既然用了java就不能写这么没有扩展性的程序，起码来个泛型快排吧，可以处理任意数据类型的数组！！！下面是泛型快排代码：

<span style="font-size:18px;">/**
 * 
 */
package charp_1;


/**
 * @author freestyle458
 *
 */
public class QuickSort2 {
	public static void main(String[] args)
	{
		int[] b = new int[]{-17, 8, 100 ,6, 16, 1, 2, 78};
		Integer[] items = new Integer[b.length];
		for (int i = 0; i < items.length; i++)
			items[i] = b[i];
		System.out.println("before quickSort:");
		print(items);
		quickSort(items);
		System.out.println("after quickSort:");
		print(items);
	}
	
	public static <T extends Comparable<T>> void print(T[] items)
	{
		for (int i = 0; i < items.length; i++)
			System.out.printf(items[i] + " ");
		System.out.println();
	}
	
	public static <T extends Comparable<T>> void quickSort(T[] items)
	{
		subQuickSort(items, 0, items.length-1);
	}
	
	public static <T extends Comparable<T>> void subQuickSort(T[] items, int p, int r)
	{
		if (p < r) {
			int q = partition(items, p, r);
			subQuickSort(items, p, q-1);
			subQuickSort(items, q+1, r);
		}
	}
	
	private static <T extends Comparable<T>> void swap(T[] items, int i, int j)
	{
		T tmp = items[i];
		items[i] = items[j];
		items[j] = tmp;
	}
	
	private static <T extends Comparable<T>> int partition(T[] items, int p, int r)
	{
		int midIndex = (p+r)/2;
		int medIndex;
		if (items[p].compareTo(items[midIndex]) <= 0 &&
			items[midIndex].compareTo(items[r]) <= 0)
			medIndex = midIndex;
		else if (items[midIndex].compareTo(items[p]) <= 0 &&
				 items[p].compareTo(items[r]) <= 0)
			medIndex = p;
		else {
			medIndex = r;
		}
		
		swap(items, medIndex, r);
		
		int i = p - 1;
		T key = items[r];
		for (int j = p; j < r; j++) {
			if (items[j].compareTo(key) <= 0) {
				i++;
				swap(items, i, j);
			}
		} 
		swap(items, i+1, r);
		
		return i+1;
	}
	
}


</span>

运行结果是：

除了可以排序整数外，我们来试一下排序字符串看看：

<span style="font-size:18px;">	public static void main(String[] args)
	{
		String[] items = new String[]{"asdfdas", "wrb", "asdf", "ohnkh", "yexin"};
		System.out.println("before quickSort:");
		print(items);
		quickSort(items);
		System.out.println("after quickSort:");
		print(items);
	}</span>

其实快排思想很重要，在很多时候我们都可以借助快排思想来高效的完成一些工作，具体等到结合编程题目来看看吧！！

以一张快排趣图结束：