洛谷 P1177 【模板】快速排序【13种排序模版】

P1177 【模板】快速排序

题目描述

利用快速排序算法将读入的N个数从小到大排序后输出。

快速排序是信息学竞赛的必备算法之一。对于快速排序不是很了解的同学可以自行上网查询相关资料，掌握后独立完成。（C++选手请不要试图使用STL，虽然你可以使用sort一遍过，但是你并没有掌握快速排序算法的精髓。）

输入输出格式

输入格式：

输入文件sort.in的第1行为一个正整数N，第2行包含N个空格隔开的正整数a[i]，为你需要进行排序的数，数据保证了A[i]不超过1000000000。

输出格式：

输出文件sort.out将给定的N个数从小到大输出，数之间空格隔开，行末换行且无空格。

输入输出样例

输入样例#1：

5
4 2 4 5 1

输出样例#1：

1 2 4 4 5

说明

对于20%的数据，有N≤1000；

对于100%的数据，有N≤100000。

题目链接：https://www.luogu.org/problem/show?pid=1177

下面给出几种排序方法：

1.松式基排

所谓普通基排，就是以65536为底，用位运算，把一个数拆成两部分，要循环两遍

松式基排，就是以256为底，用位运算把一个数拆成四部分，要循环四遍

为什么松式基排在WC的时候会更快呢，因为这样的话cnt数组刚好能装进L1高速缓存

下面给出如下代码：

#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 100010;
const int BIT = 16;
const int U = 65536;
int n, a[MAXN];
inline int getd( int x, int d ) {
    return (x>>(d*BIT))&(U-1);
}
int cnt[U], b[MAXN];
void radix_sort() {
    int *x = a, *y = b;
    for( int d = 0; d < 2; ++d ) {
        for( int i = 0; i < U; ++i ) cnt[i] = 0;
        for( int i = 0; i < n; ++i ) ++cnt[getd(x[i],d)];
        for( int i = 1; i < U; ++i ) cnt[i] += cnt[i-1];
        for( int i = n-1; i >= 0; --i ) y[--cnt[getd(x[i],d)]] = x[i];
        swap(x,y);
    }
    for( int i = 0; i < n; ++i ) printf( "%d ", x[i] );
}
int main() {
    scanf( "%d", &n );
    for( int i = 0; i < n; ++i ) scanf( "%d", a+i );
    radix_sort();
    return 0;
}

2.归并排序

时间复杂度：O(nlogn)

注意：

1.其他排序算法的空间复杂度是O(1)，而归并排序的空间复杂度很大，为O(n)。

2.下面的end是“末尾索引＋1”，即数列末尾要留一个空位。

下面给出如下代码：

#include<iostream>
using namespace std;
int a[100010];
int temp[100010];
void merge_sort(int *a,int start,int end)
{
    if(start+1>=end)                                         //回渊
    return;
    //int temp[start-end+5];                            
    int mid=start+(end-start)/2;                        //划分阶段
    int i=start,j=mid,count=start;
    merge_sort(a,start,mid);
    merge_sort(a,mid,end);
    while(i<mid||j<end)                                    //合并解
    {
        if(j>=end||(i<mid&&a[i]<=a[j]))
        {
            temp[count++]=a[i++];
        }
        else
        temp[count++]=a[j++];
    }
    //int x=0;
    for(int v=start;v<end;v++)
    {
        a[v]=temp[v];
    }
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    merge_sort(a,0,n);
    for(int i=0;i<n;i++)
    {
        cout<<a[i]<<' ';
    }
    return 0;
}

3.快速排序(优化读入读出)

下面给出如下代码：

