快速排序

首先，快速排序采用了“分治的思想”，什么问题可以用到“分治思想”？我们把一个原始问题分解为一系列的子问题，这些子问题拥有和原问题完全一致的解决思路，这种问题就可以用“分治思想”来解决。

“分治”分为三个步骤

1. 分解
2. 解决
3. 合并

下面以快排为例。

分解：

在常规的快排算法中，我们将一个数组中的最后一位标记为“标兵”，通过遍历数组，来将每一个元素与“标兵”进行比较，小于它的放在前面，大于它的放在后面，这样就将一个数组分成了三部分，“小于标兵的子数组”、“标兵”、“大于标兵的子数组”

4被选做“标兵”，从前向后遍历数组，2小于4，放在前面，8大于4，放在后面，7大于4，放在后面……

直到6，原数组被分解为如下：

最后将“标兵”放在两个子数组中间

解决：

然后再对两个子数组进行相同的步骤，直至子子数组只剩下一个元素，此时该子子数组一定是有序的

合并：

合并通常与解决是同时进行的，且合并的前提是子问题已经被解决。

例如左子数组{2,1,3}将被分解为{2,1}{3}{}

左子数组又被分解为{}{1}{2}

此时子数组只剩下一个元素，开始进行合并

{1,2}

{1,2,3}

代码如下：

public class QuickSort {

	public static void main (String[] args) {
		
		int[] a = {2,8,7,1,3,5,6,4};
		quickSort (a, 0, a.length - 1);
		
		for (int i = 0; i < a.length; i++) {
			System.out.println (a[i]);
		}
	}
	
	public static void quickSort (int[] a, int p, int r) {
		int q = partition (a, p, r);
		
		if (p <= q - 1)
			quickSort (a, p, q - 1);
		if (q + 1 <= r)
			quickSort (a, q + 1, r);
	}
	
	public static 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 += 1;
				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;
	}
}

当原数组已经是有序状态时，时间复杂度会增加至Θ(n^2)，为了避免这种情况发生，可以随机寻找一位作为“标兵”，即在partition()方法中增加几行代码

	public static int partition (int[] a, int p, int r) {
		int random = (int)(Math.random () * (r - p) + p);
		int t = a[r];
		a[r] = a[random];
		a[random] = t;
		
		int x = a[r];
		int i = p - 1;
		
		for (int j = p; j < r; j++) {
			if (a[j] <= x) {
				i += 1;
				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;
	}