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