老老实实复习算法: 5 快速排序

#ifndef __sort_quick__hh
#define __sort_quick__hh
#include <stdlib.h>
/** 快速排序, 最差 O(n^2), 但统计上平均 O(nlgn), 而且常数因子很小
QUICK_SORT(A, p, r)
if p < r
q = PARTITION(A, p, r)
QUICK_SORT(A, p, q-1)
QUICK_SORT(A, q+1, r)

PARTITION(A, p, r)
x = A[r]        // 总使用最后一个元素作为比较值
i = p - 1
for j = p to r-1
if A[j] <= r
i++
exchange A[j], A[i]
exchange A[i+1], A[r]
return i+1                              // 分割位置

PARTITION_RANDOM(A, p, r)       // 一般情况下, 使用随机数版本能更好的平分
x = p + RANDOM(r-p)
exchange A[x], A[r]
return PARTITION(A, p, r)
*/
template<class T>
inline void __exchange(T &a, T &b)
{
T t = a;
a = b;
b = t;
}
template<class T>
inline size_t __partition(T *array, size_t header, size_t tail)
{
T x = array[tail-1];    // last elem
size_t i = header-1;
for (size_t j = header; j < tail-1; j++) {
if (array[j] <= x) {
i++;
__exchange<T>(array[j], array[i]);
}
}
__exchange<T>(array[i+1], array[tail-1]);
return i+1;
}
/** 实际中, 使用随机数版本, 效果优与每次使用最后一个的版本
*/
template<class T>
inline size_t __partition_random(T *array, size_t header, size_t tail)
{
size_t x = random() % (tail - header) + header;
__exchange(array[x], array[tail-1]);
return __partition(array, header, tail);
}
template<class T>
inline void __quick (T *array, size_t header, size_t tail)
{
if (header+1 < tail) {
#ifdef NOT_USING_RANDOM
size_t q = __partition<T>(array, header, tail);
#else
size_t q = __partition_random<T>(array, header, tail);
#endif // using random
__quick(array, header, q);
__quick(array, q+1, tail);
}
}
template<class T>
inline void algo_sort_quick (T *array, size_t start, size_t size)
{
__quick<T>(array, start, start+size);
}
#endif // quick.h