排序算法之快速排序

  快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

一、挖坑填数法

1、算法描述

  快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

1. i =L; j = R; 将基准数挖出形成第一个坑a[i]；

2. j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中；

3. i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中；

4. 再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

2、算法图解

3、算法demo

#include <bits/stdc++.h>
using namespace std;

//挖坑填数法
void quick_sort(vector<int> &s, int l, int r)
{
    if (l < r)
    {
        int i = l, j = r, x = s[i];//选取基数
        while (i < j)//只要左边游标和游标不重叠的话那么就继续遍历
        {
            while (i < j && s[j] > x)//j--由后向前找比它小的数，找到后挖出此数填前一个坑s[i]中。
                j--;
            if (i < j)
                s[i++] = s[j];
            while (i < j && s[i] < x)//i++由前向后找比它大的数，找到后也挖出此数填到前一个坑s[j]中。
                i++;
            if (i < j)
                s[j--] = s[i];
        }
        //如果i==j，将基准数填入s[i]中。
        s[i] = x;
        quick_sort(s, l, i-1);//对基数的左半部分进行快速排序
        quick_sort(s, i+1, r);//对基数的右半部分进行快速排序
    }
}

int main(int argc, char const *argv[])
{
	vector<int> vec1 = {7, 8, 9, 5, 3, 6, 1};
    quick_sort(vec1, 0, vec1.size()-1);
	for (const auto v : vec1)
		cout << v << " ";
	system("pause");
}

二、partition函数划分

1、递归方法

1. 选取主元（首元素，尾元素或一个随机元素）；

2. 以选取的主元为分界点，把小于主元的放在左边，大于主元的放在右边；

3. 分别对左边和右边进行递归，重复上述过程。

2、非递归方法

1. 选取主元（首元素，尾元素或一个随机元素）；

2. 以选取的主元为分界点，把小于主元的放在左边，大于主元的放在右边；

3. 用栈保存下次需要排序的子数组的开始位置和结束位置，重复上述过程。

3、算法demo

#include <iostream>
#include <stack>
#include <vector>
using namespace std;

int partition(vector<int>&arr, int low, int high)
{
	int pivot = arr[high]; // 选最后一个元素作为枢纽元
	int location = low; // location放置的是最新的比枢纽元小的元素
	for (int i = low; i < high; i++) // 比枢纽元小的元素依次放在前半部分
		if (arr[i] < pivot)
			swap(arr[i], arr[location++]); // 移动location
	swap(arr[high], arr[location]); // 最后交换的是arr[high]，不是pivot
	return location;
}

void quick_sort(vector<int>&arr, int low, int high)
{
	if (low < high)
	{
		// 返回分界点
		int middle = partition(arr, low, high);
		// 根据分界点对左边和右边重复快排过程
		quick_sort(arr, low, middle - 1);
		quick_sort(arr, middle + 1, high);
	}
}

void quick_sort_unrecursion(vector<int>& arr)
{
	// 栈中保存下次需要排序的子数组的开始位置和结束位置
	stack<int> st;
	st.push(0);
	st.push(arr.size() - 1);
	while (!st.empty()) // 栈非空
	{
		int high = st.top();
		st.pop();
		int low = st.top();
		st.pop();
		int middle = partition(arr, low, high);
		if (middle + 1 < high) // 右边子数组的上下界入栈
		{
			st.push(middle + 1);
			st.push(high);
		}
		if (low < middle - 1) // 左边子数组的上下界入栈
		{
			st.push(low);
			st.push(middle - 1);
		}
	}
}

int main()
{
	vector<int> arr{ 8,5,1,6,2,7,3,4 };
	quick_sort(arr, 0, arr.size()-1);
	quick_sort_unrecursion(arr);
	for (auto v : arr)
		cout << v << endl;
	system("pause");
	return 0;
}

三、算法总结

  快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，但不是稳定排序方法。最好情况下的时间复杂度为O（nlogn），最坏情况下的时间复杂度为O（n^2）【当待排序的序列为正序或逆序排列时，最坏情况的快速排序退化为冒泡排序】。

  快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。

四、算法优化

  快排是一种基于分治的算法，对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。

  我们已经知道，若输入本身已被排序，那么对于快排来说就糟了。那么如何避免这样的情况？

  两种解决方案：
（1）随机排列序列中的元素；
（2）随机地选择基准元素（pivot）；

  这便是随机化快速排序的思想，这种快排的好处是：其运行时间不依赖于输入序列的顺序。

参考：https://blog.csdn.net/MoreWindows/article/details/6684558
https://blog.csdn.net/N_sev7/article/details/78057111
https://blog.csdn.net/qing0706/article/details/50084611