数据结构和算法面试题系列—排序算法之快速排序

这个系列是我多年前找工做时对数据结构和算法总结，其中有基础部分，也有各大公司的经典的面试题，最先发布在CSDN。现整理为一个系列给须要的朋友参考，若有错误，欢迎指正。本系列完整代码地址在 这里。

0 概述

快速排序也是基于分治模式，相似归并排序那样，不一样的是快速排序划分最后不须要merge。对一个数组 A[p..r] 进行快速排序分为三个步骤：

• 划分： 数组 A[p...r] 被划分为两个子数组 A[p...q-1] 和 A[q+1...r]，使得 A[p...q-1] 中每一个元素都小于等于 A[q]，而 A[q+1...r] 每一个元素都大于 A[q]。划分流程见下图。
• 解决： 经过递归调用快速排序，对子数组分别排序便可。
• 合并：由于两个子数组都已经排好序了，且已经有大小关系了，不须要作任何操做。

快速排序算法不算复杂的算法，可是实际写代码的时候倒是最容易出错的代码，写的不对就容易死循环或者划分错误，本文代码见 这里。

1 朴素的快速排序

这个朴素的快速排序有个缺陷就是在一些极端状况如全部元素都相等时（或者元素自己有序，如 a[] = {1,2,3,4,5}等），朴素的快速算法时间复杂度为 O(N^2)，而若是可以平衡划分数组则时间复杂度为 O(NlgN)。

/**
 * 快速排序-朴素版本
 */
void quickSort(int a[], int l, int u)
{
    if (l >= u) return;

    int q = partition(a, l, u);
    quickSort(a, l, q-1);
    quickSort(a, q+1, u);
}

/**
 * 快速排序-划分函数
 */
int partition(int a[], int l, int u)
{
    int i, q=l;
    for (i = l+1; i <= u; i++) {
        if (a[i] < a[l])
            swapInt(a, i, ++q);
    }
    swapInt(a, l, q);
    return q;
}
复制代码

2 改进-双向划分的快速排序

一种改进方法就是采用双向划分，使用两个变量 i 和 j，i 从左往右扫描，移太小元素，遇到大元素中止；j 从右往左扫描，移过大元素，遇到小元素中止。而后测试i和j是否交叉，若是交叉则中止，不然交换 i 与 j 对应的元素值。

注意，若是数组中有相同的元素，则遇到相同的元素时，咱们中止扫描，并交换 i 和 j 的元素值。虽然这样交换次数增长了，可是却将全部元素相同的最坏状况由 O(N^2) 变成了差很少 O(NlgN) 的状况。好比数组 A={2,2,2,2,2}， 则使用朴素快速排序方法，每次都是划分 n 个元素为 1 个和 n-1 个，时间复杂度为 O(N^2)，而使用双向划分后，第一次划分的位置是 2，基本能够平衡划分两部分。代码以下：

/**
 * 快速排序-双向划分函数
 */
int partitionLR(int a[], int l, int u, int pivot)
{
    int i = l;
    int j = u+1;
    while (1) {
        do {
            i++;
        } while (a[i] < pivot && i <= u); //注意i<=u这个判断条件，不能越界。

        do {
            j--;
        } while (a[j] > pivot);

        if (i > j) break;

        swapInt(a, i, j);
    }

    // 注意这里是交换l和j，而不是l和i，由于i与j交叉后，a[i...u]都大于等于枢纽元t，
    // 而枢纽元又在最左边，因此不能与i交换。只能与j交换。
    swapInt(a, l, j);

    return j;
}

/**
 * 快速排序-双向划分法
 */
void quickSortLR(int a[], int l, int u)
{
    if (l >= u) return;

    int pivot = a[l];
    int q = partitionLR(a, l, u, pivot);
    quickSortLR(a, l, q-1);
    quickSortLR(a, q+1, u);
}
复制代码

虽然双向划分解决了全部元素相同的问题，可是对于一个已经排好序的数组仍是会达到 O(N^2) 的复杂度。此外，双向划分还要注意的一点是代码中循环的写法，若是写成 while(a[i]<t) {i++;} 等形式，则当左右划分的两个值都等于枢纽元时，会致使死循环。

3 继续改进—随机法和三数取中法取枢纽元

为了解决上述问题，能够进一步改进，经过随机选取枢纽元或三数取中方式来获取枢纽元，而后进行双向划分。三数取中指的就是从数组A[l... u]中选择左中右三个值进行排序，并使用中值做为枢纽元。如数组 A[] = {1, 3, 5, 2, 4}，则咱们对 A[0]、A[2]、A[4] 进行排序，选择中值 A[4](元素4) 做为枢纽元，并将其交换到 a[l] ，最后数组变成 A[] = {4 3 5 2 1}，而后跟以前同样双向排序便可。

/**
 * 随机选择枢纽元
 */
int pivotRandom(int a[], int l, int u)
{
    int rand = randInt(l, u);
    swapInt(a, l, rand); // 交换枢纽元到位置l
    return a[l];
}

/**
 * 三数取中选择枢纽元
 */
int pivotMedian3(int a[], int l, int u)
{
     int m = l + (u-l)/2;

     /*
      * 三数排序
      */
     if( a[l] > a[m] )
        swapInt(a, l, m);

     if( a[l] > a[u] )
        swapInt(a, l, u);

     if( a[m] > a[u] )
        swapInt(a, m, u);

     /* assert: a[l] <= a[m] <= a[u] */
     swapInt(a, m, l); // 交换枢纽元到位置l

     return a[l];
}
复制代码

此外，在数据基本有序的状况下，使用插入排序能够获得很好的性能，并且在排序很小的子数组时，插入排序比快速排序更快，能够在数组比较小时选用插入排序，而大数组才用快速排序。

4 非递归写快速排序

非递归写快速排序着实比较少见，不过练练手老是好的。须要用到栈，注意压栈的顺序。代码以下：

/**
 * 快速排序-非递归版本
 */
void quickSortIter(int a[], int n)
{
    Stack *stack = stackNew(n);
    int l = 0, u = n-1;
    int p = partition(a, l, u);

    if (p-1 > l) { //左半部分两个边界值入栈
        push(stack, p-1); 
        push(stack, l);
    }

    if (p+1 < u) { //右半部分两个边界值入栈
        push(stack, u);
        push(stack, p+1);
    }

    while (!IS_EMPTY(stack)) { //栈不为空，则循环划分过程
        l = pop(stack);
        u = pop(stack);
        p = partition(a, l, u);

        if (p-1 > l) {
            push(stack, p-1);
            push(stack, l);
        }

        if (p+1 < u) {
            push(stack, u);
            push(stack, p+1);
        }
    }
}
复制代码

参考资料

• 《数据结构和算法-C语言实现》
• 《算法导论》