C/C++ Quick Sort Algorithm

本系列文章由 @YhL_Leo 出品，转载请注明出处。

文章链接： http://blog.csdn.net/yhl_leo/article/details/50255069

---

快速排序算法，由C.A.R.Hoare于1962年提出，算法相当简单精炼，基本策略是随机分治。首先选取一个枢纽元（pivot），然后将数据划分成左右两部分，左边的大于（或等于）枢纽元，右边的小于(或等于枢纽元)，最后递归处理左右两部分。分治算法一般分成三个部分：分解、解决以及合并。快排是就地排序，所以就不需要合并了。只需要划分（partition）和解决（递归）两个步骤。因为划分的结果决定递归的位置，所以Partition是整个算法的核心。快速排序最佳运行时间O(nlogn)，最坏运行时间O(n2)，随机化以后期望运行时间O(nlogn)。

首先来看一段升序快速排序算法的实现代码：

#include <iostream>

using namespace std;

void quickSort(int arr[], int first, int last);
void printArray(int arr[], const int& N);

void main()
{
    int test[] = { 1, 12, 5, 26, 7, 14, 3, 7, 2 };
    int N = sizeof(test)/sizeof(int);

    cout << "Size of test array :"  << N << endl;

    cout << "Before sorting : " << endl;
    printArray(test, N);

    quickSort(test, 0, N-1);

    cout << endl << endl << "After sorting : " << endl;
    printArray(test, N);
}

/**
 * Quicksort.
 * @param a - The array to be sorted.
 * @param first - The start of the sequence to be sorted.
 * @param last - The end of the sequence to be sorted.
*/
void quickSort(int arr[], int left, int right)
{
    int i = left, j = right;
    int tmp;
    int pivot = arr[(left + right) / 2];

    /* partition */
    while (i <= j)
    {
        while (arr[i] < pivot)
            i++;
        while (arr[j] > pivot)
            j--;
        if (i <= j)
        {
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    }

    /* recursion */
    if (left < j)
        quickSort(arr, left, j);
    if (i < right)
        quickSort(arr, i, right);
}

/**
 * Print an array.
 * @param a - The array.
 * @param N - The size of the array.
*/
void printArray(int arr[], const int& N)
{
    for(int i = 0 ; i < N ; i++)
        cout << "array[" << i << "] = " << arr[i] << endl;
} 

1 划分（Partition）

划分分为两个步骤：

• 选取枢纽元
• 根据枢纽元所在位置将数组分为左右两部分

1.1 选取枢纽元

所谓的枢纽元，也就是将数组分为两部分的参考元素，选取的方式并不唯一。对于完全随机的数据，枢纽元的选取不是很重要，往往可以直接选取数组的初始位置的元素作为枢纽元。但是实际中，数据往往是部分有序的，如果仍然使用数组两端的数据作为枢纽元，划分的效果往往不好，导致运行时间退化为O(n2)。因此，这里给出的代码就是选取数组中间位置元素：

int pivot = arr[(left + right) / 2];

也有三数取中的方法、随机选取法等。

1.2 根据枢纽元分为左右两部分

上文算法代码使用的是Hoara的双向扫描方法：

/* partition */
while (i <= j)
{
    while (arr[i] < pivot)
        i++;
    while (arr[j] > pivot)
        j--;
    if (i <= j)
    {
        tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
        i++;
        j--;
    }
}

除此以外还有单向扫描，双向扫描（区别于Hoara的方法）以及改进的双向扫描等。

1.3 关于双向扫描的思考

• 内层循环中的while循环条件是用<=/>=还是</>。
  • 一般的想法是用<=/>=，忽略与枢纽元相同的元素，这样可以减少不必要的交换，因为这些元素无论放在哪一边都是一样的。但是如果遇到所有元素都一样的情况，这种方法每次都会产生最坏的划分，也就是一边1个元素，令一边n−1个元素，使得时间复杂度变成O(n2)。而如果用严格</>，虽然两边指针每此只挪动1位，但是它们会在正中间相遇，产生一个最好的划分。
  • 也有人分析，认为内循环使用严格</>，可以减少内循环。
  • 因此，建议内循环使用</>。
• 小数组的特殊处理
  
  • 按照上面的方法，递归会持续到分区只有一个元素。而事实上，当分割到一定大小后，继续分割的效率比插入排序要差。由统计方法得到的数值是50左右，也有采用20的，这样quickSort函数就可以优化成：

void newQuickSort(int arr[], int left, int right, int thresh)
{
    if(right - left > thresh)
    {
        // quick sort for large array
        quickSort(arr, left, right);
    }
    else
    {
        // insertion sort for small array
        insertionSort(arr, left, right);
    }
}

2 递归（Recursive）

即重复上述的划分（Partition）操作，最底层的情形是数列的大小是0或者1。快速排序算法和大多数分治排序方法一样，都有两次递归调用，但是快速排序的递归在函数尾部，因此可以实施尾递归优化，从而缩减堆栈的深度，减少算法的时间复杂度。

最后，贴上前文代码运行的过程：

---

参考文献

• http://www.algolist.net/Algorithms/Sorting/Quicksort

• http://mathbits.com/MathBits/CompSci/Arrays/Quick.htm

• http://codereview.stackexchange.com/questions/77782/quick-sort-implementation

• https://gsamaras.wordpress.com/code/quicksort-c/

• http://blogread.cn/it/article/612?f=sa