快速排序算法

• 算法思路：
  快速排序算法是基于分治策略的一种排序算法，它的思想是，对于输入的子数组a[p,r]，分别执行以下三个步骤：
  ①.分解(divide):以a[q]为基准元素，将a[p,r]划分为三段a[p,q-1],a[q],a[q+1,r]，使得a[p,q-1]中的任何元素都小于等于a[q]，a[q+1,r]中的任何元素都大于等于a[q]，q是在划分过程中确定的。
  ②.递归求解(conquer):通过调用快速排序算法，分别对a[p,q-1]和a[q+1,r]进行排序。
  ③.合并(merge):由于a[p,q-1]和 a[q+1,r]是就地进行的，所以a[p,q-1]和a[q+1,r]都已排好的序后就不需要进行任何计算了，a[p,r]都已排好序。

• 算法实现：

private static void qSort(int p,int r){
    if(p<r){
        int q=partition(p,r);
        qSort(p,q-1);
        qSort(q+1,r);
    }
}

private static int partition(int p,int r){
    int i=p;j=r-1;
    Comparabel x = a[p];
    /*
        将<x的元素交换到左边区域
        将>x的元素交换到右边区域
    */
    while(true){
        while(a[++i].compareTo(x)>0 && i<r);
        while(a[--j].compareTo(x)<0);
        if(i>=j) break;
        MyMath.swap(a,i,j);
    }
    a[p]=a[j];
    a[j]=x;
    return j;
}

• 算法分析

①.最坏情况下时间复杂度（每次划分所产产生的两个区域分别包含n-1个元素和1个元素）：

$$T(n) = \begin{cases} O(1), & \text{n $\le$ 1} \\ T(n-1)+O(n), & \text{n $\gt$ 1} \end{cases}$$
$\qquad\qquad$解此递归方程可得T(n)=O(n $^2$).

②.最好情况下时间复杂度（每次划分所取的基准恰好为中值，每次划分都产生两个大小为n/2的区域）：

$$T(n) = \begin{cases} O(1), & \text{n $\le$ 1} \\ 2T(n/2)+O(n), & \text{n $\gt$ 1} \end{cases}$$
$\qquad\qquad$其解为T(n)=O(nlogn).
③.平均情况下时间复杂度：
$\qquad\qquad\quad$T(n)=O(nlogn).

注解：这个算法是基于比较排序算法中算的快速的，快速排序也因此而得名。

• 算法优化：

  随机化的划分算法实现：

private static int randomizedPartition(int p,int r){
    /*
        快速排序算法的性能取决于划分的对称性。
        通过在a[p,r]中随机选出一个元素作为作为划分基准。
        从而使得划分基准的选择是随机的，可以期望划分是比较对称的。
        random(p,r)产生p和r之间的一个随机整数，且产生不同整数的概率相同。
    */
    int i = random(p,r);
    MyMath.swap(a,i,p);
    return partition(p,r);
}
private static void randomizedQuickSort(int p, int r){
    if(p<r){
        int q = randomizedPartition(p,r);
        randomizedQuickSort(p,q-1);//对左半段排序
        randomizedQuickSort(q+1,r);//对有半段排序
    }
}