快速排序算法可能是应用最广泛的排序算法了。它实现简单，适用于各种不同的输入数据且在一般应用中比其他排序算法都要快。

该算法的实现可分为以下几步：

1. 在数组中选一个基准数（通常为数组第一个）；

2. 将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边；

3. 对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只有一个元素，即为全部有序。

动态图

例如有一需要排序的数组为：23,45,17,11,13,89,72,26,3,17,11,13（从小到大排序）：

选取数组第一个数23为基准数，存入temp变量中，

从数组的左右两边界向中间进行遍历，定义两个指针 i 和 j，i 最开始指向数组的第一个元素，j 最开始指向数组的最后一个元素。

指针 i 从左向右移动，指针 j 从右向左移动。先移动 j 指针（从右往左移），当 j 指向的数大于基准数时，略过，j 继续往左移动，直到遇到小于等于基准数的数arr[j]，将arr[j]填入arr[i]中；再移动 i 指针，当 i 指向的数小于等于基准数时，略过，i 继续往右移动，直到遇到不比基准数小的数arr[i]，将arr[i]填入arr[j]中；

再移动 i 指针，再移动 j 指针…(轮换移动)，直到 i 和 j 指针相遇，此时将temp（基准数）填入arr[i]中即完成算法的第2个步骤。

接下来分别将基准数左边和右边的数组按照以上方法进行聚合，直到每个子集只有一个元素，即排序完成。

可能描述得有些抽象，接下来用图一步一步的示意：

1.将数组第一个数23赋给temp变量，指针 i 指向数组第一个元素，指针 j 指向数组最后一个元素

2.从 j 开始遍历（从右往左），遇到13时，因为13<=temp，因此将arr[j]填入arr[i]中，即此时指针 i 指向的数为13；

3.再从 i 遍历（从左往右），遇到45时，因为45>temp，因此将arr[i]填入arr[j]中，此时指针 j 指向的数为45；

4.继续从 j 遍历，遇到11时，因为11<=temp，因此将arr[j]填入arr[i]中，即此时指针 i 指向的数为11；

5.从 i 遍历，遇到89时，因为89>temp，因此将arr[i]填入arr[j]中，此时指针 j 指向的数为89；

6.从 j 遍历，遇到17时，因为17<=temp，因此将arr[j]填入arr[i]中，即此时指针 i 指向的数为17；

7.从 i 遍历，遇到72时，因为72>temp，因此将arr[i]填入arr[j]中，此时指针 j 指向的数为72；

8.从 j 遍历，遇到3时，因为3<=temp，因此将arr[j]填入arr[i]中，即此时指针 i 指向的数为3；

9.从 i 遍历，遇到26时，因为26>temp，因此将arr[i]填入arr[j]中，此时指针 j 指向的数为26；

10.从 j 遍历，和 i 重合；将 temp（基准数23）填入arr[i]中。

代码

 public class QuickSort {
    public static void sort(Comparable[] a) {
        sort(a, 0, a.length - 1);
    }
    private static void sort(Comparable[] a, int lo, int hi) {
        if (hi <= lo) {
            return;
        }
        int j = partition(a, lo, hi);//切分
        sort(a, lo, j - 1);
        sort(a, j + 1, hi);
    }
    private static int partition(Comparable[] a, int lo, int hi) {
        //将数组切分为a[lo...i-1],a[i],a[i+1...hi]
        int i = lo; //左边扫描指针
        int j = hi + 1;//右边扫描指针
        //切分元素
        Comparable v = a[lo];
        while (true) {
            //扫描左右，检查扫描是否结束，并交换元素
            //当a[i]大于v时，循环跳出
            while (less(a[++i], v)) {
                if (i == hi) break;
            }
            //当a[j]小于v时，循环跳出
            while (less(v, a[--j])) {
                if (j == lo) break;
            }
            if (i >= j) {
                break;
            }
            swap(a, i, j);
        }
        swap(a, lo, j); //将v=a[j]放入到正确位置
        return j;  //a[lo..j-1]<a[j]<a[j+1..hi] 达成
    }
    /**
     * 交换元素
     *
     * @param arr
     * @param a
     * @param b
     */    public static void swap(Comparable[] arr, int a, int b) {
        Comparable temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
    public static void main(String[] args) {
        String[] a = new String[]{"t", "g", "c", "p", "f", "w", "v"};
        sort(a);
        show(a);
    }
}
  

输出结果：

c f g p t v w