桶排序，计数排序算法

计数排序：

桶排序：www.roading.org/algorithm/introductiontoalgorithm

算法模型：

1，桶排序假设待排的一组数统一分布在一个范围[m....n]，将这一范围划分为几个子范围，也就是桶bucket。

　　例如，如何将0---999范围的数，划分到10个桶中？范围中数的个数用K表示，那么K/10=1000/10=100，就是每个桶装100个元素，即[0..99]装到第一个桶中，[100..199]装到第二个桶中，。。。以此类推。

　　怎么判断一个数组该放到哪个桶中呢？例如整形元素a[i]=342，a[i]/100=342/100=3，就是说342得放到第（3+1）=4桶中

2，将待排序的一组数，分别放到这些子桶中。（可以采用插入排序的过程，在放入桶的过程中进行排序;也可以分配好后，利用stdlib.h中的qsort函数进行快速排序）;

3，最后将各个桶中的数据有序的合并起来。

时间复杂度分析：https://www.byvoid.com/blog/sort-radix

对于整数序列A，元素的最小值不小于0，最大值不大于K。假设我们由M个桶，第i个桶Bucket[i]存储的i*K/M~(i+1)*K/M之间的数字。

如果数据是期望平均分配的，则每个桶中的元素平均个数就N/M。

　　如果对每个桶中的元素采用快速排序，每次排序的的复杂度为O(N/M *  log(N/M))。

则总的时间复杂度为O(N)+O(M)*O(N/M *  log(N/M)) = O(N + Nlog(N/M)) = O(N+NlogN - NlogM)，就是说M越接近N时，桶排序的时间复杂度就可近似认为是O(N)。这时桶的数量也就越多。

//伪代码
Bucket-Sort(A)
    let B[0..n-1] be a new array
    n = A.lenghtS
    for i = 0 to n - 1
        make B[i] an empty list
    for i = 1 to n 
        insert A[i] into list B[nA[i]]
    for i = 0 to n - 1
        sort list B[i] with insertion sort
    concatenate the lists B[0], B[1]....B[n - 1] togather in order

　　来自https://zh.wikipedia.org/wiki/%E6%A1%B6%E6%8E%92%E5%BA%8F

class A{
public：
 ///
    const int BUCKET_NUM = 10;
    ListNode *insert(ListNode *head, int val){
        ListNode dummyNode(-1);
        ListNode *newNode = new ListNode(val);
        ListNode *prev,*curr;
        dummyNode.next = head;
        prev = &dummyNode;
        curr = head;
        while(curr && curr->val <= val){
            prev = curr;
            curr = curr->next;
        }///find location to insert; prev->next
        newNode->next = curr;
        prev->next = newNode;
        return dummyNode.next;
    }

    ListNode *mergebucket(ListNode *head1,ListNode *head2){
        ListNode dummy(-1);
        ListNode *h = &dummy;
        while(head1 && head2){
            if(head1->val <= head2->val){
                h->next = head1;
                head1 = head1->next;
            }else{
                h->next = head2;
                head2 = head2->next;
            }
            h = h->next;
        }
        if(head1) h->next = head1;
        if(head2) h->next = head2;
        return dummy.next;
    }

    void BucketSort(int n,int arr[]){
        vector<ListNode*> buckets(BUCKET_NUM,nullptr);
        for(int i = 0;i<n;i++){
            int index = arr[i]%BUCKET_NUM;
            ListNode *head = buckets[index];
            buckets[index] = insert(head,arr[i]);
        }///
        ListNode *head = buckets[0];
        for(int i = 1;i<BUCKET_NUM;i++){
            head = mergebucket(head,buckets[i]);
        }

        for(int i = 0;i<n;i++){
            arr[i] = head->val;
            head = head->next;
        }
    }///

    void test(ListNode *head){
        int *a = new int[15];
        for(int i = 0;i<15;i++){
            a[i] = rand()%15+1;
        }
        for(int i = 0;i<15;i++){
            cout<<a[i]<<" ";
        }cout<<endl;
        BucketSort(15,a);
        for(int i = 0;i<15;i++){
            cout<<a[i]<<" ";
        }cout<<endl;
    }
};

基数排序

基数排序(Radix Sort)。计数排序和桶排序都只是在研究一个关键字的排序，现在我们来讨论有多个关键字的排序问题。

假设我们有一些二元组(a,b)，要对它们进行以a为首要关键字，b的次要关键字的排序。我们可以先把它们先按照首要关键字排序，分成首要关键字相 同的若干堆。然后，在按照次要关键值分别对每一堆进行单独排序。最后再把这些堆串连到一起，使首要关键字较小的一堆排在上面。按这种方式的基数排序称为MSD(Most Significant Dight)排序。

第二种方式是从最低有效关键字开始排序，称为LSD(Least Significant Dight)排序。首先对所有的数据按照次要关键字排序，然后对所有的数据按照首要关键字排序。要注意的是，使用的排序算法必须是稳定的，否则就会取消前一次排序的结果。由于不需要分堆对每堆单独排序，LSD方法往往比MSD简单而开销小。下文介绍的方法全部是基于LSD的。

通常计数排序要用到计数排序或桶排序。

下面利用桶排序 对  二元组进行 基数排序。