快速排序详解+各种实现方式

快速排序的思想大体来说比较简单，就是从数组中挑选一个数字当做枢纽，然后将比枢纽大的和比枢纽小的分别放在枢纽的两边，再递归地对两边进行操作，从而进行分治解决问题。平均情况下快速排序是复杂度为O(nlogn)O(nlogn)O(nlogn)，可是有时候复杂度会退化为O(n2)O(n^2)O(n2)，这与我们如何选择枢纽以及如何将数组进行划分有关。

总共有两种情况下复杂度会退化：

数组大体有序：这个时候如果我们枢纽选择的不够好，那么数组的一边将会比较大，一边将会比较小，最严重的时候每次只能将规模减一，则复杂度将会变成T(n)=T(n−1)+nT(n)=T(n-1)+nT(n)=T(n−1)+n，即T(n)=n2T(n)=n^2T(n)=n2。解决这个问题的方法就是合理的选择枢纽，例如选择数组头部、尾部、中间三个数字的平均值，这种方法就能有有效解决这个问题。我们一般将枢纽放在数组的头部（只需要交换选择的枢纽和原本位于枢纽头部的元素即可），这样做可以方便我们进行划分。
数组中有很多一模一样的数字：这样同样会产生每次只能将规模减小很少的情况，最坏的时候复杂度也将退化为O(n2)O(n^2)O(n2)。这种问题的产生我们无法通过有效的选择枢纽解决，只能够通过划分的时候使得即使数组中的元素都等于枢纽我们仍旧能够将数组大概分成相等的两部分。

常见的有以下划分方法：

从一边进行划分

大概的思想就是把第一个元素当做枢纽，然后使用一个指针保存分界点，指针的左边是小于枢纽的元素，指针的右边是大于等于枢纽的元素（必须有一边支持等于，否则划分将会卡住）。

将指针初始化在数组头部，遍历后面的元素，如果比枢纽小就将指针向后移动一位，然后将该位置的元素和遍历到的元素交换。否则就继续向后遍历。这样做可以成功的原因是任何时刻指针后面的元素都是大于等于枢纽的元素，通过交换就将小于枢纽的元素放在了指针之前，从而完成划分。

实现代码
```
void QuickSort(T* a,int l,int r)
{if(r-l<2) return;//从一边划分int index=l;T x=a[l];for(int i=l+1;i<r;++i){if(a[i]<x)swap(a[++index],a[i]);}swap(a[index],a[l]);QuickSort(a,l,index); QuickSort(a,index+1,r);
｝
```

虽然这种方法实现起来比较简单，但是他不能够解决出现大量重复元素复杂度提升的问题。

从两边进行划分

空穴法

我们先将枢纽元素取出数组，然后用两个指针分别指向数组头部和数组尾部，先从尾部找比枢纽元素小的元素，找到以后放在数组头部因为将枢纽元素取出形成的空穴中，此时指向数组尾部的指针所指向的元素被取走形成空穴，再从头部找比枢纽大的元素，找到以后再放在尾部形成的空穴中。如此反复，直到两个指针相遇，然后再将枢纽放在最后的这个空穴中，完成划分。

实现代码
```
void QuickSort(T* a,int l,int r){if(r-l<2) return;//空穴法int i=l,j=r-1;T x=a[l];while(i<j){while(i<j && a[j]>x) --j; a[i]=a[j];while(i<j && a[i]<=x) ++i;a[j]=a[i];}a[i]=x;QuickSort(a,l,i); QuickSort(a,i+1,r);}
```
这中方法我们同样必须在一边允许等号，因此也可能出现复杂度退化的问题

直接交换

当然我们也可以直接进行交换而不使用空穴，一种简单的实现方法

