排序算法——快速排序

快速排序算法就是不断的取基准值，然后根据基准值将序列分成大于基准值的和小于基准值的两部分。
空间复杂度：最优时是O(1),就是类似于冒泡排序两两交换，最坏时是O(n),递归到最深层。
快速排序的平均时间复杂度和最坏时间复杂度分别是O(nlgn)、O(n^2)，
快速排序算法的平均时间复杂度为 O(nlgn)。
算法稳定性：不稳定。
划分的方法有两种：
第一种是双向划分，从两端向中间合拢

具体代码：

int Partition(vector<int>& arr, int low, int high)
{
	int tmp = arr[low];
	while (low < high)
	{
		while (low < high&&tmp<=arr[high])
		{
			high--;
		}
		if (low < high)
		{
			arr[low] = arr[high];
		}
		while (low<high && tmp>arr[low])
		{
			low++;
		}
		if (low < high)
		{
			arr[high] = arr[low];
		}
	}
	arr[low] = tmp;
	return low;
}

第二种划分方式是从一端开始，这种方式也适用于单链表。

代码实现：

int Partition(vector<int> &arr, int low, int high)
{
	int i = low;
	int j = low + 1;
	while (j <= high)
	{
		if (arr[j] <= arr[low])
		{
			++i;
			std::swap(arr[i], arr[j]);
		}
		j++;
	}
	std::swap(arr[i], arr[low]);
	return i;
}

排序方法也分了递归和非递归，这两个也比较好理解
递归实现：

void QuickSort(vector<int> &arr, int low, int high)
{
	if (low < high)
	{
		//随机划法
		// srand(time(nullptr));
		//int index = rand%(right-left+1)+left;
		//std::swap(arr[left],arr[index]);
		int par = Partition(arr, low, high);
		QuickSort(arr, low, par - 1);
		QuickSort(arr, par + 1, high);
	}
}

非递归实现，可以使用栈或者队列

void QuickSort(vector<int>& arr, int low, int high)
{
	stack<int> st;
	if(low < high)
	{
		st.push(low);
		st.push(high);
		while (!st.empty())
		{
			int max = st.top();
			st.pop();
			int min = st.top();
			st.pop();
			int mid = Partition(arr, min, max);
			if (min < mid - 1)
			{
				st.push(min);
				st.push(mid - 1);
			}
			if (max > mid + 1)
			{
				st.push(mid + 1);
				st.push(max);
			}
		}
	}
}