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

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

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

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

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

常见的有以下划分方法：

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

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

2. 从两边进行划分

• 空穴法

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

  实现代码

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

为什么这样做就可以解决重复元素的问题呢？这里和上面方法最大的不同就在于我们在划分的时候没有使用等号。这样的话如果遇到和枢纽相等的元素的时候我们就移动然后越过这个位置。使用$do$ $while;$结构就是为了能够跨越和枢纽相等的元素。如果整个数组都是相等的话虽然我们多进行一些交换，但是有效地将数组划分成了差不多相等的两部分。
对于代码的理解，很重要的一点就是将$i=l-1$。刚开始我觉得这一点没有很重要所以自己将其改为了$i=l$，然后最后将枢纽元素放在中间。但是在测试的时候我发现对于有些数据会出错。仔细推敲数据以后发现，$i=l-1$的意义不仅仅在于第一个$do()while$结构可以将枢纽元素计算进去，更重要的是一个哨兵的作用。因为后面我们进行移动指针的时候并没有判断指针是否越界。对于右边的指针无论如何一定会停下来，因为它的左边至少还有一个和枢纽元素相等的元素（枢纽元素本身），但是如果左边我们刚开始的时候跳过了枢纽元素，那么如果在数组末尾的话就会越界。只有让左边刚开始为$i=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;
}

为了验证是否我们的确对算法的效率进行了提高，我编写了测试程序：（单位为$S$，环境为$Ubuntu18.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;
}