快速排序（Quick Sort）：快速排序算法是基于分治策略的另一个排序算法。其基本思想是，对于输入的子数组a[p:r]，按以下三个步骤进行排序：

　　（1）分解（Divide）：以a[p]为基准元素将a[p:r]划分成3段a[p:q-1]，a[q]，和a[q+1:r]，使a[p:q-1]中任何一个元素都小于等于a[q]，而a[q+1:r]中任何一个元素都大于等于a[q]。下标q在划分过程中确定。

　　（2）递归求解（Conquer）：通过递归调用快速排序算法分别对a[p:q-1]和a[q+1:r]进行排序。

　　（3）合并（Merge）：由于对a[p:q-1]和a[q+1:r]的排序是就地进行的，所以在a[p:q-1]和a[q+1:r]都已排好的序后，不需要执行任何计算，a[p:r]就已排好序。

基于这个思想，可以实现快速排序算法如下：

1 private static int[] quickSort(int[] a,int l,int r){
2     if(l < r){
3         int q = partition(a,l,r);
4         quickSort(a,l,q-1);
5         quickSort(a,q+1,r);
6     }
7     return a;
8 }

上述算法中的函数Partition，以一个确定的基准元素a[pivot]对子数组a[l:r]（个人比较习惯用l，r）进行划分，它是快速排序算法的关键，代码如下：

 1 private static int partition(int[] a,int l,int r){
 2     int i = l;
 3     int j = r;
 4     int pivot = a[l];
 5     int temp;
 6     System.out.println("开始时pivot="+pivot); //查看开始时的pivot，非必要
 7     while(true){
 8         while(a[i] <= pivot && i < r)
 9             ++i;   //i一直向后移动，直到出现a[i]>pivot
10         System.out.println("i="+i); //查看当前的i，非必要
11         while(a[j] > pivot)
12             --j;   //j一直向前移动，直到出现a[j]<pivot
13         System.out.println("j="+j); //查看当前的j，非必要
14         if(i >= j) break;
15         temp = a[i];      //交换a[i]和a[j]
16         a[i] = a[j];
17         a[j] = temp;
18         System.out.print("中间过程的数组：");
19         for(int m:a)
20             System.out.print(m+" ");         //输出每次更改为止后的数组，非必要
21         System.out.println();
22     }
23     a[l] = a[j];
24     a[j] = pivot;
25     System.out.println("结束时pivot="+pivot);  //查看循环结束时的pivot，非必要
26     System.out.print("Partition结束后的数组：");
27     for(int m:a)
28         System.out.print(m+" ");            //输出Partition结束后的数组，非必要
29     System.out.println();
30     return j;
31 }

我在一些地方安插了输出语句来监测数组以及一些重要变量的变化，读者可以根据这些输出语句，一步一步地理解快排的工作过程。

以下是测试代码：

1 public static void main(String[] args) {
2     int[] a = {73,12,87,43,25,93,32,26,57,65};
3     int[] b = quickSort(a,0,a.length-1);
4     for(int i : b)
5         System.out.print(i+" ");
6 }

由于添加了很多辅助理解用的输出语句，结果的输出比较长，就不贴出来了，有兴趣学习快速排序的读者可以把这段代码运行一次，也会有很多收获！

如有不对的地方或对该算法有更好的建议，请指出！