常用排序之快速排序法

       通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

算法描述

    1、设置两个变量i、j，排序开始的时候：i = 0，j = N-1；

    2、以第一个数组元素作为关键数据，赋值给key，即key = A[0]；

    3、从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]  和A[i]互换；

    4、从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和  A[j]互换；

    5、重复第3、4步，直到i = j； 

      3、4步中，没找到符合条件的值，即3中A[j]不小于key,4中  A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条  件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-  完成的时候，此时令循环结束。

示例

6    2    7    3    8    9

      创建变量i=0(指向第一个数据)，j=5(指向最后一个数据)，k=a[i](赋值为第一个数据的值)

       我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较：

---------------------------------

3    2    7    6    8    9

i=0,j=3,k=6

---------------------------------

       接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换:

---------------------------------

3    2    6    7    8    9

i=2,j=3,k=6

---------------------------------

称上面两次比较为一个循环。

接着，再递减变量j，不断重复进行上面的循环比较。

      在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大：

----------------------------------

3    2    6    7    8    9

----------------------------------

      如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。

      然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。

      注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。

示例程序：

#include<iostream>  
#include<new>  
#include<string>  
using namespace std;

void InsertionSort(int v[], int n)
{
	int j, temp, p;
	for (p = 1; p < n; p++)
	{
		temp = v[p];
		for (j = p; j > 0 && v[j - 1] > temp; j--)
			v[j] = v[j - 1];
		v[j] = temp;
	}
}
void swap(int *x, int *y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}
int median3(int a[], int left, int right)
{
	int center = (left + right) / 2;

	if (a[left] > a[center])
		swap(&a[left], &a[center]);
	if (a[left] > a[right])
		swap(&a[left], &a[right]);
	if (a[center] > a[right])
		swap(&a[center], &a[right]);

	swap(&a[center], &a[right - 1]);
	return a[right - 1];
}

void Qsort(int a[], int left, int right)
{
	int i, j;
	int pivot;
	if (left + 3 <= right)
	{
		pivot = median3(a, left, right);
		i = left, j = right - 1;
		for (;;)
		{
			while (a[++i] < pivot) {}
			while (a[--j] > pivot) {}
			if (i < j)
				swap(&a[i], &a[j]);
			else
				break;
		}
		swap(&a[i], &a[right - 1]);
		Qsort(a, left, i - 1);
		Qsort(a, i + 1, right);
	}
	else
		InsertionSort(a + left, right - left + 1);
}
int main()
{
	int b[] = { 14,54,12,65,45,87,57,43,11,24,81,10 };
	Qsort(b, 0, 11);
	for (auto c : b)
		cout << c << " ";
	system("pause");
	return 0;
}

快速排序的非递归实现：

int patition(int *a, int start, int end)
{
	int index = start;
	swap(a[index],a[end]);
	int small = start - 1;
	for (index = start; index < end; index++) {
		if (a[index] < a[end]) {
			++small;
			if (small != index) 
				swap(a[index],a[small]);
		}
	}
	++small;
	swap(a[small],a[end]);
	return small;
}

void quickSort2(int* root, int low, int high)
{
	stack<int> st;
	int index;
	if (low<high)
	{
		st.push(low);
		st.push(high);
		while (!st.empty())
		{
			int j = st.top(); st.pop();
			int i = st.top(); st.pop();

			index = patition(root, i, j);

			if (i<index - 1){
				st.push(i);
				st.push(index - 1);
			}
			if (j>index + 1){
				st.push(index + 1);
				st.push(j);
			}
		}
	}
}