快速排序的优化方法

//分为{<v}部分和{>=v}部分
template<typename T>
int __partition(T arr[], int l, int r)
{
	//优化一：采用随机数，避免近乎有序的数组使得快排递归树平衡度过低而退化为O（n^2）
	swap(arr[l], arr[rand() % (r - l + 1) + l]);
	T v = arr[l];
	
	//arr[l+1...j] < v;arr[j+1...i] > v
	int j = l;
	for (int i = l + 1; i <= r; i++) {
		if (arr[i] < v) {
			swap(arr[j + 1], arr[i]);
			j++;
		}
	}
	swap(arr[l], arr[j]);
	return j;
}

//优化二，采用新的partition2
//两路排序，分为{<=v}部分和{>=v}部分
template<typename T>
int __partition2(T arr[], int l, int r)
{
	swap(arr[l], arr[rand() % (r - l + 1) + l]);
	T v = arr[l];
	//arr[l+1...i) <= v; arr(j...r] >= v
	//避免重复键值过多导致的递归树平衡度过低
	//将等于v的键值平均分配到左右端
	int i = l + 1, j = r;
	while (true) {
		while (i <= r && arr[i] < v) i++;
		while (j >= l+1 && arr[j] > v) j--;
		if (i > j)	break;
		swap(arr[i], arr[j]);
		i++;
		j--;
	}
	swap(arr[l], arr[j]);
	return j;
}

template<typename T>
void __quickSort(T arr[], int l, int r)
{
	//if (l >= r)
	//	return;
	if (r - l <= 15) {
		insertionSort(arr, l, r);
		return;
	}

	int p = __partition(arr, l, r);
	//int p = __partition2(arr, l, r);
	//int p = __partition3(arr, l, r);
	__quickSort(arr, l, p - 1);
	__quickSort(arr, p + 1, r);
}

//近乎有序的数据或过多的重复值会使得该排序退化为O(n^2)
template<typename T>
void quickSort(T arr[], int n)
{
	srand(time(NULL));
	__quickSort(arr, 0, n - 1);
}

//优化三，三路快排，将数组分为{<v},{==v},{>v}三部分
template <typename T>
void __quickSort3Ways(T arr[], int l, int r)
{
	if (r - l <= 15) {
		insertionSort(arr, l, r);
		return;
	}

	//partition
	swap(arr[l], arr[rand() % (r - l + 1) + l]);
	T v = arr[l];

	int lt = l;//arr[l+1...lt] < v
	int gt = r + 1;//arr[gt...r] > v
	int i = l + 1;//arr[lt+1...i) == v
	while (i < gt) {
		if (arr[i] < v) {
			swap(arr[i], arr[lt + 1]);
			lt++;
			i++;
		}
		else if (arr[i] > v) {
			swap(arr[i], arr[gt - 1]);
			gt--;
		}
		else {//arr[i] == v
			i++;
		}
	}
	swap(arr[l], arr[lt]);
	__quickSort3Ways(arr, l, lt-1);
	__quickSort3Ways(arr, gt, r);
}

参考自刘宇波老师排序算法源码