#include <cstdio>
#include <iostream>
using namespace std;
int a[100000];
int read_int() //读入优化
{
    int x,f=1; //f表示符号,x表示数值
    char ch;
    while (ch=getchar(),ch<48||ch>57) //如果ch不是数字
        if (ch=='-') f=-f; //如果是符号就改变符号
    x=ch-48; //首位数字
    while (ch=getchar(),ch>=48&&ch<=57) //接下来的每位数字
        x=x*10+ch-48; //将数字添加进x内
    return x*f; //返回数值
}
void write_int(int x)  
{  
    if (x==0) //判断0的情况
        {
        putchar('0');
        return;
    }
    int num=0;
    char c[11]; //然而我刚开始打的是10,然后发现输出10位数乱码了
    while (x) //x!=0
        c[++num]=x%10+48,x/=10; //保存每一位
    while (num) //如果未输出完
        putchar(c[num--]); //输出
}
int sort(int l,int r) //快排，不用多说了吧
{
    int i,j,x;
    x=a[(l+r)>>1]; //基准
    i=l;
    j=r;
    do
    {
        while (a[i]<x) ++i;
        while (a[j]>x) --j; //跳过排序完毕的元素
        if (i<=j)
        {
            a[0]=a[i];
            a[i]=a[j];
            a[j]=a[0];
            ++i;
            --j; //交换
        }
    }
    while (i<=j);
    if (l<j) sort(l,j);
    if (i<r) sort(i,r); //排序左右子序列
}
int main()
{
    int n,i;
    n=read_int();
    for (i=1;i<=n;i++)
        a[i]=read_int(); //快读的正确打开方式
    sort(1,n);
    for (i=1;i<n;i++)
    {
        write_int(a[i]);
        putchar(' '); //输出的正确打开方式
    }
    write_int(a[n]);
    putchar('\n'); //强迫症...
    return 233; 
}

4.利用stl实现堆排序，不是优先队列，比优先队列快上不少，而且容易记

下面给出如下代码：

#include <cstdio>
#include <algorithm>
#include <queue>//头文件
using namespace std;
const int maxx = 100000 + 10;
int Heap[maxx];
int main()
{
    int n,num = 0,x;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&x),Heap[++num]=x,push_heap(Heap+1,Heap+num+1,greater<int>());
    for(int i=1;i<=n;i++)
            printf("%d ",Heap[1]),pop_heap(Heap+1,Heap+num+1,greater<int>()),num--;//这几步是关键
    return 0;
}//代码比手搓堆短很多，而且时间差不多

5.朴素的堆排模板类

下面给出如下代码：

#include <bits/stdc++.h>
using namespace std;
template<typename T> //定义一个交换模板
void change(T& a,T& b)
{
    T t;
    t=a;a=b;b=t;
}
template<typename T> //定义一个模板类
class Heap{
    T data[100001]; //存储数据

    void ify(int i); //维护堆
        Heap(int); //构造函数
        ~Heap(); //析构函数
        void build(); //建堆
        void heapsort(); //堆排序
        istream& scan(istream&); //读入
        ostream& print(ostream&); //输出
};
template<typename T>
Heap<T>::Heap(int n_):n(n_)
{
}
template<typename T>
Heap<T>::~Heap()
{
}
template<typename T>
void Heap<T>::ify(int i)
{
    int l=i<<1;
    int r=(i<<1)+1;
    int m;
    if (l<=size&&data[l]>data[i]) m=l;
    else m=i;
    if (r<=size&&data[r]>data[m]) m=r;
    if (m!=i)
    {
        change(data[m],data[i]); //找到最大数后交换并维护子树
        ify(m);
    }
}
template<typename T>
void Heap<T>::build()
{
    int i;
    size=n;
    for (i=n/2;i>0;i--) //对每个非叶子节点维护一次
        ify(i);
}
template<typename T>
void Heap<T>::heapsort()
{
    build();
    for (int i=n;i>1;i--)
    {
        change(data[1],data[i]); //将最大数扔到最后
        --size;
        ify(1); //维护
    }
}
template<typename T>
istream& Heap<T>::scan(istream& is) //读入 
{
    for (int i=1;i<=n;i++)
        is>>data[i];
    return is;
}
template<typename T>
ostream& Heap<T>::print(ostream& os) //输出 
{
    for (int i=1;i<n;i++)
        os<<data[i]<<' ';
    os<<data[n];
    return os;
}
template<typename T>
istream& operator>>(istream& is,Heap<T>& a) //重载运算符 
{
    return a.scan(is);
}
template<typename T>
ostream& operator<<(ostream& os,Heap<T>& a) //同上 
{
    return a.print(os);
}
int main()
{
    int n;
    cin>>n;
    Heap<int> a(n);
    cin>>a;
    a.heapsort();
    cout<<a<<endl;
}

