快速排序

快速排序是递归的思路谈起来是很简单的：

（1）当待排元素S个数为1的时候，什么也不做。

（2）在待排元素S中取一个元素作为枢纽pivot。

（3）将待排元素分成三份：小于pivot的元素S1、pivot它自己、大于pivot的元素S2。

（4）对小于pivot的元素S1进行快速排序，对大于pivot的元素S2进行快速排序。

但是，具体实现这个思路的时候，是比较复杂的。

对于（2），我们取枢纽元的时候，决定了S1和S2的个数。我们希望S1和S2各占S的一半左右，如此的话，元素可以被细分logN次，每次两份，就是2*logN，对每一份的比较是线性的，为N，快速排序的时间复杂度为O(NlogN)。

但是如果每次S1和S2极度不平衡，例如S2大大超过S1，考虑最坏的情况，S1每次0个，其余都在S2中，则元素要被分N-1次，每次的比较也是线性的，为N，则快速排序的时间复杂度为O(N^2)。

所以枢纽的选择很重要，最糟糕的选法是把第一个元素当成枢纽，在待排元素基本有序的情况下，快速排序的时间复杂度是二次的。最安全的选法是随机选择元素当枢纽。另外有一种流行的并且安全的方法是Median-of-Three Partitioning，其实就是选择第一个，中间一个和最后一个元素，然后把这三个位置根据大小进行排序，并把最小值放在最左边，最大值放在最右边，中间的值放在中间，作为枢纽。之后，我们把枢纽与当前待排序集合的倒数第二个位置（或者最后）交换，那么枢纽右边的值自然是大于枢纽的，不用考虑。方便我们将来的分割。

对于（3），当我们分割元素的时候，要考虑当元素等于枢纽的值的情况。考虑当待排数组的元素的值完全相同，如果我们将枢纽视单独视为划分到S1或S2，那么同样会造成O(N^2)的时间复杂度。所以我们在分割的时候，i和j遇到等于枢纽的情况也要停下。

另外，当我们使用Median-of-THree分割法的时候，遇到少于三个元素的，我们将它丢到插入排序去处理。如此避免我们在快排的实现中考虑额外的特殊情况。这个做法依据这样一个工程实践：

对于很小的数组（N<=20），快速排序不如插入排序好。对于小的数组，我们不递归使用快速排序，而以插入排序这样对小数组有序的排序算法来取代。使用这种策略，针对自始至终使用快速排序的情况，可以节省大约15%的运行时间。

实现的代码如下：

#include <cstdio>
#include <cstdlib>

#define MINLENGTH 10

typedef int Item;
// inline使Swap内联展开。提高程序效率。 
void inline
Swap(Item* a, Item* b)
{
    if (a != b) {
        *a ^= *b;
        *b ^= *a;
        *a ^= *b;
    }
}    
// 在arr中取左中右三个位置，比较。pivot取中间值，将pivot放在right-1的位置上。
// left的位置小于pivot，right的位置大于pivot。 
Item
Median3(Item arr[], int left, int right)
{
    int center = (left + right) / 2;
    
    if (arr[left] > arr[center]) {
        Swap(&arr[left], &arr[center]);
    }
    if (arr[left] > arr[right]) {
        Swap(&arr[left], &arr[right]);
    }
    if (arr[center] > arr[right]) {
        Swap(&arr[center], &arr[right]);
    }
    
    Swap(&arr[center], &arr[right-1]);
    return arr[right-1];
}

void
InsertSort(int arr[], int len)
{
    for (int i = 1; i < len; i++) {
        int tmp = arr[i];
        int j;
        for (j = i; j >= 1 && arr[j-1] > tmp; j--) {
            arr[j] = arr[j-1];
        }
        arr[j] = tmp;
    }
}
// 这里选用i，j遇到等于pivot的情况下停止（因为如果不停止，那会达到O(N^2)。）
// 另外，程序考虑待排数字不少于3个的情况。少于3个的话，需要考虑额外的特殊情况。 
void 
QSort(Item arr[], int left, int right) 
{
    if (right - left >= MINLENGTH) {
        int pivot = Median3(arr, left, right);
        int i = left;
        int j = right - 1;
        for ( ; ; ) {
            while (arr[++i] < pivot) {}
            while (arr[--j] > pivot) {}
            if (i < j) {
                Swap(&arr[i], &arr[j]);
            } else {
                break;
            }
        }
        Swap(&arr[i], &arr[right-1]); // 将pivot放在i的位置上。 
        QSort(arr, left, i - 1);
        QSort(arr, i + 1, right);
    } 
    else {
        InsertSort(arr + left, right - left + 1);
    }
}

void
QuickSort(Item arr[], int len)
{
    QSort(arr, 0, len-1);
}

int 
main(int argc, char** argv)
{
    //Item arr[6] = {17, 11, 2, 23, 5, 7};
    Item arr[100000] = {0};
    
    for (int i = 0; i < 100000; i++) {
        arr[i] = 100000/(i+1);
    }
/*
    for (int i = 0; i < 10000; i++) {
        printf("%d\t", arr[i]);
    }
    printf("\n");
    */
    QuickSort(arr, 100000);
    //InsertSort(arr, 10000);
    
    for (int i = 0; i < 100000; i++) {
        if (arr[i] == 0)
        printf("%d\t", arr[i]);
    }
    printf("\n");
    
    system("pause");
    
    return 0;
}