桶排序

桶排序：

桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序。

时间复杂度： O(N) + 每个桶中所用排序方法的时间复杂度 * 桶个数

空间复杂度： O(N) + 每个桶中所用排序方法的空间复杂度 * 桶个数

应用：一年的全国高考考生人数为500 万，分数使用标准分，最低100 ，最高900 ，没有小数，你把这500 万元素的数组排个序。

方法：分成8个桶，桶(1)的分数范围是100-199，桶(2)的分数范围是200-299，以此类推。然后对每个桶进行快速排序。最后整合可得结果,其中桶中排序用链表版的快速排序

typedef struct Node{
    int val;
    struct Node *next, *pre;
}node;
node* root[81];
void add(node*r, int val){
    node* tmp = (node *)malloc(sizeof(node));
    tmp->pre = r;
    tmp->val = val;
    tmp->next = r->next;
    if(r->next != NULL)
        r->next->pre = tmp;
    r->next = tmp;
}
void qSort(node * head,node * tail){
    if(head == NULL || head == tail)
        return;
    node* le = head, * ri = tail;
    int p = head->val;
    while(le != ri){
        while(le != ri && ri->val > p)
            ri = ri->pre;
        if(le != ri){
            le->val = ri->val;
            le = le->next;
        }
        while(le != ri && le->val < p)
            le = le->next;
        if(le != ri){
            ri->val = le->val;
            ri = ri->pre;
        }
    }
    le->val = p;
    if(head != le)
        qSort(head,le->pre);
    if(le != tail)
        qSort(le->next,tail);
    
}
void bucketSort(int *a, int n){
    int i=0;
    for(i=0; i<81; i++){
        root[i] = (node*)malloc(sizeof(node));
        root[i]->next = root[i]->pre = NULL;
    }
    for(i=0; i<n; i++){
        add(root[a[i]/100-1],a[i]);
    }
    for(i=0; i<81; i++){
        node* tail;
        if(root[i]->next != NULL)
        for(tail=root[i]->next; tail->next != NULL; tail = tail->next);
        
        qSort(root[i]->next,tail);
    }
    
    int cnt=0;
    node *tmp;
    for(i=0; i<81; i++){
        for(tmp = root[i]->next; tmp != NULL; tmp = tmp->next){
            a[cnt++] = tmp->val;
        }
    }
}