6.优先队列priority_queue

下面给出如下代码：

#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
int main(){
    priority_queue<int,vector<int>,greater<int> > q;
    int n,x;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&x);
        q.push(x);    
    }
    for(int i=1;i<=n;i++){
        x=q.top();
        printf("%d ",x);
        q.pop();
    }
    return 0;
}

7.用一个红黑树来实现

下面给出如下代码：

#include <cstdlib>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main(int argc, char *argv[])
{
    multiset<int>sort;//新建一个红黑树
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
            int a;
            cin>>a;
            sort.insert(a);//将数据插入红黑树
            }
    set<int>::iterator it;
    for(it=sort.begin();it!=sort.end();it++)
    cout << *it<<' ';//遍历输出红黑树，即排序结果
    cout<< endl;
    return 0;
}

8.排序二叉树

有一种很好的办法是用排序二叉树。。。建好树后中序遍历输出。。。就好了。

不过二叉排序树有退化成链的可能，所以可以用splay或是treap甚至AVL以及红黑树来排序。。。

伸展树(splay)的写法：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#define xh(a,b,c)for(int a=(b);a<=(c);a++)
#define dxh(a,b,c)for(int a=(b);a>=(c);a--)
#define hy(a)memset(a,0,sizeof(a))
using namespace std;
void qin(int &x){//快速读入
    int base=1,num;
    char c=getchar();
    while(!(c=='-'||c>='0'&&c<='9'||c==EOF))c=getchar();
    if(c==EOF)exit(0);
    if(c=='-')base=-1,c=getchar();
    num=c-'0';
    c=getchar();
    while(c>='0'&&c<='9'){
        num*=10;
        num+=c-'0';
        c=getchar();
    }
    x=num*base;
}
char integ[50];
void qout(int x){//快速输出
    if(x<0)putchar('-'),x=-x;
    int len=0;
    do{
        integ[len++]=x%10+'0';
        x/=10;
    }while(x);
    while(len--){
        putchar(integ[len]);
    }
}
struct jd{//静态splay
    int x;
    int l,r,h; 
};
const int N=101010;
jd bst[N];
int root,n;//root表示根节点的编号
void lj(int u,int d,int fx){
    if(fx==1)bst[u].r=d;
    else bst[u].l=d;
    bst[d].h=u;
}
void zig(int x){//左旋
    int b1=bst[x].l,b2=bst[x].r,h=bst[x].h,b3=bst[h].r;
    root=x;
    bst[x].h=0;
    lj(x,h,1);
    lj(x,b1,-1);
    lj(h,b2,-1);
    lj(h,b3,1);
}
void zag(int x){//右旋
    int b1=bst[x].l,b2=bst[x].r,h=bst[x].h,b3=bst[h].l;
    root=x;
    bst[x].h=0;
    lj(x,h,-1);
    lj(x,b2,1);
    lj(h,b3,-1);
    lj(h,b1,1);
}
void zigzig(int x){//略。。。反正是向上调
    int b1=bst[x].l,
        b2=bst[x].r,
        h=bst[x].h,
        b3=bst[h].r,
        hh=bst[h].h,
        b4=bst[hh].r,
        hhh=bst[hh].h;
        if(hhh==0){
            root=x;
            bst[x].h=0;
        }else if(bst[hhh].l==hh)lj(hhh,x,-1);
        else lj(hhh,x,1);
    lj(x,h,1);
    lj(h,hh,1);
    lj(x,b1,-1);
    lj(h,b2,-1);
    lj(hh,b3,-1);
    lj(hh,b4,1);
}
void zagzag(int x){//略。。。反正是向上调*2
    int h=bst[x].h,
        hh=bst[h].h,
        hhh=bst[hh].h,
        b1=bst[hh].l,
        b2=bst[h].l,
        b3=bst[x].l,
        b4=bst[x].r; 
        if(hhh==0){
            root=x;
            bst[x].h=0;
        }else if(bst[hhh].l==hh)lj(hhh,x,-1);
    else lj(hhh,x,1);
    lj(x,h,-1);
    lj(h,hh,-1);
    lj(x,b4,1);
    lj(h,b3,1);
    lj(hh,b1,-1);
    lj(hh,b2,1);
}
void zigzag(int x){//略。。。反正是向上调*3
    int b1=bst[x].l,
        b2=bst[x].r,
        h=bst[x].h,
        b3=bst[h].r,
        hh=bst[h].h,
        b4=bst[hh].l,
        hhh=bst[hh].h;
    if(hhh==0){
            root=x;
            bst[x].h=0;
        }else if(bst[hhh].l==hh)lj(hhh,x,-1);
    else lj(hhh,x,1);
    lj(x,h,1);
    lj(x,hh,-1);
    lj(hh,b1,1);
    lj(h,b2,-1);
    lj(h,b3,1);
    lj(hh,b4,-1);    
}
void zagzig(int x){////略。。。反正是向上调
    int b1=bst[x].l,
        b2=bst[x].r,
        h=bst[x].h,
        b3=bst[h].l,
        hh=bst[h].h,
        b4=bst[hh].r,
        hhh=bst[hh].h;
        if(hhh==0){
            root=x;
            bst[x].h=0;
        }else if(bst[hhh].l==hh)lj(hhh,x,-1);
    else lj(hhh,x,1);
    lj(x,h,-1);
    lj(x,hh,1);
    lj(h,b1,1);
    lj(hh,b2,-1);
    lj(h,b3,-1);
    lj(hh,b4,1);    
}
void splay(int x){//伸展操作（把x节点调到根节点）
    while(bst[x].h){
        if(bst[bst[x].h].h==0){
            if(bst[bst[x].h].l==x)zig(x);
            else zag(x);
        }
        else{
            int h=bst[x].h,hh=bst[h].h;
            if(bst[h].l==x){
                if(bst[hh].l==h)zigzig(x);
                else zigzag(x);
            }
            else{
                if(bst[hh].l==h)zagzig(x);
                else zagzag(x);
            }
        }
    }
}
void ins(int r,int i){//插入
    if(bst[i].x<bst[r].x){
        if(bst[r].l==0){
            lj(r,i,-1);
            splay(i);//每当插入一个数后都要把这个数调到根节点
        }
        else ins(bst[r].l,i);
    }
    else{
        if(bst[r].r==0){
            lj(r,i,1);
            splay(i);;//每当插入一个数后都要把这个数调到根节点
        }
        else ins(bst[r].r,i);
    }
}
void bl(int x){//中序遍历
    if(x==0)return;
    bl(bst[x].l);
    qout(bst[x].x);
    putchar(' ');
    bl(bst[x].r);
}
int main(){
    qin(n);
    qin(bst[1].x);
    root=1;
    xh(i,2,n){
        qin(bst[i].x);
        ins(root,i);
    }
    bl(root);
    putchar('\n');
    return 0;
}

