八种排序

1、计数排序 稳定 n+maxn
2、冒泡排序 稳定 n^2
3、选择排序 不稳 n^2
4、插入排序 稳定 n^2
5、基数排序 稳定 P+n
6、快速排序 不稳 n log （n） 退化(n^2)
7、归并排序 稳定 n log n
8、堆排序 不稳定 n log n

注：以下代码均为从小到大排序

一、计数排序

void Sort(){
    int cnt[1005],B[1005];
    for(int i=1;i<=n;i++)cnt[A[i]]++;
    for(int i=0;i<=100;i++)cnt[i]+=cnt[i-1];
    for(int i=n;i>=1;i--)B[cnt[A[i]]--]=A[i];
    for(int i=1;i<=n;i++)A[i]=B[i];
}

复杂度对于元素大小小，密集的比较好用；对于数据特别大的则会很慢。
需要多余的空间来辅助计算，数太大空间就不够了。

二、冒泡排序

void Sort(){
    for(int i=1;i<n;i++)
        for(int j=1;j<n-i+1;j++)
            if(A[j]>A[j+1])swap(A[j],A[j+1]);
}

不断地交换，每次求出一个最值。
冒泡可以用来求逆序对，但是O(n^2)太慢了，有更快的方法。

三、选择排序

void Sort(){
    for(int i=1;i<=n;i++){
        int x=i;
        for(int j=i+1;j<=n;j++)if(A[x]>A[j])x=j;
        swap(A[x],A[i]);
    }
}

每次找出一个最值，和当前位置交换。
和冒泡一模一样。

四、插入排序

void Sort(){//插入  稳  n^2 
    for(int i=1;i<=n;i++){
        int j,x=A[i];
        for(j=i-1;j>=1&&A[j]>x;j--)A[j+1]=A[j];
        A[j+1]=x;
    }
}

每次进来一个值，把比他大的后移，直到一个数比他小。
类似于生活当中的排队，一个一个插入到队伍里去

五、基数排序

void Sort(){
    int P=(1<<16)-1;
    int cnt[P+5],B[1005];
    for(int i=1;i<=n;i++)cnt[A[i]&P]++;
    for(int i=1;i<=P+1;i++)cnt[i]+=cnt[i-1];
    for(int i=n;i>=1;i--)B[cnt[A[i]&P]--]=A[i];
    for(int i=1;i<=n;i++)cnt[(B[i]>>16)&P]++;
    for(int i=1;i<=P+1;i++)cnt[i]+=cnt[i-1];
    for(int i=n;i>=1;i--)A[cnt[(B[i]>>16)&P]--]=B[i];
}

计数排序的基础上弄的。复杂度固定就是n+P
想法就是计数排序，分两次，一个数分两半，P就是int(2^32-1)的一半(2^16-1)

六、快速排序

void Sort(int l,int r){
    if(l>=r)return;
    int x=rand()%(r-l+1)+l;
    swap(A[l],A[x]);
    int tmp=A[l];
    int i=l,j=r;
    while(i<j){
        while(i<j&&tmp<A[j])j--;
        if(i<j)A[i]=A[j],i++;else break;
        while(i<j&&tmp>A[i])i++;
        if(i<j)A[j]=A[i],j--;else break;
    }
    A[i]=tmp;
    Sort(l,i-1);Sort(i+1,r);
}

这是快排的递归段，引用就Sort(1,n)即可。
每次确定一个数的位置，然后分成两半往下递归。
若是不加rand，那么如果是递减序列，就会退化成n^2。

七、归并排序

void Sort(int l,int r){
    if(l>=r)return;
    int mid=(l+r)/2;
    Sort(l,mid);Sort(mid+1,r);
    int B[1005];
    int i=l,j=mid+1,k=l;
    while(i<=mid&&j<=r)if(A[i]>A[j])B[k++]=A[j++];else B[k++]=A[i++];
    while(i<=mid)B[k++]=A[i++];
    while(j<=r)B[k++]=A[j++];
    for(int i=l;i<=r;i++)A[i]=B[i];
}

和快排一样，一半一半排序，然后合起来。这样的话就是真的n log n，但是常数有点大。需要额外空间来过渡。
这是求逆序对的另一种方式，只要在合并短加一些东西即可，比冒泡快。

八、堆排序

void down(int p){
    while(2 *p<=n){
        int t=2*p;
        if(t+1<=n&&A[t+1]<A[t])t++;
        if(A[p]<A[t])break;
        swap(A[p],A[t]);
        p=t;
    }
}
int top(){return A[1];}
void pop(){
    A[1]=A[n--];
    down(1);
}
void sort(int n){
    for(int i=n/2;i>=1;i--)down(i);
    int m=n;
    for(int i=1;i<=m;i++){printf("%d ",top());pop();}
}

小顶堆，模拟优先级队列，用树的形式。
可以仿照这个来写手打堆

排序作为信息学竞赛最基础的东西，这八种是必要的。不能只用sort。