排序专题

一些知识点：

常见的 n^2 的排序算法有：冒泡排序，选择排序，交换排序

常见的 nlogn 的排序算法有：归并排序（稳定排序），快速排序，堆排序，利用AVL 排序

代码实现：

冒泡排序（稳定排序）：

/****************************************
* File Name: bubble_sort.cpp
* Author: sky0917
* Created Time: 2014年04月 2日 20:16:56
****************************************/
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 1001;

int a[maxn];
int main(){
    int n;
    while (scanf("%d",&n)!=EOF){
        for (int i=0; i<n; i++){
            scanf("%d",&a[i]);
        }
        for (int i=0; i<n; i++){
            for (int j=0; j<n-1; j++){
                if (a[j] > a[j+1]){
                    swap(a[j], a[j+1]);
                }    
            }
        }
        for (int i=0; i<n; i++){
            printf("%d
",a[i]);
        }
    }
    return 0;
}

选择排序（不稳定排序）：

/****************************************
* File Name: select_sort.cpp
* Author: sky0917
* Created Time: 2014年04月 2日 20:31:51
****************************************/
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1002;

int a[maxn];
int main(){
    int n; 
    while (scanf("%d",&n)!=EOF){
        for (int i=0; i<n; i++){
            scanf("%d",&a[i]);
        }
        
        for (int i=0; i<n; i++){
            int g = i;
            for (int j=i+1; j<n; j++){
                if (a[j] < a[g]){
                    g = j;
                }
            }
            swap(a[i], a[g]);
        }
        for (int i=0; i<n; i++){
            printf("%d
",a[i]);
        }
    }    
    return 0;
}

举个例子，序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法

归并排序（稳定排序）：

/****************************************
* File Name: merge_sort.cpp
* Author: sky0917
* Created Time: 2014年04月24日 21:50:42
****************************************/
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100005;

int a[maxn];
int b[maxn];
void merge_sort(int a[], int l, int r){
    if (l >= r)return;
    if (l + 1 == r){
        if (a[l] > a[r]) 
            swap(a[l], a[r]);
        return;
    }    
    int m = (l + r) / 2;
    merge_sort(a, l, m);
    merge_sort(a, m+1, r);
    int tl=l, tr = m+1;    
    int tp = 0;
    while (tl <= m && tr <= r){
        if (a[tl] <= a[tr])
            b[tp++] = a[tl++];
        else b[tp++] = a[tr++];    
    }    
    while (tl <= m)
        b[tp++] = a[tl++];
    while (tr <= r)
        b[tp++] = a[tr++];
    for (int i=0; i<tp; i++){
        a[l+i] = b[i];
    }
}
int main(){
    int n;
    while (scanf("%d",&n)!=EOF){
        for (int i=0; i<n; i++){
            scanf("%d",&a[i]);
        }
        merge_sort(a,  0, n-1);
        for (int i=0; i<n; i++)
            printf("%d%c",a[i],i==n-1?'
':' ');
    }    
    return 0;
}

快速排序（不稳定排序）：

/****************************************
* File Name: quick_sort.cpp
* Author: sky0917
* Created Time: 2014年04月24日 20:17:44
****************************************/
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100005;

int a[maxn];

int getmid(int a[], int l, int r){
    int x = a[r];
    int mid = l;
    for (int i=l; i<r; i++){
        if (a[i] < x){
            swap(a[mid], a[i]);
            mid++;    
        }
    }
    swap(a[mid], a[r]);
    return mid;
}

void quick_sort(int a[], int l, int r){
    if (l >= r) return;
    int m = getmid(a, l, r);
        quick_sort(a, l, m-1);
        quick_sort(a, m+1, r);
}
int main(){
    int n;
    while (scanf("%d",&n)!=EOF){
        for (int i=1; i<=n; i++){
            scanf("%d",&a[i]);
        }
        quick_sort(a, 1, n);
        for (int i=1; i<=n; i++){
            printf("%d%c",a[i],i==n?'
':' ');
        }
    }    
    return 0;
}

堆排序（不稳定排序）：

/****************************************
* File Name: heap_sort.cpp
* Author: sky0917
* Created Time: 2014年04月24日 20:04:35
****************************************/
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100005;

int a[maxn];
void down(int i, int n){
    for (int son; i <= n/2; i = son){
        son = i<<1;
        if ((son != n) && (a[son+1] > a[son]))
            son = son + 1;
        if (a[son] > a[i])
            swap(a[son], a[i]);
    }
}
void heap_sort(int a[], int n){
    for (int i=n/2; i>=1; i--){
        down(i, n);
    }
    for (int i=n; i>=1; i--){
        swap(a[1], a[i]);
        down(1, i-1);
    }
}

int main(){
    int n;
    while (scanf("%d",&n)!=EOF){
        for (int i=1; i<=n; i++){
            scanf("%d",&a[i]);
        }
        heap_sort(a, n);
        for (int i=1; i<=n; i++){
            printf("%d%c",a[i],i==n?'
':' ');
        }
    }    
    return 0;
}

基数排序（稳定排序）： 其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。

/****************************************
* File Name: bucket_sort.cpp
* Author: sky0917
* Created Time: 2014年04月24日 22:09:35
****************************************/
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 100005;

int a[maxn];
int s[10][maxn];
int tp[10];

void bucket_sort(int a[], int n){
    memset(tp, 0, sizeof(tp));
    int k = 0, w = 1;
    int max_val = 1000000;
    while (w < max_val){
        for (int i=0; i<n; i++){
            int ls = (a[i] / w) % 10;
            s[ls][tp[ls]++] = a[i];    
        }
        for (int i=0; i<10; i++){
            if (tp[i]){
                for (int j=0; j<tp[i]; j++){
                    a[k++] = s[i][j];
                }
                tp[i] = 0;
            }
        }
        k = 0, w *= 10;
    }
}
int main(){
    int n;
    while (scanf("%d",&n)!=EOF){
        for (int i=0; i<n; i++)
            scanf("%d",&a[i]);
        bucket_sort(a, n);
        for (int i=0; i<n; i++){
            printf("%d%c",a[i],i==n-1?'
':' ');
        }
    }
    return 0;
}