快速排序

其实对于c++选手来说，快速排序即使没有掌握，也可以使用STL库中的sort函数。但仔细学习一下快速排序还是很有必要的，不光是由此演化的快速选择算法，快排的种种优化也可以锻炼能力。

快排的思想很简单，就是选取序列中任意一个元素为基准，将序列划分成两部分，序列左边都比基准小，右边都比基准大，也就是找到了基准元素的正确位置，这就完成了一趟快速排序，再递归处理左右两个子序列就可以了。

快速排序是冒泡排序的改进，每次移动都是跳跃式的，平均复杂度是O(nlogn)的，而最坏情况下，快排将退化成冒泡排序，复杂度为O(n^2)。

说起来，快排有三种常见的实现方式，分别是左右指针法、挖坑法、前后指针法。这三种方法都可以，在此使用挖坑法，其他两种可以自行了解一下。

挖坑法一般会选取序列左右端点为基准，先将坑放在基准元素处，然后从两端不断挖新坑，填旧坑，最终找到基准元素应该在的坑，填上。

void qsort(int l,int r) {
    if(l>=r) return;
    int x=a[l],i=l,j=r;
    while(i<j) {
        while(a[j]>=x&&i<j) --j;
        a[i]=a[j];
        while(a[i]<=x&&i<j) ++i;
        a[j]=a[i];
    }
    a[i]=x;
    qsort(l,i-1);
    qsort(j+1,r);
}

再来说说快排的优化，为什么需要优化呢？快排的平均效率很高，主要是为了针对一些极端情况，比如序列原先有序、有大量重复元素等。

优化的方法主要有三个：1、三数取中法 2、小区间优化 3、针对重复元素的优化。

基准元素如果选的太大或太小，就会影响快排的效率，随机选取基数，或是使用三数取中法都是可以尽量避免的。三数取中法就是选取序列开头结尾及中间位置上的三个数中第二大的数。

其实，挖坑法会选取端点元素为基准，也可以认为是将次大的元素放到序列端点上。

void move_mid(int l,int r) {
    int m=l+(r-l)/2;
    if(a[l]>a[m]) swap(a[l],a[m]);
    if(a[m]>a[r]) swap(a[m],a[r]);
    if(a[l]<a[m]) swap(a[l],a[m]);
}

move_mid(l,r);  //快排中加入此语句

小区间优化是指当要排序的序列长度较小时，快速排序的效率甚至不如插入排序，因此当区间长度较小时，可以用插排代替快排。

void isort(int l,int r) { //插入排序
    for(int i=l+1,j;i<=r;++i) {
        int x=a[i];
        for(j=i-1;a[j]>x&&j>0;--j) a[j+1]=a[j];
        a[j+1]=x;
    }
}

if(r-l+1<10) { //快排中加入此语句
    isort(l,r);
    return;
}

如果序列里有大量重复元素，快排的效率会很低，优化方法是，按照基准划分左右序列时，将重复元素放到序列两端，划分结束后，将重复元素放到基准元素周围。

void qsort(int l,int r) {
    if(l>=r) return;
    int x=a[l],i=l,j=r,first=l,last=r,llen=0,rlen=0;
    while(i<j) {
        while(a[j]>=x&&i<j) { //先将与基准元素相同的元素放到序列两端
            if(a[j]==x) {
                swap(a[j],a[last--]);
                ++rlen;
            }
            --j;
        }
        a[i]=a[j];
        while(a[i]<=x&&i<j) {
            if(a[i]==x) {
                swap(a[i],a[first++]);
                ++llen;
            }
            ++i;
        }
        a[j]=a[i];
    }
    a[i]=x;
    int p=l,q=i-1; //将重复元素放到基准元素周围
    while(p<first&&a[q]!=x) swap(a[p++],a[q--]);
    p=j+1,q=r;
    while(q>last&&a[p]!=x) swap(a[p++],a[q--]);
    qsort(l,i-1-llen); //只需排序重复元素两边的子序列
    qsort(j+1+rlen,r);
}

这三种优化一起使用，效率会很高，接近c++ STL中的sort函数。

void move_mid(int l,int r) { //三数取中法
    int m=l+(r-l)/2;
    if(a[l]>a[m]) swap(a[l],a[m]);
    if(a[m]>a[r]) swap(a[m],a[r]);
    if(a[l]<a[m]) swap(a[l],a[m]);
}
void isort(int l,int r) { //插入排序
    for(int i=l+1,j;i<=r;++i) {
        int x=a[i];
        for(j=i-1;a[j]>x&&j>0;--j) a[j+1]=a[j];
        a[j+1]=x;
    }
}
void qsort(int l,int r) {
    if(l>=r) return;
    if(r-l+1<10) { //小区间优化
        isort(l,r);
        return;
    }
    move_mid(l,r);
    int x=a[l],i=l,j=r,first=l,last=r,llen=0,rlen=0;
    while(i<j) {
        while(a[j]>=x&&i<j) { //先将与基准元素相同的元素放到序列两端
            if(a[j]==x) {
                swap(a[j],a[last--]);
                ++rlen;
            }
            --j;
        }
        a[i]=a[j];
        while(a[i]<=x&&i<j) {
            if(a[i]==x) {
                swap(a[i],a[first++]);
                ++llen;
            }
            ++i;
        }
        a[j]=a[i];
    }
    a[i]=x;
    int p=l,q=i-1; //将重复元素放到基准元素周围
    while(p<first&&a[q]!=x) swap(a[p++],a[q--]);
    p=j+1,q=r;
    while(q>last&&a[p]!=x) swap(a[p++],a[q--]);
    qsort(l,i-1-llen); //只需排序重复元素两边的子序列
    qsort(j+1+rlen,r);
}

呃呃，目前来说，快速排序对我还是很玄学的。。。理论上快排的各种实现方式效果应该是一样的，但洛谷上面的快排模板题对于某些不加优化实现方式是会超时的，在这里放一下简洁的未加优化却可以A掉某些其他实现形式A不掉的模板题的代码。

void quicksort(int l, int r) {
    if (l == r) return;
    int mid = a[l + (r - l) / 2], i = l, j = r;
    while (i <= j) {
        while (a[i] < mid) ++i;
        while (a[j] > mid) --j;
        if (i <= j) {
            swap(a[i], a[j]);
            ++i,--j;
        }
    };
    if (i < r) quicksort(i, r);
    if (j > l) quicksort(l, j);
}