桶排序(BucketSort)

桶排序思想

桶排序的思想就是把数组分到有限的桶中，然后再分别排序，最后将各个桶中的数据有序的合起来，具体如下：

（1）设计好桶的大小和桶的个数

（2）遍历数组，把每个元素放到对应的桶中

（3）对每个桶分别排序（可以递归使用桶排序，也可以使用其它排序）

（4）遍历桶中的数据，将数据有效的合起来

复杂度

桶排序利用函数映射关系，较少了几乎所有的比较操作。把大量数据分割成了基本有效的数据块，然后只需要对桶中的少量数据做先进的比较排序。

对 n 个关键字进行桶排序的时间复杂度分为两部分：

1、循环计算每个关键字的桶映射函数，这个时间复杂度是O(n).

2、利用比较先进的比较排序算法，对每个桶中的数据进行排序，其时间复杂度是∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。

很显然，第(2)部分是桶排序性能好坏的决定因素。基于比较排序的最好平均时间复杂度只能达到O(N*logN)，所以应该尽可能较少每个桶内数据的数量。

映射函数f(k)能够将N个数据平均的分配到M个桶中，这样每个桶就有[N/M]个数据量。

所以尽量的增大桶的数量，极限情况下每个桶只能得到一个数据，这样就完全避开了桶内数据的“比较”排序操作。这就是一种空间换时间的策略。

总结

对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：

　　O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)

当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。

桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM).

空间复杂度O(N+M）,如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。

此外，桶排序是稳定的

代码实现

简易版

#include<stdio.h>
#include<algorithm>
#include<vector>
using namespace std;

const int bucket_num = 10;    //桶的数量
const int interval = 10;    //桶的容量
const int maxn = 100 + 10;        //数字的最大值
vector<int>buckets[bucket_num];    //每个桶

void BucketSort(int *arr, int n)
{
    for (int i = 0; i < n; i++)
        buckets[arr[i] / interval].push_back(arr[i]);
    for (int i = 0; i < bucket_num; i++)  if (buckets[i].size())
        sort(buckets[i].begin(), buckets[i].end());
    for (int i = 0; i < bucket_num; i++)  if (buckets[i].size())
        for (int j = 0; j < buckets[i].size(); j++)
            printf("%d ", buckets[i][j]);
    printf("
");
}

int main()
{
    int n, arr[maxn];
    printf("数组大小：");
    scanf("%d", &n);
    printf("数组：");
    for (int i = 0; i < n; i++)  scanf("%d", &arr[i]);
    BucketSort(arr, n);
    
    return 0;
}

详细版

#include<stdio.h>
#include<stdlib.h>

const int  NARRAY = 50 + 5;  /* array size */
const int NBUCKET = 5; /* bucket size */
const int INTERVAL = 10; /* bucket range */

struct Node
{
    int data;
    struct Node *next;
};

void BucketSort(int arr[],int n);
struct Node *InsertionSort(struct Node *list);
void print(int arr[],int n);
void printBuckets(struct Node *list);
int getBucketIndex(int value);

void BucketSort(int arr[],int n)
{
    struct Node **buckets;

    /* allocate memory for array of pointers to the buckets */
    buckets = (struct Node **)malloc(sizeof(struct Node*) * NBUCKET);

    /* initialize pointers to the buckets */
    for (int i = 0; i < NBUCKET; ++i) {
        buckets[i] = NULL;
    }

    /* put items into the buckets，like insert from the head */
    for (int i = 0; i < n; ++i) {
        struct Node *current;
        int pos = getBucketIndex(arr[i]);
        current = (struct Node *) malloc(sizeof(struct Node));
        current->data = arr[i];
        current->next = buckets[pos];
        buckets[pos] = current;
    }

    /* check what's in each bucket */
    for (int i = 0; i < NBUCKET; i++) {
        printf("Bucket[%d] : ", i);
        printBuckets(buckets[i]);
    }

    /* sorting bucket using Insertion Sort */
    for (int i = 0; i < NBUCKET; ++i) {
        buckets[i] = InsertionSort(buckets[i]);
    }

    /* check what's in each bucket */
    
    printf("-------------
");
    printf("Bucktets after sorted
");

    for (int i = 0; i < NBUCKET; i++) {
        printf("Bucket[%d] : ", i);
        printBuckets(buckets[i]);
    }

    /* put items back to original array */
    for (int j = 0, i = 0; i < NBUCKET; ++i) {
        struct Node *node;
        node = buckets[i];
        while (node) {
            arr[j++] = node->data;
            node = node->next;
        }
    }

    /* free memory */
    for (int i = 0; i < NBUCKET; ++i) {
        struct Node *node;
        node = buckets[i];
        while (node) {
            struct Node *tmp;
            tmp = node;
            node = node->next;
            free(tmp);
        }
    }
    free(buckets);
    return;
}

/* Insertion Sort */
struct Node *InsertionSort(struct Node *list)  //list as head pionter
{
    struct Node *k, *nodeList;
    /* need at least two items to sort */
    if (list == 0 || list->next == 0) {
        return list;
    }

    nodeList = list;
    k = list->next;
    nodeList->next = 0; /* 1st node is new list */
    while (k != 0) {
        struct Node *ptr;
        /* check if insert before first */
        if (nodeList->data > k->data) {
            struct Node *tmp;    //swap(k,nodeList)
            tmp = k;
            k = k->next;
            tmp->next = nodeList;
            nodeList = tmp;
            continue;
        }

        for (ptr = nodeList; ptr->next != 0; ptr = ptr->next) {
            if (ptr->next->data > k->data) break;
        }

        if (ptr->next != NULL) {  //if isn`t tail node,swap
            struct Node *tmp;
            tmp = k;
            k = k->next;
            tmp->next = ptr->next;
            ptr->next = tmp;
            continue;
        }
        else {                    //if isn tail node,insert at the tail
            ptr->next = k;
            k = k->next;
            ptr->next->next = 0;
            continue;
        }
    }
    return nodeList;
}

int getBucketIndex(int value)
{
    return value / INTERVAL;
}

void print(int arr[],int n)
{
    for (int i = 0; i < n; ++i) {
        printf("%3d",arr[i]);
    }
    printf("
");
}

void printBuckets(struct Node *list)
{
    struct Node *cur = list;
    while (cur) {
        printf("%3d", cur->data);
        cur = cur->next;
    }
    printf("
");
}

int main()
{
    int n, array[NARRAY];
    printf("数组大小:");
    scanf("%d", &n);        //less than NBUCKET*INTERVAL
    printf("数组：");
    for (int i = 0; i < n; i++)  scanf("%d", &array[i]);

    printf("Initial array
");
    print(array,n);
    printf("-------------
");

    BucketSort(array,n);
    printf("-------------
");
    printf("Sorted array
");
    print(array,n);

    return 0;
}

 参考链接：

https://baike.baidu.com/item/桶排序/4973777

https://blog.csdn.net/u012194956/article/details/79887143