排序总结系列五：快速排序

1.快速排序的思想

经过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录比关键字大的，一部分记录比关键字小的，在可分别对这两部分记录继续进行排序，以达到整体有序的目的。

<pre name="code" class="cpp">void Qsort(int *ar, int left, int right);    //函数声明
int partition(int *arr, int left, int right);//函数声明
/
void quick_sort(int *arr, int len)            //排错
{
	assert(arr != NULL);
	Qsort(arr, 0, len - 1);
}
void Qsort(int *arr, int left, int right)      //左右来筛
{
	int mid = 0;
	if (left < right)
	{
		mid = partition(arr, left, right);//一次划分
		Qsort(arr, left,  mid - 1);
		Qsort(arr, mid + 1, right);
	}
}
int partition(int *arr, int left, int right)
{
	int key = arr[right];//注意和下面左筛右筛对应
	while (left < right)
	{
		while (left < right && arr[left] <= key)    //左筛
		{
			left++;
		}
		if (left < right) swap(arr, left, right);       //交换
		while (left < right && arr[right] >= key)//右筛
		{
			right--;
		}
		if (left < right) swap(arr, left, right);       //交换
	}
	return left;
}
///
void swap(int *arr, int left, int right)
{
	int tmp = arr[left];
	arr[left] = arr[right];
	arr[right] = tmp;
}

partition函数要做的事情，就是先选取其中的一个关键字，然后想办法将它放到一个位置，使得它左边的值都比它小，右边的值都比它大，我们称这样的关键字为枢纽。pivot

2.空间时间

时间: 最优情况O(nlogn) 最坏情况0(n^2)

空间： 最好情况O(log2n） 最坏情况O(n) 平均情况 空间O(logn);

稳定： 不稳定

3.快速排序的优化:

3.1优化选取枢轴： 随机取中法。

三数取中法。(取三个关键字先进行排序，将中间数作为枢轴，一般是取左端、右端和中间三个数。

int pivotkey;

int m=low + (high-low)/2;

if(ar[low] > ar[high)    swap(ar,low,high);

if(ar[m] > ar[high])     swap(ar,high,m);

if(ar[m] > ar[low])       swap(ar,m,low);

pivotkey = ar[low];

3.2优化不必要的交换

3.3优化小数组时的排序方案

3.4优化递归操作。

/

/**使用递归快速排序**/

template<typename Comparable>
void quicksort1(vector<Comparable> &vec, int low, int high)
{
	if (vec.empty() || low < 0) return;
	if (low < high)
	{
		int mid = partition(vec, low, high);
		quicksort1(vec, low, mid - 1);
		quicksort1(vec, mid + 1, high);
	}
}

/**使用栈的非递归快速排序**/

<pre name="code" class="cpp">/**使用栈的非递归快速排序**/
template<typename Comparable>
void quicksort2(vector<Comparable> &vec, int low, int high)
{
	stack<int> st;
	if (low < high)
	{
		int mid = partition(vec, low, high);
		if (low < mid-1)
		{
			st.push(low);
			st.push(mid-1);
		}
		if (mid+1 < high)
		{
			st.push(mid+1);
			st.push(high);
		}
		//其实就是用栈保存每一个待排序子串的首尾元素下标，下一次while
		//循环时取出这个范围，对这段子序列进行partition操作
		while (!st.empty())
		{
			int high = st.top(); //范围的右边
			st.pop();
			int low = st.top();  //范围的左边
			st.pop();
			mid = partition(vec, low, high);
			if (low < mid - 1)
			{
				st.push(low);
				st.push(mid-1);
			}
			if (mid + 1< high)
			{
				st.push(mid+1);
				st.push(low);
			}
		}
	}
}
//一次划分
template <typename Comparable>
int partition(vector<Comparable> &vec, int low, int high)
{
	Comparable pivot = vec[low];  //任选元素作为轴，这里选首元素
	while (low < high)
        {
		while (low < high && vec[high] >= pivot)  high--;
		if (low < high) vec[low] = vec[high];

		while (low < high && vec[low] <= pivot)   low++;
		if (low < high) vec[high] = vec[low];
		
	 }
	vec[low] = pivot;                    //此时low==high
	return low;
}

可以看到非递归的算法比递归实现还要慢。下面解释为什么会这样。

递归算法使用的栈由程序自动产生，栈中包含：函数调用时的参数和函数中的局部变量。如果局部变量很多或者函数内部又调用了其他函数，则栈会很大。每次递归调用都要操作很大的栈，效率自然会下降。

而对于非递归算法，每次循环使用自己预先创建的栈，因此不管程序复杂度如何，都不会影响程序效率。

但对于上面的快速排序，由于局部变量只有一个mid，栈很小，所以效率并不比非递归实现的低。

//

对长度为n 的线性表作快速排序,在最坏情况下,比较次数为n(n-1)/2.

快速排序的最坏情况就是数组有序，选的基数要和每一个数进行比较，(n-1)+(n-2)+...+1=n(n-1)/2次。