《算法导论》第7章 快速排序 (四种变形)

这一章的正文及思考题部分讲到了快速排序及其几种变形，包括：Hoare快排，
普通快排，随机快排，三数取中快排。

这些快排的区别主要是划分方法PARTITION算法的不同：如何选取主元，划分出的
两部分范围是什么。根据划分出的范围不同，各变形的QUICKSORT有微小的差别。

1. Hoare快排

Hoare划分是最初的版本，与《算法导论》中的划分版本相比，它选取第一个元素A[p]为主元。
划分后的两部分是：A[p..j]和A[j+1..r]，主元可能放入某一个之中。

int hoare_partition(int A[], int p, int r)
{
int x = A[p];
int i = p - 1;
int j = r + 1;

while (1) {

do j--;
while (A[j] > x);

do i++;
while (A[i] < x);

if (i < j)
swap(A, i, j);
else
return j;
}
}

void hoare_quick_sort(int A[], int p, int r)
{
if (p < r) {
int q = hoare_partition(A, p, r);
hoare_quick_sort(A, p, q);
hoare_quick_sort(A, q + 1, r);
}
}

2. 普通快排

选取最后一个元素A[r]为主元后，j 从头遍历到尾，i 是两范围的分隔。
划分结果为[p, q - 1]和[q + 1, r]。

int partition(int A[], int p, int r)
{
int x = A[r];
int i = p - 1;
int j;

for (j = p; j <= r - 1; j++) {
if (A[j] <= x) {
i++;
swap(A, i, j);
}
}

swap(A, i + 1, r);
return i + 1;
}

void quick_sort(int A[], int p, int r)
{
if (p < r) {
int q = partition(A, p, r);
quick_sort(A, p, q - 1);
quick_sort(A, q + 1, r);
}
}

3. 随机快排

通过头文件stdlib.h中的rand()方法生成[p, r]之间的随机数作为主元。
rand() % n 将生成 [0, n)之间的随机数。
为了重用partition方法，将选定的主元交换到位置 r。

int randomized_partition(int A[], int p, int r)
{
int i = p + rand() % (r - p + 1);
swap(A, i, r);
return partition(A, p, r);
}

void randomized_quick_sort(int A[], int p, int r)
{
if (p < r) {
int q = randomized_partition(A, p, r);
randomized_quick_sort(A, p, q - 1);
randomized_quick_sort(A, q + 1, r);
}
}

4. 三数取中快排

每次划分前，从当前子数组里随机取出三个数，取这三个数的中间数作为主元的索引。

int median_partition(int A[], int p, int r)
{
int range = r - p + 1;
int med1 = p + rand() % range;
int med2 = p + rand() % range;
int med3 = p + rand() % range;
int med  = (A[med1] < A[med2]) ?
(A[med2] < A[med3] ? med2 : (A[med1] < A[med3] ? med3 : med1)):
(A[med1] < A[med3] ? med1 : (A[med2] < A[med3] ? med2 : med3));

swap(A, med, r);
return partition(A, p, r);
}

void median_quick_sort(int A[], int p, int r)
{
if (p < r) {
int q = median_partition(A, p, r);
median_quick_sort(A, p, q - 1);
median_quick_sort(A, q + 1, p);
}
}

//测试方法

int main(void)
{
int A[SIZE] = { 2, 8, 7, 1, 3, 5, 6, 4 };
print(A, SIZE);

//hoare_quick_sort(A, 0, SIZE - 1);
//quick_sort(A, 0, SIZE - 1);
//randomized_quick_sort(A, 0, SIZE - 1);
median_quick_sort(A, 0, SIZE - 1);
print(A, SIZE);

return 1;
}