常见的排序算法——快速排序

本文记述了快速排序的基本思想和一份参考实现代码，并在说明了算法的性能后用随机数据进行了验证。

◆ 思想

基于分治思想的快速排序，使用切分函数找到一个切分位置，保证其左侧子范围内的所有元素都不大于切分位置的元素，右侧子范围内的所有元素都不小于切分位置的元素。然后用递归调用分别对两个子范围排序。

算法的核心是切分函数。先随机取用一个元素作为切分元素，然后从待排序范围的左端开始向右扫描直到找到一个大于等于它的元素，在从数组的右端向左扫描直到找到一个小于等于它的元素，交换这两个元素。如此反复，直到左右扫描相遇为止。最后将切分元素与相遇点元素交换，即完成切分。如要得到逆序的结果，则仅需改变比较的方向即可。

◆ 实现

排序代码采用《算法（第4版）》的“排序算法类模板”实现。(代码中涉及的基础类，如 Array，请参考算法文章中涉及的若干基础类的主要API）

// quick.hxx

...

class Quick
{

    ...
    
    template
    <
        class _T,
        class = typename std::enable_if<std::is_base_of<Comparable<_T>, _T>::value>::type
    >
    static
    void
    sort(Array<_T> & a)
    {
        Std_Random::shuffle(a);              // #1
        __sort__(a, 0, a.size()-1);
    }
    
    ...
    
    template
    <
        class _T,
        class = typename std::enable_if<std::is_base_of<Comparable<_T>, _T>::value>::type
    >
    static
    void
    __sort__(Array<_T> & a, int lo, int hi)
    {
        if (hi <= lo) return;
        int j = __partition__(a, lo, hi);       // #2
        __sort__(a, lo, j-1);                // #3
        __sort__(a, j+1, hi);
    }

    ...

    template
    <
        class _T,
        class = typename std::enable_if<std::is_base_of<Comparable<_T>, _T>::value>::type
    >
    static
    void
    __partition__(Array<_T> & a, int lo, int hi)
    {
        int i = lo, j = hi+1;
        _T v = a[lo];              // #4
        while (true) {
            while (__less__(a[++i], v)) if (i == hi) break;      // #5
            while (__less__(v, a[--j])) if (j == lo) break;      // #6
            if (i >= j) break;
            __exch__(a, i, j);
        }
        __exch__(a, lo, j);         // #7
        return j;
    }

    ...
    
    template
    <
        class _T,
        class = typename std::enable_if<std::is_base_of<Comparable<_T>, _T>::value>::type
    >
    static
    bool
    __less__(_T const& v, _T const& w)
    {
        return v.compare_to(w) < 0;         // #8
    }

    ...
    
    template
    <
        class _T,
        class = typename std::enable_if<std::is_base_of<Comparable<_T>, _T>::value>::type
    >
    static
    void
    __exch__(Array<_T> & a, int i, int j)
    {
        _T t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    ...

“快速排序最多需要约 N^2 / 2 次比较，但随机打乱数组能够预防这种情况。”（引《算法（第4版）》）（#1）。 使用切分函数找到一个切分位置（#2），将待排序元素分为左右两个待排序子范围，然后用递归调用分别对两个子范围分别排序（#3）。切分函数中，先用第一个元素作为切分元素（#4），然后从待排序范围的左端开始向右扫描直到找到一个大于等于它的元素（#5），再从数组的右端向左扫描直到找到一个小于等于它的元素（#6），交换这两个元素。如此继续，直到左右扫描相遇为止。最后将切分元素与相遇点元素交换（#7），即完成切分。将 '<' 改为 '>'，即得到逆序的结果（#8）。

◆ 性能

时间复杂度	空间复杂度	是否稳定
N*log(N)	log(N)	否

◆ 验证

测试代码采用《算法（第4版）》的倍率实验方案，用随机数据验证其正确性并获取时间复杂度数据。

// test.cpp
    
...

time_trial(int N)
{
    Array<Double> a(N);
    for (int i = 0; i < N; ++i) a[i] = Std_Random::random();    // #1
    Stopwatch timer;
    Quick::sort(a);                     // #2
    double time = timer.elapsed_time();
    assert(Quick::is_sorted(a));            // #3
    return time;
}

...

test(char * argv[])
{
    int T = std::stoi(argv[1]);          // #4
    double prev = time_trial(512);
    Std_Out::printf("%10s%10s%7s\n", "N", "Time", "Ratio");
    for (int i = 0, N = 1024; i < T; ++i, N += N) {            // #5
        double time = time_trial(N);
        Std_Out::printf("%10d%10.3f%7.2f\n", N, time, time/prev);   // #6
        prev = time;
    }
}

...

用 [0,1) 之间的实数初始化待排序数组（#1），打开计时器后执行排序（#2），确保得到正确的排序结果（#3）。整个测试过程要执行 T 次排序（#4）。每次执行排序的数据规模都会翻倍（#5），并以上一次排序的时间为基础计算倍率（#6），

此测试在实验环境一中完成，

$ g++ -std=c++11 test.cpp std_out.cpp std_random.cpp stopwatch.cpp type_wrappers.cpp

$ ./a.out 15

         N      Time  Ratio
      1024     0.007   2.33
      2048     0.015   2.14
      4096     0.031   2.07
      8192     0.066   2.13
     16384     0.137   2.08
     32768     0.293   2.14
     65536     0.609   2.08
    131072     1.293   2.12
    262144     2.690   2.08
    524288     5.526   2.05
   1048576    12.020   2.18
   2097152    24.061   2.00
   4194304    50.476   2.10
   8388608   103.608   2.05
  16777216   217.020   2.09

可以看出，随着数据规模的成倍增长，排序所花费的时间将是上一次规模的 2.1? 倍，且在不断波动地变小。将数据反映到以 2 为底数的对数坐标系中，可以得到如下图像，

O(N*log(N)) 代表了线性对数级别复杂度下的理论排序时间，该行中的数据是以 Time 行的第一个数据为基数逐一乘 2 + 2/log(N) 后得到的结果（因为做的是倍率实验，所以乘 (2*N*log(2*N)) / (N*log(N))，化简得到 2 + 2/log(N)，即乘 2+2/log(1024)，2+2/log(2048)，2+2/log(4096)，... 2+2/log(16777216)；因为是二分递归，所以 log 的底数为 2）。

◆ 最后

完整的代码请参考 [gitee] cnblogs/18227388 。

查看性能对比，了解此算法与其它排序算法的相似性和差异性。

写作过程中，笔者参考了《算法（第4版）》的快速排序、“排序算法类模板”和倍率实验。致作者 Sedgwick，Wayne 及译者谢路云。