排序算法-桶排序(bucketSort)-C

思路：

桶排序是计数排序的升级，计数排序可以理解为一个桶只能放同样大小的一个或多个值，因为不同桶存放的值是连续大小，这样如数组元素大小不连续就可能有多个桶是空的；而桶排序是一个桶可以存放一定范围大小的一个或多个值（比如，存放范围是10，那么大小再10以内的元素可能落在一个桶里面），然后再对每个桶里面里面的元素排序，最后从小到大将所以非空桶的元素输出。

基本步骤：

1. 计算输入数组的最大最小值，根据传入的桶的范围大小，计算桶的数量，并创建桶；
2. 根据映射函数，将输入数组中的每个元素映射到不同桶中；
3. 对每个非空桶中的元素进行排序；
4. 依次将非空桶中的元素输出到原始数组中。

时间复杂度：

最好：；平均：；最坏：

程序：

void insert_sort(int array[],int array_size)
{
    int i,j,tmp;
    for(i=1;i<array_size;i++)
    {
        tmp=array[i];
        for(j=i;j>0&&array[j-1]>tmp;j--)
            array[j]=array[j-1];
        array[j]=tmp;
    }
}

void find_min_max(int array[],int array_size,int *min,int *max)
{
    int min_p,max_p,i;
    min_p=0;
    max_p=array_size-1;
    for(i=0;i<array_size;i++)
    {
        if(array[i]<array[min_p])
            min_p=i;
        if(array[i]>array[max_p])
            max_p=i;
    }
    *min=array[min_p];
    *max=array[max_p];
}

struct bucket {
    int count;
    int *array;
};

struct bucket ** create_buckets(int bucket_count,int bucket_size)
{   
    int i; 
    struct bucket **buckets=calloc(bucket_count,sizeof(struct bucket *));
    if(buckets==NULL)
    {
        printf("No full space! \n");
        return NULL;
    }
    for(i=0;i<bucket_count;i++)
    {
        buckets[i]=calloc(1,sizeof(struct bucket));
        if(buckets[i]==NULL)
        {
            printf("No full space! \n");
            free(buckets);
            return NULL;
        }
        buckets[i]->count=0;
        buckets[i]->array=calloc(bucket_size,sizeof(int));
        if(buckets[i]->array==NULL)
        {
            printf("No full space! \n");
            free(buckets[i]);
            free(buckets);
            return NULL;
        }
    }
    return buckets;
}

void bucket_sort(int array[],int array_size,int bucket_interval)
{   
    if(array_size<2)
        return;
    int i,j,k, min,max,bucket_count,index;
    find_min_max(array, array_size, &min, &max);
    bucket_count=((max-min)/bucket_interval)+1;
    //step1. Create bucket_count empty  buckets
    struct bucket ** buckets=create_buckets(bucket_count,array_size);
    if(buckets==NULL)
    {
        printf("NULL pointer! \n");
        return;
    }
    //step2. Put array elements in differernt buckets
    for(i=0;i<array_size;i++)
    {
        index=(array[i]-min)/bucket_interval;
        buckets[index]->array[buckets[index]->count++]=array[i];
    }
    //step3. Sort individual buckets
    for(i=0;i<bucket_count;i++)
    {
        if(buckets[i]->count>=2)
        {
            insert_sort(buckets[i]->array,buckets[i]->count);
        }
    }
    //step4. Concatenate all buckets into  array[]
    k=0;
    for(i=0;i<bucket_count;i++)
    {
        for(j=0;j<buckets[i]->count;j++)
        {
            array[k++]=buckets[i]->array[j];
        }
    }
}

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

int main()
{
    int i;  
    int array[]={100,96,88,75,63,52,41,36,28,96,19,6,0,-19,-105,28,52,52,52};
    int array_size=sizeof(array)/sizeof(int);
    printf("Original array:\n");
    for(i=0;i<array_size;i++)
        printf(" %d, ",array[i]);
    printf("\n");
    bucket_sort(array,array_size,10);
    printf("Sorted array:\n");
    for(i=0;i<array_size;i++)
        printf(" %d, ",array[i]);
    printf("\n");
    return 0;
}

参考：

https://www.thecrazyprogrammer.com/2017/02/bucket-sort-in-c.html

https://stackoverflow.com/questions/27876525/array-bucket-sort-in-c

https://en.wikipedia.org/wiki/Bucket_sort

https://www.programiz.com/dsa/bucket-sort

https://www.geeksforgeeks.org/bucket-sort-2/

https://www.cnblogs.com/onepixel/articles/7674659.html

https://www.runoob.com/w3cnote/ten-sorting-algorithm.html