C语言---排序算法11---桶排序法

文章目录

• 算法步骤
• C语言实现代码
• 关键点说明
• 优化方向

桶排序（Bucket Sort）是一种分布式排序算法，适用于数据均匀分布在某个范围内的场景。其核心思想是将元素分配到有限数量的桶中，对每个桶单独排序（通常使用其他排序算法），最后合并所有桶的结果。

算法步骤

1、确定桶的数量和范围：根据数据范围和分布选择合适的桶数量。

2、分配元素到桶中：遍历数组，根据元素值将其放入对应的桶。

3、对每个桶排序：使用插入排序等简单算法对桶内元素排序。

4、合并桶：按顺序将桶中的元素合并回原数组。

C语言实现代码

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

// 定义桶的结构
typedef struct {
    int size;      // 桶中元素数量
    int capacity;  // 桶的容量
    int *array;    // 存储元素的数组
} Bucket;

// 创建新桶
Bucket* createBucket(int capacity) {
    Bucket *bucket = (Bucket*)malloc(sizeof(Bucket));
    bucket->size = 0;
    bucket->capacity = capacity;
    bucket->array = (int*)malloc(capacity * sizeof(int));
    return bucket;
}

// 向桶中添加元素
void addToBucket(Bucket *bucket, int value) {
    if (bucket->size < bucket->capacity) {
        bucket->array[bucket->size++] = value;
    }
}

// 对桶内元素排序（使用插入排序）
void sortBucket(Bucket *bucket) {
    for (int i = 1; i < bucket->size; i++) {
        int key = bucket->array[i];
        int j = i - 1;
        while (j >= 0 && bucket->array[j] > key) {
            bucket->array[j + 1] = bucket->array[j];
            j--;
        }
        bucket->array[j + 1] = key;
    }
}

// 桶排序主函数
void bucketSort(int arr[], int n, int bucketSize) {
    // 当序列长度小于等于1时，已有序
    if (n <= 1) return;

    // 1. 找到最大值和最小值
    int minVal = arr[0], maxVal = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] < minVal) minVal = arr[i];
        if (arr[i] > maxVal) maxVal = arr[i];
    }

    // 2. 计算桶的数量
    int bucketCount = (maxVal - minVal) / bucketSize + 1;
    Bucket **buckets = (Bucket**)malloc(bucketCount * sizeof(Bucket*));
    for (int i = 0; i < bucketCount; i++) {
        buckets[i] = createBucket(n); // 每个桶的容量设为n（足够大）
    }

    // 3. 分配元素到桶中
    for (int i = 0; i < n; i++) {
        int index = (arr[i] - minVal) / bucketSize;
        addToBucket(buckets[index], arr[i]);
    }

    // 4. 对每个桶排序并合并回原数组
    int idx = 0;
    for (int i = 0; i < bucketCount; i++) {
        sortBucket(buckets[i]);
        for (int j = 0; j < buckets[i]->size; j++) {
            arr[idx++] = buckets[i]->array[j];
        }
        free(buckets[i]->array);
        free(buckets[i]);
    }
    free(buckets);
}

// 测试代码
int main() {
    int arr[] = {3};
    int n = sizeof(arr) / sizeof(arr[0]);
    int bucketSize = 10; // 每个桶的范围大小

    printf("Original array: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);

    bucketSort(arr, n, bucketSize);

    printf("\nSorted array: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);

    return 0;
}

关键点说明

1、桶的数量和范围：

桶的数量通常根据数据范围和大小动态计算（如 (max-min)/bucketSize + 1）。

bucketSize 决定了每个桶的数值范围，需根据数据分布调整。

2、桶内排序：

示例中使用插入排序，适合小规模数据。也可替换为快速排序等更高效的算法。

优化方向

动态调整桶的数量以适应数据分布。

对非均匀数据，使用更复杂的哈希函数分配桶。

结合其他排序算法（如基数排序）处理桶内数据。