八種排序

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。