快速排序（递归和非递归）

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

快速排序适用于大量数据进行排序。

（1）如果每次将数组一分为二，此时排序就是最优：

最优情况下时间复杂度为：O（nlogn）

最优情况下空间复杂度为：O（logn）

（2）如果每次选取的基准是数组中最大值或最小值，此时，退化为冒泡排序，为最差情况：

最坏情况下时间复杂度为：O（n^2 ）

最坏情况下时间复杂度为：O（n）

（3）/*递归实现*/

#include<iostream>
#include<Cassert>
using namespace std;

int Partion(int *array, int low, int high)//用来每一次的调整，对基准两边的数进行调整
{
	/*选取第一个数为基准，你也可以对其进行优化，选取其他基准*/
	int tmp = array[low];
	
	while (low <= high)
	{
		while (low<high&&array[high]>tmp)
		{
			high--;
		}
		if (array[high] < tmp)
		{
			array[low] = array[high];
		}
		else
		{
			break;
		}
		while (low < high&&array[low] <= tmp)
		{
			low++;
		}
		if (array[low]>tmp)
		{
			array[high] = array[low];
		}
		else
		{
			break;
		}
	}
	array[low] = tmp;
	return low;//将low返回，作为下一次的基准
}

void  quickSort(int *array, int start, int end)
{
	assert(array != NULL);
	int tmp = Partion(array,  start, end);

	if (tmp >start + 1)
	{
		quickSort(array, 0, tmp - 1);
	}
	if (tmp < end - 1)
	{
		quickSort(array, tmp + 1, end);
	}

}

void show(int *array,int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << array[i] << " ";
	}
	cout << endl;
}
int main()
{
	int array[] = { 50, 50,0,96,96,2, 12, 0, 96, 54, 3, 8, 3, 4 };
	int len = sizeof(array) / sizeof(array[0]);
	quickSort(array,0,len-1);
	show(array,len);
	return 0;
}

（4）非递归实现

#include<iostream>
#include<Cassert>
#include<stack>
using namespace std;
int Partion(int *array, int low, int high)
{
	int tmp = array[low];
	while (low <= high)
	{
		while (low<high&&array[high]>=tmp)
		{
			high--;
		}
		if (array[high] < tmp)
		{
			array[low] = array[high];
		}
		else
		{
			break;
		}
		while (low < high&&array[low] <= tmp)
		{
			low++;
		}
		if (array[low]>tmp)
		{
			array[high] = array[low];
		}
		else
		{
			break;
		}
	}
	array[low] = tmp;
	return low;
}

template<typename T>
void quickSort(T*array, int start, int end)
{
	stack<T> stk;
	int tmp = Partion(array, start, end);

	if (tmp > start + 1)//将基准左边入栈
	{
		stk.push(0);
		stk.push(tmp - 1);
	}
	if (tmp < end - 1)//基准右边入栈
	{
		stk.push(tmp + 1);
		stk.push(end);
	}
	/*其实就是用栈保存每一个待排序子串的首尾元素下标，
	下一次while循环时取出这个范围，对这段子序列进行partion操作*/
	while (!stk.empty())
	{
		int end = stk.top();
		stk.pop();
		int start = stk.top();
		stk.pop();
		int tmp = Partion(array, start, end);
		if (tmp > start + 1)
		{
			stk.push(0);
			stk.push(tmp - 1);
		}
		if (tmp < end - 1)
		{
			stk.push(tmp + 1);
			stk.push(end);
		}
	}
 }
void show(int *array, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << array[i] << " ";
	}
	cout << endl;
}
int main()
{
	int array[] = { 50, 50, 0, 96, 96, 100,-5, 54, 3, 8, 3, 4 };
	int len = sizeof(array) / sizeof(array[0]);
	quickSort(array, 0, len - 1);
	show(array, len);
	return 0;
}

（5）其实快排有很多种优化方法，都可以使程序效率大大提高，大家可以去试着写一下。

1.三数取中法；

2.随机数法；

3.相同数聚集法；