快速排序和其随机化版本

快速排序使用了分治的思想，主要方法分为三步：

分解：数组A[p..r]被划分为两个（可能为空）子数组A[p..q-1]和A[q+1..r]，使得A[p..q-1]中的每一个元素都小于等于A[q]，而A[q]也小于等于A[q+1..r]中的每个元素。其中小标q也是划分过程的一部分。

解决：通过递归调用快速排序，对子数组A[p..q-1]和A[q+1..r]进行排序。

合并：因为子数组都是原地址排序的，所以不需要合并操作：数组A[p..r]已经有序。

下面是实现快速排序的程序，每次划分以数组的最后一位为主元

#include "pch.h"
#include <iostream>
using namespace std;
int Partition(int A[], int p, int r)
{
    int x = A[r], i = p - 1;
    for (int j = p;j < r;j++)
    {
        if (A[j] <= x)
        {
            i++;
            swap(A[i], A[j]);
        }
    }
    swap(A[i + 1], A[r]);
    return i + 1;
}

void QuickSort(int A[], int p, int r)
{
    if (p < r)
    {
        int q = Partition(A, p, r);
        QuickSort(A, p, q - 1);
        QuickSort(A, q+1, r);
    }
}
int main()
{
    int A[10] = { 2,1,7,8,3,5,6,4,0,9};
    QuickSort(A, 0, 9);
    for (int i = 0;i < 10;i++)
        cout << A[i] << " ";
}

快速排序的性能：其运行时间依赖于是否平衡，和平衡又依赖于用于划分的元素。如果划分是平衡的，那么其性能与归并排序一样。如果划分是不平衡的，其性能就接近于插入排序了。

快速排序最好的情况是O(nlogn)，最坏的情况是O(n^2)。

在讨论平均情况性能的时候，输入数据的所有排列都是等概率的。

下面采用的是随机抽样从子数组A[p..r]中随机选择一个元素作为主元：

#include "pch.h"
#include <iostream>
#include <stdlib.h>
using namespace std;
int Partition(int A[], int p, int r)
{
    int x = A[r], i = p - 1;
    for (int j = p;j < r;j++)
    {
        if (A[j] <= x)
        {
            i++;
            swap(A[i], A[j]);
        }
    }
    swap(A[i + 1], A[r]);
    return i + 1;
}
int RandomPartition(int A[], int p, int r)
{
    int i = (rand() % (r - p)) + p;
    swap(A[r], A[i]);
    return Partition(A, p, r);
}
void QuickSort(int A[], int p, int r)
{
    if (p < r)
    {
        int q = RandomPartition(A, p, r);
        QuickSort(A, p, q - 1);
        QuickSort(A, q+1, r);
    }
}
int main()
{
    int A[10] = { 2,1,7,8,3,5,6,4,0,9};
    QuickSort(A, 0, 9);
    for (int i = 0;i < 10;i++)
        cout << A[i] << " ";
}