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

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

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

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

  2. 数组中有很多一模一样的数字：这样同样会产生每次只能将规模减小很少的情况，最坏的时候复杂度也将退化为O(n2)O(n^2)O(n2)。这种问题的产生我们无法通过有效的选择枢纽解决，只能够通过划分的时候使得即使数组中的元素都等于枢纽我们仍旧能够将数组大概分成相等的两部分。

常见的有以下划分方法：

  1. 从一边进行划分

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

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

    实现代码

    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);
｝

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

  1. 从两边进行划分

  • 空穴法

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

    实现代码

    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.0211840.2552262.9136692.9649050.005573
空穴法划分+取中值0.0148650.1723061.9809303.1350600.002652
两侧直接划分+取中值0.0170330.1953182.2361710.0048140.002670
两侧直接划分0.0162390.1895922.1781690.0047002.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;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383673.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C++的单例模式与线程安全单例模式（懒汉/饿汉）

C++的单例模式与线程安全单例模式（懒汉/饿汉）

https://www.cnblogs.com/qiaoconglovelife/p/5851163.html1 教科书里的单例模式我们都很清楚一个简单的单例模式该怎样去实现&#xff1a;构造函数声明为private或protect防止被外部函数实例化&#xff0c;内部保存一个private static的类指针保存唯一的实例&#xff0c;实例的…
阅读更多...
计算矩阵的逆和行列式的值(高斯消元+LU分解)

计算矩阵的逆和行列式的值(高斯消元+LU分解)

计算矩阵的逆 选主元的高斯消元法 朴素的高斯消元法是将矩阵A和单位矩阵放在一起&#xff0c;通过行操作&#xff08;或者列操作&#xff09;将A变为单位矩阵&#xff0c;这个时候单位矩阵就是矩阵A的逆矩阵。从上到下将A变为上三角矩阵的复杂度为O(n3n^3n3)&#xff0c;再从下…
阅读更多...
Linux网络编程——tcp并发服务器（epoll实现）

Linux网络编程——tcp并发服务器（epoll实现）

https://blog.csdn.net/lianghe_work/article/details/46551871通过epoll实现tcp并发回执服务器&#xff08;客户端给服务器发啥&#xff0c;服务器就给客户端回啥&#xff09; 代码如下&#xff1a;#include <string.h>#include <stdio.h>#include <stdlib.h&g…
阅读更多...
证明AVL树的上界和下界

证明AVL树的上界和下界

对于n个节点的AVL树&#xff0c;其高度最低的时候肯定为叶子节点只在最后一层和倒数第二层的时候。即对于2k−1<n≦2k1−12^k-1< n\leqq 2^{k1}-12k−1<n≦2k1−1的时候下界都为kkk。因此下界为h┌log2(n1)┐−1h\ulcorner log_2(n1)\urcorner-1h┌log2​(n1)┐−1 对…
阅读更多...
浅谈dup和dup2的用法

浅谈dup和dup2的用法

https://blog.csdn.net/u012058778/article/details/78705536一、dup和dup2函数 这两个函数都可以来复制一个现有的文件描述符&#xff0c;他们的声明如下&#xff1a;#include <unistd.h>int dup(int fd);int dup2(int fd, int fd 2); 123 关于dup函数&#xff0c;当我…
阅读更多...
C++ cin 实现循环读入

C++ cin 实现循环读入

习惯了使用while(~scanf("%d",x)){}来实现循环读入&#xff0c;但是有时候使用泛型编程的时候就必须使用C中的cin&#xff0c;但是当我想要实现循环读入的时候却发现有些困难。 我们可以看一下下面这个简单的例子&#xff1a; #include <iostream>using name…
阅读更多...
BFPTR算法详解+实现+复杂度证明

BFPTR算法详解+实现+复杂度证明

BFPTR算法是由Blum、Floyed、Pratt、Tarjan、Rivest这五位牛人一起提出来的&#xff0c;其特点在于可以以最坏复杂度为O(n)O(n)O(n)地求解top−ktop-ktop−k问题。所谓top−ktop-ktop−k问题就是从一个序列中求解其第k大的问题。 top−ktop-ktop−k问题有许多解决方法&#xff…
阅读更多...
C++子类对象隐藏了父类的同名成员函数（隐藏篇）

C++子类对象隐藏了父类的同名成员函数（隐藏篇）

https://blog.csdn.net/alpha_love/article/details/75222175#include <iostream>#include <stdlib.h>#include <string>using namespace std;/*** 定义人类: Person* 数据成员: m_strName* 成员函数: attack()*/class Person{public:Person(){cout<<&…
阅读更多...
随机化快速排序+快速选择 复杂度证明+运行测试

随机化快速排序+快速选择 复杂度证明+运行测试

对于快速排序和快速选择我之前的文章已经有详细的说明&#xff0c;需要了解的同学可以移步 传送门&#xff1a;快速排序&#xff5c;快速选择(BFPTR) 所谓随机化其实就是选择枢纽的时候使用随机数选择而已&#xff0c;实现起来很简单。但是我们使用随机数如何保证复杂度呢&am…
阅读更多...
C++子类父类成员函数的覆盖和隐藏实例详解

