【java实现+4种变体完整例子】排序算法中【桶排序】的详细解析，包含基础实现、常见变体的完整代码示例，以及各变体的对比表格

以下是桶排序的详细解析，包含基础实现、常见变体的完整代码示例，以及各变体的对比表格：

一、桶排序基础实现

原理

将数据分到有限数量的桶中，每个桶内部使用其他排序算法（如插入排序或快速排序），最后合并所有桶的结果。

代码示例

java 复制代码

import java.util.ArrayList;
import java.util.List;

public class BucketSort {
    void sort(float[] arr) {
        if (arr.length == 0) return;

        // 创建桶（假设每个桶是一个ArrayList）
        int bucketCount = arr.length; // 桶的数量通常与元素数量相近
        List<ArrayList<Float>> buckets = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            buckets.add(new ArrayList<>());
        }

        // 将数据分配到桶中
        for (float num : arr) {
            int index = (int) Math.floor(num * bucketCount);
            buckets.get(index).add(num);
        }

        // 对每个桶进行排序（此处使用插入排序）
        for (ArrayList<Float> bucket : buckets) {
            insertionSort(bucket);
        }

        // 合并所有桶的结果到原数组
        int index = 0;
        for (ArrayList<Float> bucket : buckets) {
            for (float num : bucket) {
                arr[index++] = num;
            }
        }
    }

    // 插入排序用于桶内排序
    private void insertionSort(ArrayList<Float> list) {
        for (int i = 1; i < list.size(); i++) {
            float key = list.get(i);
            int j = i - 1;
            while (j >= 0 && list.get(j) > key) {
                list.set(j + 1, list.get(j));
                j--;
            }
            list.set(j + 1, key);
        }
    }
}

复杂度分析

时间复杂度 ：
- 平均：O(n + k)（k为桶的数量）。
- 最坏：O(n²)（数据分布极不均匀时，桶内排序退化）。
空间复杂度 ：O(n + k)。
稳定性：稳定（若桶内排序算法稳定）。

二、常见变体及代码示例

1. 自适应桶排序（动态桶大小）

改进点 ：根据数据分布动态调整桶的大小，减少极端分布的影响。
适用场景：数据分布不均匀时。

java 复制代码

import java.util.ArrayList;
import java.util.List;

public class AdaptiveBucketSort {
    void sort(float[] arr) {
        if (arr.length == 0) return;

        // 统计数据分布
        float min = Arrays.stream(arr).min().getAsFloat();
        float max = Arrays.stream(arr).max().getAsFloat();
        int bucketCount = arr.length;
        float bucketSize = (max - min) / bucketCount;

        List<ArrayList<Float>> buckets = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            buckets.add(new ArrayList<>());
        }

        // 动态分配到桶
        for (float num : arr) {
            int index = (int) ((num - min) / bucketSize);
            index = Math.min(index, bucketCount - 1); // 防止溢出
            buckets.get(index).add(num);
        }

        // 桶内排序并合并
        int index = 0;
        for (ArrayList<Float> bucket : buckets) {
            insertionSort(bucket);
            for (float num : bucket) {
                arr[index++] = num;
            }
        }
    }

    private void insertionSort(ArrayList<Float> list) {
        // 同基础版本的插入排序
    }
}

2. 分布式桶排序

改进点 ：利用多线程对多个桶并行排序。
适用场景：大数据或分布式计算环境。

java 复制代码

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ParallelBucketSort {
    void sort(float[] arr) {
        if (arr.length == 0) return;

        int bucketCount = arr.length;
        List<ArrayList<Float>> buckets = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            buckets.add(new ArrayList<>());
        }

        // 分配到桶
        for (float num : arr) {
            int index = (int) Math.floor(num * bucketCount);
            buckets.get(index).add(num);
        }

        // 并行排序每个桶
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        for (ArrayList<Float> bucket : buckets) {
            executor.submit(() -> insertionSort(bucket));
        }
        executor.shutdown();
        try {
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 合并结果
        int index = 0;
        for (ArrayList<Float> bucket : buckets) {
            for (float num : bucket) {
                arr[index++] = num;
            }
        }
    }

    private void insertionSort(ArrayList<Float> list) {
        // 同基础版本的插入排序
    }
}

3. 基于链表的桶排序

改进点 ：用链表存储桶中的元素，避免动态扩容开销。
适用场景：频繁插入/删除元素的场景。

java 复制代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LinkedListBucketSort {
    void sort(float[] arr) {
        if (arr.length == 0) return;

        int bucketCount = arr.length;
        List<LinkedList<Float>> buckets = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            buckets.add(new LinkedList<>());
        }

        // 分配到桶
        for (float num : arr) {
            int index = (int) Math.floor(num * bucketCount);
            buckets.get(index).add(num);
        }

        // 对每个桶排序（此处用快速排序）
        for (LinkedList<Float> bucket : buckets) {
            quickSort(bucket, 0, bucket.size() - 1);
        }

        // 合并结果
        int index = 0;
        for (LinkedList<Float> bucket : buckets) {
            for (float num : bucket) {
                arr[index++] = num;
            }
        }
    }

    private void quickSort(LinkedList<Float> list, int low, int high) {
        // 快速排序实现（略）
    }
}

三、变体对比表格

变体名称	时间复杂度	空间复杂度	稳定性	主要特点	适用场景
基础桶排序	`O(n + k)`（平均） `O(n²)`（最坏）	`O(n + k)`	稳定	简单实现，适用于均匀分布数据	值域均匀且数据量适中的场景
自适应桶排序	`O(n + k)`	`O(n + k)`	稳定	动态调整桶大小，适应不均匀分布	数据分布不均匀但需稳定性
分布式桶排序	`O(n/k + k)`（并行）	`O(n + k)`	稳定	并行加速，适合大数据或分布式系统	大数据集或高性能计算环境
基于链表的桶排序	`O(n + k)`	`O(n + k)`	不稳定	链表存储减少扩容开销，桶内排序可选算法	需频繁插入/删除或对内存敏感场景

四、关键选择原则

基础场景：优先使用基础桶排序，因其简单且适合均匀分布数据。
数据分布不均匀：自适应桶排序通过动态调整桶大小，减少极端情况的影响。
性能优化：分布式版本利用多线程加速，适合大数据或并行环境。
内存效率：链表桶排序减少动态扩容开销，但需注意桶内排序算法的稳定性。
稳定性需求：若需稳定排序，避免使用链表桶排序（若桶内使用快速排序等不稳定算法）。

通过选择合适的变体，可在特定场景下优化性能或适应数据特性。例如，自适应桶排序解决数据分布问题，而分布式版本提升处理超大数据的效率。