以下是桶排序的详细解析，包含基础实现、常见变体的完整代码示例，以及各变体的对比表格：
一、桶排序基础实现
原理
将数据分到有限数量的桶中，每个桶内部使用其他排序算法（如插入排序或快速排序），最后合并所有桶的结果。
代码示例
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. 自适应桶排序（动态桶大小）
改进点：根据数据分布动态调整桶的大小，减少极端分布的影响。
适用场景：数据分布不均匀时。
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. 分布式桶排序
改进点：利用多线程对多个桶并行排序。
适用场景：大数据或分布式计算环境。
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. 基于链表的桶排序
改进点：用链表存储桶中的元素，避免动态扩容开销。
适用场景：频繁插入/删除元素的场景。
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) | 不稳定 | 链表存储减少扩容开销，桶内排序可选算法 | 需频繁插入/删除或对内存敏感场景 |
四、关键选择原则
- 基础场景：优先使用基础桶排序，因其简单且适合均匀分布数据。
- 数据分布不均匀：自适应桶排序通过动态调整桶大小，减少极端情况的影响。
- 性能优化：分布式版本利用多线程加速，适合大数据或并行环境。
- 内存效率：链表桶排序减少动态扩容开销，但需注意桶内排序算法的稳定性。
- 稳定性需求：若需稳定排序，避免使用链表桶排序（若桶内使用快速排序等不稳定算法）。
通过选择合适的变体，可在特定场景下优化性能或适应数据特性。例如，自适应桶排序解决数据分布问题，而分布式版本提升处理超大数据的效率。