void QuickSort(T* a,int l,int r)
{if(r-l<2) return;int i=l+1,j=r-1;T x=a[l];while(i<=j){while(i<r && a[i]<=x) ++i;while(j>l && a[j]>x) --j;if(i<j) swap(a[i],a[j]);}swap(a[l],a[j]);QuickSort(a,l,j);QuickSort(a,i,r);
｝

然而这种方法依旧不能够解决问题（不会采用），因此我们需要进行一些变形

实现代码

void QuickSort(T* a,int l,int r)
{if(r-l<2) return;int i=l-1,j=r;T pivot = a[l];while(i<j){do ++i; while(a[i] < pivot);do --j; while(a[j] > pivot);if(i < j) swap(a[i],a[j]);}QuickSort(a,l,j+1); QuickSort(a,j+1,r);
｝

为什么这样做就可以解决重复元素的问题呢？这里和上面方法最大的不同就在于我们在划分的时候没有使用等号。这样的话如果遇到和枢纽相等的元素的时候我们就移动然后越过这个位置。使用dododo while;while;while;结构就是为了能够跨越和枢纽相等的元素。如果整个数组都是相等的话虽然我们多进行一些交换，但是有效地将数组划分成了差不多相等的两部分。
对于代码的理解，很重要的一点就是将i=l−1i=l-1i=l−1。刚开始我觉得这一点没有很重要所以自己将其改为了i=li=li=l，然后最后将枢纽元素放在中间。但是在测试的时候我发现对于有些数据会出错。仔细推敲数据以后发现，i=l−1i=l-1i=l−1的意义不仅仅在于第一个do()whiledo() whiledo()while结构可以将枢纽元素计算进去，更重要的是一个哨兵的作用。因为后面我们进行移动指针的时候并没有判断指针是否越界。对于右边的指针无论如何一定会停下来，因为它的左边至少还有一个和枢纽元素相等的元素（枢纽元素本身），但是如果左边我们刚开始的时候跳过了枢纽元素，那么如果在数组末尾的话就会越界。只有让左边刚开始为i=l−1i=l-1i=l−1，那么指针至少会停在枢纽元素的位置。如果发生了交换的话，那么指针也一定会停在交换时右边指针位置的前面。还有一点就是第12行区间分割为[l,j+1) [j+1,r)而不是[l,j),[j,r)，因为后面这种做法有可能导致左边[l,j)的区间长度为0，这样将会导致栈溢出。产生这种现象的原因主要是枢纽元素选择的不恰当，对于选择第一个元素作为枢纽来讲，j一定是小于r-1的（因为第一次肯定会卡住），所以不用担心j+1等于r。如果枢纽选择的比较恰当，就不会出现这种问题。

上面的这种做法没有将枢纽元素放在中间，但是因为他不害怕重复元素，所以不用担心问题的规模不减小而产生栈溢出。

通过划分解决了上面的问题以后我们就可以得到一个复杂度挺优秀的快速排序了。

实现代码

#include <iostream>using namespace std;typedef double T;T* CreatList(int &n)
{printf("n="); scanf("%d",&n);T* ret = new T[n];for(int i=0;i<n;++i){cin>>ret[i];}return ret;
}void Init(T* a,int l,int r)
{int mid=(l+r)>>1;if(a[mid] < a[l]) swap(a[mid],a[l]);if(a[mid] < a[r-1]) swap(a[mid],a[r-1]);if(a[l] > a[r-1]) swap(a[l],a[r-1]);return;
}void QuickSort(T* a,int l,int r)
{if(r-l<2) return;Init(a,l,r);//将首部、尾部、中间三个数中的中值放在开头int i=l-1,j=r;T pivot = a[l];while(i<j){do ++i; while(a[i] < pivot);do --j; while(a[j] > pivot);if(i < j) swap(a[i],a[j]);}QuickSort(a,l,j+1); QuickSort(a,j+1,r);
}void Show(T* a,int n)
{for(int i=0;i<n;++i){cout<<a[i]<<" ";}cout<<endl;
}int main()
{int n;T* a=CreatList(n);QuickSort(a,0,n);cout<<"经过排序之后:"<<endl;Show(a,n);delete[] a;return 0;
}

为了验证是否我们的确对算法的效率进行了提高，我编写了测试程序：（单位为SSS，环境为Ubuntu18.04Ubuntu18.04Ubuntu18.04）

数据规模	1e5乱序	1e6乱序	1e7乱序	5e4重复	5e4有序
一侧划分+取中值	0.021184	0.255226	2.913669	2.964905	0.005573
空穴法划分+取中值	0.014865	0.172306	1.980930	3.135060	0.002652
两侧直接划分+取中值	0.017033	0.195318	2.236171	0.004814	0.002670
两侧直接划分	0.016239	0.189592	2.178169	0.004700	2.622307

为了减少运行时操作系统的影响，每个数据规模运行我都运行十次然后取平均值。

虽然仍旧可能还有数据本身的影响，但是我们也能够大概看出来一个大体的变化规律。当数据为乱序的时候空穴法是比较优秀的，但是当出现重复元素时，两侧直接划分的方法碾压前面两种方法。当数据大体是有序的时候如果我们选取枢纽直接选择第一个其时间复杂度也是可怕的。

因此综合考虑我们采用第三种方法是比较好的。

测试程序代码

#include <iostream>
#include <ctime>
#include <cstdio>
#include <fstream>
#include <cstdlib>using namespace std;typedef double T;
typedef void (*FP)(T*,int,int);  //定义函数指针数组类型void CreatData()
{int n=10;FILE* file=fopen("TestFile","w");fprintf(file,"%d\n",n);int t;srand(t);for(int i=0;i<n;++i){t=rand();fprintf(file,"%d ",rand()%10);}fclose(file);return ;
}T* CreatList(int &n)
{//printf("n=");//CreatData();ifstream in("TestFile");in >> n;T* ret = new T[n];for(int i=0;i<n;++i){in>>ret[i];}in.close();return ret;
}void Init(T* a,int l,int r)
{int mid=(l+r)>>1;if(a[mid] > a[l]) swap(a[mid],a[l]);if(a[mid] > a[r-1]) swap(a[mid],a[r-1]);if(a[l] > a[r-1]) swap(a[l],a[r-1]);return;
}void QuickSort1(T* a,int l,int r)
{if(r-l<2) return;Init(a,l,r);//将首部、尾部、中间三个数中的中值放在开头//从一边划分int index=l;T x=a[l];for(int i=l+1;i<r;++i){if(a[i]<x)swap(a[++index],a[i]);}swap(a[index],a[l]);QuickSort1(a,l,index); QuickSort1(a,index+1,r);
}void QuickSort2(T* a,int l,int r)
{if(r-l<2) return;Init(a,l,r);//将首部、尾部、中间三个数中的中值放在开头//空穴法int i=l,j=r-1;T x=a[l];while(i<j){while(i<j && a[j]>x) --j; a[i]=a[j];while(i<j && a[i]<=x) ++i;a[j]=a[i];}a[i]=x;QuickSort2(a,l,i); QuickSort2(a,i+1,r);
}void QuickSort3(T* a,int l,int r)
{if(r-l<2) return;Init(a,l,r);//将首部、尾部、中间三个数中的中值放在开头int i=l-1,j=r;T pivot = a[l];while(i<j){do ++i; while(a[i] < pivot);do --j; while(a[j] > pivot);if(i < j) swap(a[i],a[j]);}QuickSort3(a,l,j+1); QuickSort3(a,j+1,r);
}void QuickSort4(T* a,int l,int r)
{if(r-l<2) return;int i=l-1,j=r;T pivot = a[l];while(i<j){do ++i; while(a[i] < pivot);do --j; while(a[j] > pivot);if(i < j) swap(a[i],a[j]);}QuickSort4(a,l,j+1); QuickSort4(a,j+1,r);
}void Show(T* a,int n)
{for(int i=0;i<n;++i){cout<<a[i]<<" ";}cout<<endl;
}void Test(FP fp[])
{for(int i=0;i<4;++i){clock_t S,E;int Time = 10;double sum=0;for(int j=0;j<Time;++j){int n;T* a=CreatList(n);S=clock();fp[i](a,0,n);E=clock();sum+=(double)(E-S)/CLOCKS_PER_SEC;//cout<<"经过排序之后:"<<endl;//Show(a,n);delete[] a;}printf("QuickSort%d's times=%f\n",i+1,sum/Time);}
}int main()
{FP fp[4] = {QuickSort1,QuickSort2,QuickSort3,QuickSort4};Test(fp);return 0;
}

快速排序详解+各种实现方式相关推荐

Android复习10【Service与Thread的区别、Service的生命周期、Service生命周期解析（相关方法详解、启动方式的不同、绑定）、音乐播放器+服务】
音乐播放器Android代码下载:https://wws.lanzous.com/ifqzihaxvij 目录 Service与Thread的区别 Service的生命周期 Service生命周 ...
常用排序:冒泡排序与快速排序详解，看完这篇就够了！风马博客
常用排序:冒泡排序与快速排序详解. 在排序算法中,冒泡排序和快速排序可以算是排序算法入门必会的两种排序了,今天和大家来分析一下如何快速理解并掌握这两种排序.首先冒泡排序是初学者最常用的排序,所以我们先 ...
MySQL数据库怎么查看er图表_详解 Navicat 查看方式之ER图表
Navicat 在主窗口查看对象类型的方法有三种,分别是列表.详细信息.ER图表.默认情况下,Navicat 使用"列表"查看对象类型.这三种查看类型拥有不同的特点,本教程将详解 ...
python 快速排序详解
python 快速排序详解快速排序函数 def partition(arr,low,high): i = ( low-1 ) #最小元素<索引>pivot = arr[high] #选取 ...
消息通知系统详解1---通讯方式
消息通知系统详解1-通讯方式消息通知系统详解2-后端设计消息通知系统详解3-Netty 消息通知系统详解4-整合Netty和WebSocket 目录什么是消息通知系统系统特性通讯方式短连接 ...
iOS绘图详解-多种绘图方式、裁剪、滤镜、移动、CTM
iOS绘图详解摘要: Core Graphics Framework是一套基于C的API框架,使用了Quartz作为绘图引擎.它提供了低级别.轻量级.高保真度的2D渲染.该框架可以用于基于路径的绘 ...
HTTP详解（请求方式）
原文地址:HTTP协议详解(真的很经典) 作者:308938969 HTTP是一个属于应用层的面向对象的协议,由于其简捷.快速的方式,适用于分布式超媒体信息系统.它于1990年提出,经过几年的使用与发 ...
NFS 服务详解及实现方式
NFS 服务详解 NFS 介绍 1.NFS 服务 2.NFS 文件系统 3.NFS 工作原理 4.NFS 各个版本的对比 NFS 程序环境 1.环境介绍 2.NFS 服务主要进程 3.配置防火墙(NF ...
【数据结构】快速排序详解
目录一.基本介绍二.快排的实现 1. 调试环境 2.快排的单趟排序 (1)Hoare版本 (2)挖坑法 (3)前后指针法 2.递归过程三.快排的优化 1. 优化取key方式,防止栈溢出 2. 小 ...

快速排序详解+各种实现方式

快速排序详解+各种实现方式相关推荐

最新文章

热门文章