9.可并堆

#include<bits/stdc++.h>
using namespace std;
#define fr(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
struct tree{
    tree *l,*r,*f;
    int v,sl,sr;
    tree(){
        l=r=f=NULL;
        v=sl=sr=0;
    }
}*root,*k,*d;
tree* merge(tree *x,tree *y){//合并
    if(x==NULL)return y;
    if(y==NULL)return x;
    if(x->v>y->v)
        swap(x,y);
    x->r=merge(x->r,y);
    x->sr++;
    if((x->sl)<(x->sr)){
        swap(x->l,x->r);
        swap(x->sl,x->sr);
    }
    return x;
}
void insert(int x){//插入
    k=new tree;
    k->v=x;
    if(root==NULL)root=k;
    else root=merge(root,k);
}
int top(){//顶端元素
    if(root!=NULL)return root->v;
    return -1;
}
void pop(){//弹出
    if(root!=NULL)root=merge(root->l,root->r);//合并左右子数
}
int main(){
    root=NULL;
    int n;
    scanf("%d",&n);
    fr(i,1,n){
        int a;
        scanf("%d",&a);
        insert(a);
    }
    fr(i,1,n){
        printf("%d ",top());
        pop();
    }
    return 0;
}

10.希尔排序

#include <cstdio>
using namespace std;
int i,j,k,n,m,x,y,t,d,a[100001];
void ShellInsert(int* pDataArray, int d, int iDataNum){
    for (int i = d; i < iDataNum; i += 1){
        int j = i - d;
        int temp = pDataArray[i];
        while (j >= 0 && pDataArray[j] > temp){pDataArray[j+d] = pDataArray[j];j -= d;}
        if (j != i - d)pDataArray[j+d] = temp;
    }
}
void ShellSort(int* pDataArray, int iDataNum){
    int d = iDataNum / 2;
    while(d >= 1){ShellInsert(pDataArray, d, iDataNum);d = d / 2;}
}
int main(){
    scanf("%d",&n);if (n==0) return 0;
    for (i=0;i<n;i++) scanf("%d",&a[i]);
    ShellSort(a,n);
    for (i=0;i<n;i++) printf("%d ",a[i]);
    return 0;
}