C++子类父类成员函数的覆盖和隐藏实例详解

https://www.jb51.net/article/117380.htm函数的覆盖覆盖发生的条件&#xff1a; &#xff08;1&#xff09; 基类必须是虚函数&#xff08;使用virtual 关键字来进行声明&#xff09; &#xff08;2&#xff09;发生覆盖的两个函数分别位于派生类和基类 &#xff08;3&#xf…
阅读更多...
【Linux基础】Linux的5种IO模型详解

【Linux基础】Linux的5种IO模型详解

引入 为了更好的理解5种IO模型的区别&#xff0c;在介绍IO模型之前&#xff0c;我先介绍几个概念 1.进程的切换 &#xff08;1&#xff09;定义 为了控制进程的执行&#xff0c;内核必须有能力挂起正在CPU上运行的进程&#xff0c;并恢复以前挂起的某个进程的执行。即从用户…
阅读更多...
计算机网络【五】广播通信+以太网

计算机网络【五】广播通信+以太网

局域网的拓扑 广域网使用点到点通信 局域网使用广播通信 可以随意向网络中添加设备。 总线网星形网&#xff0c;使用集线器。现在多使用星形网络。环状网树形网 其中匹配电阻用来吸收总线上传播的信号。 共享通信媒体 静态划分信道 频分复用、时分复用、波分复用、码分复用…
阅读更多...
聊聊Linux 五种IO模型

聊聊Linux 五种IO模型

一篇《聊聊同步、异步、阻塞与非阻塞》已经通俗的讲解了&#xff0c;要理解同步、异步、阻塞与非阻塞重要的两个概念点了&#xff0c;没有看过的&#xff0c;建议先看这篇博文理解这两个概念点。在认知上&#xff0c;建立统一的模型。这样&#xff0c;大家在继续看本篇时&#…
阅读更多...
操作系统【四】分页存储管理

操作系统【四】分页存储管理

连续分配方式的缺点&#xff1a; 固定分区分配&#xff1a;缺乏灵活性&#xff0c;产生大量的内部碎片&#xff0c;内存的利用率较低 动态分区分配&#xff1a;会产生许多外部碎片&#xff0c;虽然可以用紧凑技术处理&#xff0c;但是紧凑技术的时间代价较高 基本分页存储管理…
阅读更多...
聊聊同步、异步、阻塞与非阻塞

聊聊同步、异步、阻塞与非阻塞

近来遇到了一些常见的概念&#xff0c;尤其是网络编程方面的概念&#xff0c;如&#xff1a;阻塞、非阻塞、异步I/O等等&#xff0c;对于这些概念自己也没有太清晰的认识&#xff0c;只是很模糊的概念&#xff0c;说了解吧也了解&#xff0c;但是要让自己准确的描述概念方面的具…
阅读更多...
操作系统【五】分段内存管理+段页式内存管理

操作系统【五】分段内存管理+段页式内存管理

基本分段存储管理 与分页最大的区别&#xff1a;离散分配时所分配地址空间的基本单位不同 进程的地址空间&#xff1a;按照程序自身的逻辑关系划分为若干个段&#xff0c;每个段都有一个段名&#xff0c;每段从0开始编址 内存分配规则&#xff1a;以段位单位进行分配&#xff…
阅读更多...
计算机网络【六】网络层协议

计算机网络【六】网络层协议

网络层负责在不同网络之间尽力转发数据包&#xff08;基于数据包的IP地址转发&#xff09;。不负责丢失重传&#xff0c;也不负责顺序&#xff08;每一个数据包都是单独选择路径&#xff09;。 可靠传输是由传输层实现。 网络设备和OSI参考模型 通过分层&#xff0c;屏蔽了…
阅读更多...
epoll 水平触发与边缘触发

epoll 水平触发与边缘触发

https://blog.csdn.net/lihao21/article/details/67631516?refmyread epoll也是实现I/O多路复用的一种方法&#xff0c;为了深入了解epoll的原理&#xff0c;我们先来看下epoll水平触发&#xff08;level trigger&#xff0c;LT&#xff0c;LT为epoll的默认工作模式&#xff…
阅读更多...
计算机网络【3】网络层

计算机网络【3】网络层

主要任务时把分组从源端发送到目的端&#xff0c;为分组交换网上的不同主机提供服务。网络层传输单位是数据报 功能&#xff1a; 路由选择与分组转发&#xff08;最佳路径 &#xff09;异构网络互联拥塞控制 数据交换方式 电路交换&#xff1a;通信时延小、有序传输、没有冲…
阅读更多...
C++空类的大小

C++空类的大小

https://blog.csdn.net/lihao21/article/details/47973609 本文中所说是C的空类是指这个类不带任何数据&#xff0c;即类中没有非静态(non-static)数据成员变量&#xff0c;没有虚函数(virtual function)&#xff0c;也没有虚基类(virtual base class)。 直观地看&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023