当前位置：首页 > backend >正文

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

backend 2025/5/19 23:42:45

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

一、桶排序基础实现

原理

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

代码示例

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)`	不稳定	链表存储减少扩容开销，桶内排序可选算法	需频繁插入/删除或对内存敏感场景