快速排序

基本思想

快速排序基于分治策略，时间复杂度最好O(nlogn)，最差O(n^2)，平均O(nlogn)，为不稳定排序。
算法思想：选取一个数作为轴点，然后把小于轴点的元素移到左边，大于轴点的移到右边，接着递归处理左右两部分，最终处理完毕的数组即为排序后的数组。

那么如何构造出上图这种情况呢，首先需要任取某一元素作为轴点，这里我们取首元素m作为轴点，那么构造策略如下：首先右指针左移找到第一个小于m的元素，把这个元素填充在左指针位置；接着左指针右移找到第一个大于m的元素，并填充在右指针位置；如此循环反复，直到左右指针相遇，把轴点的值m填充在相遇的这个位置即可。

版本一：

void QuickSort(vector<int>& a, int low, int high)
{
	// 单元素自然有序
	if (low >= high)
		return;
	int mid = Partition(a, low, high);
	QuickSort(a, low, mid - 1);
	QuickSort(a, mid + 1, high);
}

int Partition(vector<int>& a, int low, int high)
{
	// 任选一元素与首元素交换，等效于随机选取轴点
	swap(a[low], a[low + rand() % (high - low + 1)]);
	int pivot = a[low];
	while (low < high)
	{
		while (low < high && a[high] >= pivot)
			--high;
		a[low] = a[high];
		while (low < high && a[low] <= pivot)
			++low;
		a[high] = a[low];
	}
	a[low] = pivot;
	return low;
}

复杂度分析

快速排序依赖于分治策略，也就是说复杂度依赖于所划分的子任务规模相近。
最好的情况为所选取的轴点恰为中位数，那么划分出来的左右两个数组规模相近，递归下去，复杂度为O(nlogn)。

最差的情况为，当输入的数组已经有序的数组，而每次都是简单地选取最左端元素为轴点，那么划分出来的两个数组就一个为空，一个为满。每次划分都要进行n次比较,最终时间复杂度升高到跟冒泡排序一样的O(n^2)。

降低最差情况概率

显然，该算法的好坏严重依赖于轴点的选取，在我们上面的代码中使用了swap()在区间内任选一元素与首元素交换，等同与随机选取了一个轴点，从而一定程度减少了最坏情况出现的概率。

类似地，可采用所谓三者取中法，即任取三个数，将数值居中者作为轴点，这样可进一步降低最坏情况出现的概率。

应对退化情况

当输入的数据中有大量重复数值时，该算法又会退化到O(n^2)。考虑一种情况，即所有的元素均重复，那么由版本一的代码划分出来的数组又是一个为空，一个为满，退化成了最差情况。

为了使划分出来的子数组规模相近，调整一下交换的条件，右边的数只有小于或等于轴点就可以移到左边，左边同理。这样对于所有数值均相同的数据，就变成了最好情况了。当然这也是有代价的，每次划分都要做更多的交换操作，以及会增加次序的不稳定。

版本二：

void QuickSort(vector<int>& a, int low, int high)
{
	// 单元素自然有序
	if (low >= high)
		return;
	int mid = Partition(a, low, high);
	QuickSort(a, low, mid - 1);
	QuickSort(a, mid + 1, high);
}

int Partition(vector<int>& a, int low, int high)
{
	// 任选一元素与首元素交换，等效于随机选取轴点
	swap(a[low], a[low + rand() % (high - low + 1)]);
	int pivot = a[low];
	while (low < high)
	{
		while (low < high && a[high] > pivot)
			--high;
		a[low++] = a[high];
		while (low < high && a[low] < pivot)
			++low;
		a[high--] = a[low];
	}
	a[low] = pivot;
	return low;
}

但是上面这种方法有局限，无法转换为对链表进行排序，于是将左右指针转换为快慢指针。维护两个指针pre、cur，两个指针从首元素出发，当遇到大于轴点的元素，pre不动，cur前进；遇到小于轴点的元素，pre跟cur交换元素后均前进一步。

版本三（快慢指针法）：

void QuickSort(vector<int>& a, int low, int high)
{
	// 单元素自然有序
	if (low >= high)
		return;
	int mid = Partition(a, low, high);
	QuickSort(a, low, mid - 1);
	QuickSort(a, mid + 1, high);
}

int Partition(vector<int>& a, int low, int high)
{
	if (low < high)
	{
		// 简单选取尾元素作为轴点
		int pivot = a[high];
		int cur = low;
		int pre = cur - 1;
		while (cur < high)
		{
			// pre和cur之间有距离时才交换
			while (a[cur] < pivot && ++pre != cur)
			{
				swap(a[cur], a[pre]);
			}
			++cur;
		}
		swap(a[++pre], a[high]);
		return pre;
	}
	return -1;
}

前面的程序递归主要是利用函数栈保存了low、high两个参数，我们可以自己维护一个栈来保存形成非递归方法。

非递归版本：

void QuickSort(vector<int>& a, int low, int high)
{
	stack<int> s;
	s.push(low);
	s.push(high);
	while (!s.empty())
	{
		int high = s.top(); s.pop();
		int low = s.top(); s.pop();

		int pivot = Partition(a, low, high);
		// 终止条件
		if ((pivot - 1) > low)
		{
			s.push(low);
			s.push(pivot - 1);
		}
		if ((pivot + 1) < high)
		{
			s.push(pivot + 1);
			s.push(high);
		}
	}
}

int Partition(vector<int>& a, int low, int high)
{
	// ...
}

注：以上代码未经测试，只作记录用