前言
转自https://blog.csdn.net/qq_36528114/article/details/78667034并加以修改,红字是我修改的部分
正文
递归实现
void QuickSort(int* array,int left,int right)
{
assert(array);
if(left >= right)//表示已经完成一个组
return;
int index = PartSort(array,left,right);//枢轴的位置
QuickSort(array,left,index - 1);
QuickSort(array,index + 1,right);
}
PartSort()函数是进行一次快排的算法。
对于快速排序的一次排序，有很多种算法，我这里列举三种。
左右指针法
左右指针法可以说是这个这个问题延伸出来的,这个问题是:把比key小的数放左边,把key大的数放右边,则最后key的位置一定是最终整个数组排完序的位置;用左右指针可以解决这个问题,时间复杂度为O(n),n是数组长度,
- 选取一个关键字(key)作为枢轴，一般取整组记录的第一个数/最后一个，这里采用选取序列最后一个数为枢轴。
- 设置两个变量left = 0;right = N - 1;
- 从left一直向后走，直到找到一个大于key的值，right从后至前，直至找到一个小于key的值，然后交换这两个数。
- 重复第三步，一直往后找，直到left和right相遇，这时将key放置left的位置即可。
当left >= right时，一趟快速排序就完成了，这时将Key和array[left]的值进行一次交换。
一次快排的结果:4 1 3 0 2 5 9 8 6 7
基于这种思想，可以写出代码
int PartSort(int* array,int left,int right)
{
int& key = array[right];
while(left < right)
{
while(left < right && array[left] <= key)
++left;
while(left < right && array[right] >= key)
--right;
swap(array[left],array[right]);//这里不要用++和--,否则下面的swap会越界
}
swap(array[left],key);
return left;
}
问题：下面的代码为什么还要判断left < right？
while(left < right && array[left] <= key)
在cracking the interview code里面代码实现所选取的key,也就是所谓的哨兵pivot是数组中间位置,,所以它的代码也不需要判断left<right,因为它;且return前的最后一句swap,如果选取中间位置当哨兵,把这个值记下来,,也可以不要这句,书中代码如下
int partition(int[] arr, int left, int right) {
int pivot = arr[(left + right)/2]; //II Pick pivot point
while (left<= right) //这里可以改成<而不是=吧
{
while (arr[left]< pivot) left++;
while (arr[right] > pivot) right--;
if (left<= right) {
swap(arr, left, right);
left++;
right--;
}
}
return left;
}
key是整段序列最后一个，right是key前一个位置，如果array[right]这个位置的值和key相等，满足array[left] <= key，然后++left,这时候left会走到key的下标处。
挖坑法
- 选取一个关键字(key)作为枢轴，一般取整组记录的第一个数/最后一个，这里采用选取序列最后一个数为枢轴，也是初始的坑位。
- 设置两个变量left = 0;right = N - 1;
- 从left一直向后走，直到找到一个大于key的值，然后将该数放入坑中，坑位变成了array[left]。
- right一直向前走，直到找到一个小于key的值，然后将该数放入坑中，坑位变成了array[right]。
- 重复3和4的步骤，直到left和right相遇，然后将key放入最后一个坑位。
当left >= right时，将key放入最后一个坑，就完成了一次排序。
注意，left走的时候right是不动的，反之亦然。因为left先走，所有最后一个坑肯定在array[right]。
写出代码：
int PartSort(int* array,int left,int right)
{
int key = array[right];
while(left < right)
{
while(left < right && array[left] <= key)
{
++left;
}
array[right] = array[left];
while(left < right && array[right] >= key)
{
--right;
}
array[left] = array[right];
}
array[right] = key;
return right;
}
前后指针法
- 定义变量cur指向序列的开头，定义变量pre指向cur的前一个位置。
- 当array[cur] < key时，cur和pre同时往后走，如果array[cur]>key，cur往后走，pre留在大于key的数值前一个位置。
- 当array[cur]再次 < key时，交换array[cur]和array[pre]。
通俗一点就是，在没找到大于key值前，pre永远紧跟cur，遇到大的两者之间机会拉开差距，中间差的肯定是连续的大于key的值，当再次遇到小于key的值时，交换两个下标对应的值就好了。
带着这种思想，看着图示应该就能理解了
int PartSort(int* array,int left,int right)//这个代码写的太乱了
{
if(left < right){
int key = array[right];
int cur = left;
int pre = cur - 1;
while(cur < right)
{
while(array[cur] < key && ++pre != cur)//如果找到小于key的值，并且cur和pre之间有距离时则进行交换。注意两个条件的先后位置不能更换，可以参照评论中的解释
{
swap(array[cur],array[pre]);
}
++cur;
}
swap(array[++pre],array[right]);
return pre;
}
return -1;
}
因为左右指针法和挖坑法的右边指针都是从后往前的,而单向链表无法进行往前走的操作,所以这种适合链表的排序,力扣有一道题是要求链表的nlogn排序,则是这种前后指针的快速排序才能做到;
所以记住了，前后指针这个特点！
感觉这个写的不是很直观,下面自己写一个
void QuickSort(vector<int>& nums,int left,int right)
{
if(left>=right )return;
int key=nums[right];
int slow=left,fast=left;
while(fast<right)//当跳出循环的时候,正好fast=right
{
while(nums[slow]<=key && slow<fast)slow++;//这里slow不能超过fast,
if(slow==fast)fast++;//这一句是后面加上去的,加在前面和后面都不行
while(fast<right && nums[fast]>=key)fast++;
swap(nums[slow],nums[fast]);
//原本写的是while(nums[slow]条件){slow++; if(slow==fast) fast++}但是slow怕越界..改成上面这样了
}
swap(nums[slow],nums[right]);
helper(nums,left,slow-1);
helper(nums,slow+1,right);
}
快速排序的优化
首先快排的思想是找一个枢轴，然后以枢轴为中介线，一遍都小于它，另一边都大于它，然后对两段区间继续划分，那么枢轴的选取就很关键。
1、三数取中法
上面的代码思想都是直接拿序列的最后一个值作为枢轴，如果最后这个值刚好是整段序列最大或者最小的值，那么这次划分就是没意义的。
所以当序列是正序或者逆序时，每次选到的枢轴都是没有起到划分的作用。快排的效率会极速退化。
如果直接残暴的选择中间的来划分的话,中间的也可能是最大最小的,而如果利用概率学,取三个样本,选择中间的数,能降低最差情况的概率,所以可以每次在选枢轴时，在序列的第一，中间，最后三个值里面选一个中间值出来作为枢轴，保证每次划分接近均等。
2、直接插入
由于是递归程序，每一次递归都要开辟栈帧，当递归到序列里的值不是很多时，我们可以采用直接插入排序来完成，从而避免这些栈帧的消耗。这点比较新奇,STL的sort算法中也用到了这种思想,除了防止栈的消耗,当递归到一定深度数组变得更有序,快排变最差情况的概率也会提高,于是用插入排序,而插入排序是几种简单排序:冒泡,选择,插入里在这种情况下开销最小的一种
3. 荷兰旗问题优化,上面代码是都没涉及到荷兰旗问题优化吗,如果数组中有多个与哨兵相同的值,那一次partition就能把多个和哨兵相等的数归位,(优化前相当于一个partition只归位一个数),
这是左神基础课第一节的代码..r点一直指向最后,是不动的哨兵,这个是荷兰旗问题优化过的,不知道该划分为前后指针还是左右指针,三个指针,我感觉可以把它划分为第四种实现方法吧..
public static int[] partition(int[] arr, int l, int r) {
int less = l - 1;
int more = r;
while (l < more) {
if (arr[l] < arr[r]) {
swap(arr, ++less, l++);
} else if (arr[l] > arr[r]) {
swap(arr, --more, l);//重点!注意与more调换,此时当前指针l是不移动的
} else {
l++;
}
}
swap(arr, more, r);
return new int[] { less + 1, more };
}
上面几种问题的整个代码：
//三数取中
int GetMid(int* array,int left,int right)
{
assert(array);
int mid = left + ((right - left)>>1);
if(array[left] <= array[right])
{
if(array[mid] < array[left])
return left;
else if(array[mid] > array[right])
return right;
else
return mid;
}
else
{
if(array[mid] < array[right])
return right;
else if(array[mid] > array[left])
return left;
else
return mid;
}
}
//左右指针法
int PartSort1(int* array,int left,int right)
{
assert(array);
int mid = GetMid(array,left,right);
swap(array[mid],array[right]);
int& key = array[right];
while(left < right)
{
while(left < right && array[left] <= key)//因为有可能有相同的值，防止越界，所以加上left < right
++left;
while(left < right && array[right] >= key)
--right;
swap(array[left],array[right]);
}
swap(array[left],key);
return left;
}
//挖坑法
int PartSort2(int* array,int left,int right)
{
assert(array);
int mid = GetMid(array,left,right);
swap(array[mid],array[right]);
int key = array[right];
while(left < right)
{
while(left < right && array[left] <= key)
++left;
array[right] = array[left];
while(left < right && array[right] >= key)
--right;
array[left] = array[right];
}
array[right] = key;
return right;
}
//前后指针法
int PartSort3(int* array,int left,int right)
{
assert(array);
int mid = GetMid(array,left,right);
swap(array[mid],array[right]);
if(left < right){
int key = array[right];
int cur = left;
int pre = left - 1;
while(cur < right)
{
while(array[cur] < key && ++pre != cur)
{
swap(array[cur],array[pre]);
}
++cur;
}
swap(array[++pre],array[right]);
return pre;
}
return -1;
}
void QuickSort(int* array,int left,int right)
{
assert(array);
if(left >= right)
return;
//当序列较短时，采用直接插入
if((right - left) <= 5)
InsertSort(array,right-left+1);
int index = PartSort3(array,left,right);
QuickSort(array,left,index-1);
QuickSort(array,index+1,right);
}
int main()
{
int array[] = {4,1,7,6,9,2,8,0,3,5};
QuickSort(array,0,sizeof(array)/sizeof(array[0]) -1);//因为传的是区间，所以这里要 - 1；
}
非递归实现
递归的算法主要是在划分子区间，如果要非递归实现快排，只要使用一个栈来保存区间就可以了。
一般将递归程序改成非递归首先想到的就是使用栈，因为递归本身就是一个压栈的过程。
void QuickSortNotR(int* array,int left,int right)
{
assert(array);
stack<int> s;
s.push(left);
s.push(right);//后入的right，所以要先拿right
while(!s.empty)//栈不为空
{
int right = s.top();
s.pop();
int left = s.top();
s.pop();
int index = PartSort(array,left,right);
if((index - 1) > left)//左子序列
{
s.push(left);
s.push(index - 1);
}
if((index + 1) < right)//右子序列
{
s.push(index + 1);
s.push(right);
}
}
}
参考资料
TODO
- 这里的指针**用法https://www.jianshu.com/p/aa0ac621eac0
-
这个是生动讲快速排序的http://www.cnblogs.com/ahalei/p/3568434.html。，现在觉得讲的不好
-
这个是快速排序的三种实现：https://blog.csdn.net/qq_36528114/article/details/78667034
-
也是非递归的快速排序知乎 https://zhuanlan.zhihu.com/p/123416868
1952
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