11.用动态插入堆排序

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;
ll heap[1001000];
#define lson(x) x<<1
#define rson(x) x<<1|1
#define fa(x) x>>1
ll N;
struct Heap{
    int size;
    Heap(){
        size=0;
    }
    void pushDown(int i){ //从顶部向下推至合适位置
        int l,r,k; 
        while(lson(i)<=size){
            l=lson(i);r=rson(i);k=i;
            if(heap[k]>heap[l]){
                k=l;
            }
            if(r<=size && heap[k]>heap[r]){
                k=r;
            }
            if(k!=i){
                swap(heap[i],heap[k]);
                i=k;
            }else break;
        }
    }
    void pushUp(int i){ // 从底部推至合适位置
        while(fa(i)>=1){
            if(heap[fa(i)]>heap[i]){
                swap(heap[fa(i)],heap[i]);
                i=fa(i);
            }else break;
        }
    }
    void pop(){ //删除堆顶元素
        heap[1]=heap[size--];
        pushDown(1);
    }
    ll top(){
        return heap[1];
    }
    void insert(int x){ //插入一个新元素到堆底
        heap[++size]=x;
        pushUp(size);
    }
}H;
inline ll read(){
    ll a=0;
    char ch=getchar();
    bool flag = false;
    while(ch>'9' || ch<'0' || ch=='-'){
        if(ch=='-') flag=true;
        ch=getchar();
    }
    while(ch>='0' && ch<='9'){
        a=a*10+ch-'0';
        ch=getchar();
    }
    if(flag) a=-a;
    return a;
}
int main(){
    N=read();ll v;
    for(int i=1;i<=N;++i){
        v=read();H.insert(v);
    }
    while(H.size){
        printf("%lld ",H.top());
        H.pop();
    }
    return 0;
}

12.基数排序(O(n))

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#define Z 1000000+10
#define K 10+10//位数设为20 ， 11 也可以
#define FORZ(a,b,c) for(a=b;a<=c;a++)
#define FORJ(a,b,c) for(a=b;a>=c;a--)
#define M0(a) memset(a,0,sizeof(a))
using namespace std;
int a[Z];
int b[Z];
int cnt[K];
int getmax(const int n)
{
  int i,p=1,sum=10;
  FORZ(i,1,n)
  {
      while(a[i]>=sum)
      {
        sum*=10;
      p++;    
    }
  }
  return p;
}
void JS_sort(const int n)
{
  int i,j,k,l,o,p,u;
  int wei=getmax(n);
  int ord=1; 
  FORZ(k,1,wei)
  {
      M0(cnt);
      FORZ(i,1,n)
    {
      u=a[i]/ord%10;
      cnt[u]++;
    }
    FORZ(i,1,9)
    {
      cnt[i]+=cnt[i-1];
    }
    //滚包裹
    FORJ(i,n,1)
    {
      u=a[i]/ord%10;
      b[cnt[u]]=a[i];
      cnt[u]--;
    }
    FORZ(i,1,n)
    {
      a[i]=b[i];
    }
    ord*=10;
  }
}
int main()
{
  int n,i,j,k,l,u,o,p; 
  scanf("%d",&n);
  FORZ(i,1,n)scanf("%d",&a[i]);
  JS_sort(n);
  FORZ(i,1,n)printf("%d ",a[i]);
}

13.最不值得一提的sort(不建议，毕竟这是一道模版题)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[100010];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    sort(a+1,a+1+n);
    for(int i=1;i<n;i++)
        cout<<a[i]<<" ";
    cout<<a[n]<<endl;
    return 0;
}