算法学习（二）——快速排序（Java实现）

排序是算法中比较基础常见的问题，排序算法有很多种，如插入排序、归并排序、堆排序、快速排序、计数排序、基数排序和桶排序。今天来讲讲快速排序。
对于包含n个数的输入数组来说，快速排序的最坏情况时间复杂度为O(n²)，虽然最坏情况时间复杂度很差，但是快速排序通常是实际排序应用中最好的选择，因为它的平均性能非常好：它的期望时间复杂度是O(nlgn)。

快速排序的过程

快速排序使用到了分治的思想，所以我们也按照分之策略的三个步骤来描述快排的过程：
分解：数组A[p…r]被划分为两个（可能为空）子数组A[p…q-1]和A[q+1…r]，使得A[p…q-1]中的每个元素都小于等于A[q]，而A[q]也小于等于A[q+1…r]里的每个元素。
解决：通过递归调用快速排序，对子数组A[p…q-1]和A[q+1…r]进行排序。
合并：经过所有的递归排序后，数组已经是有序的，所以不需要合并操作。
下面是伪代码，分为两个过程：

QUICKSORT(A,p,r)
if p < r
    q = PARTITION(A,p,r)
    QUICKSORT(A,p,q-1)
    QUICKSORT(A,q+1,r)

PARTITION(A,p,r)
x = A[r]
i = p-1
for j =p to r-1
    if A[j] <= x
    i = i + 1
    exchange A[i] with A[j]
exchange A[i+1] with A[r]
return i + 1

PARTITION过程是快排的核心，在这个过程中总是选择一个x=A[r]作为主元，并围绕它来划分数组，经过一个PARTITION后，该主元在数组中的位置已经排好了，不需要对该元素再进行位置交换了，只需要再对该主元前和后的两个子数组进行递归排序就行了。
实现代码如下：

public class QuickSort {

    public static void main(String[] args) {
        int[] a = { 2, 1, 7, 8, 3, 9, 6, 5, 4 };
        quickSort(a, 0, a.length - 1);
        for (int i : a) {
            System.out.println(i);
        }
    }

    public static void quickSort(int[] a, int p, int r) {
        if (p < r) {
            int q = partition(a, p, r);
            quickSort(a, p, q - 1);
            quickSort(a, q + 1, r);
        }
    }

    private static int partition(int[] a, int p, int r) {
        // TODO Auto-generated method stub
        int x = a[r];
        int i = p - 1;
        for (int j = p; j < r; j++) {
            if (a[j] <= x) {
                i = i + 1;
                exchange(a, i, j);
            }
        }
        exchange(a, i + 1, r);
        return i + 1;
    }

    /**
     * 交换数组内的两个元素
     * @param a 数组
     * @param i j 需要交换元素的两个下标值
     */
    public static void exchange(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

结果截图：