Java算法之桶排序Bucket Sort详解

 更新时间:2023年10月31日 08:36:58   作者:Kant101  
这篇文章主要介绍了Java算法之桶排序Bucket Sort详解,桶排序(Bucket Sort)又称箱排序,是一种比较常用的排序算法,其算法原理是将数组分到有限数量的桶里,再对每个桶分别排好序,最后一次将每个桶中排好序的数输出,需要的朋友可以参考下

1. 概述

桶排序(Bucket Sort)又称箱排序,是一种比较常用的排序算法。其算法原理是将数组分到有限数量的桶里,再对每个桶分别排好序(可以是递归使用桶排序,也可以是使用其他排序算法将每个桶分别排好序),最后一次将每个桶中排好序的数输出。

2. 算法详解

桶排序的思想就是把待排序的数尽量均匀地放到各个桶中,再对各个桶进行局部的排序,最后再按序将各个桶中的数输出,即可得到排好序的数。

1.首先确定桶的个数。因为桶排序最好是将数据均匀地分散在各个桶中,那么桶的个数最好是应该根据数据的分散情况来确定。首先找出所有数据中的最大值mx和最小值mn;

根据mx和mn确定每个桶所装的数据的范围 size,有 size = (mx - mn) / n + 1,n为数据的个数,需要保证至少有一个桶,故而需要加个1;

求得了size即知道了每个桶所装数据的范围,还需要计算出所需的桶的个数cnt,有 cnt = (mx - mn) / size + 1,需要保证每个桶至少要能装1个数,故而需要加个1;

2.求得了size和cnt后,即可知第一个桶装的数据范围为 [mn, mn + size),第二个桶为 [mn + size, mn + 2 * size),…,以此类推 因此步骤2中需要再扫描一遍数组,将待排序的各个数放进对应的桶中。

3.对各个桶中的数据进行排序,可以使用其他的排序算法排序,例如快速排序;也可以递归使用桶排序进行排序;

4.将各个桶中排好序的数据依次输出,最后得到的数据即为最终有序。

例子

例如,待排序的数为:3, 6, 9, 1

1)求得 mx = 9,mn = 1,n = 4 size = (9 - 1) / n + 1 = 3 cnt = (mx - mn) / size + 1 = 3

2)由上面的步骤可知,共3个桶,每个桶能放3个数,第一个桶数的范围为 [1, 4),第二个[4, 7),第三个[7, 10) 扫描一遍待排序的数,将各个数放到其对应的桶中,放完后如下图所示:

3)对各个桶中的数进行排序,得到如下图所示:

4)依次输出各个排好序的桶中的数据,即为:1, 3, 6, 9 可见,最终得到了有序的排列。

3. 测试

JAVA

import java.util.ArrayList;

/**
 * @author yumu
 * @date 2022/8/25
 */
public class BucketSort {

    public void bucketSort(int[] nums) {
        int n = nums.length;
        int mn = nums[0], mx = nums[0];
        // 找出数组中的最大最小值
        for (int i = 1; i < n; i++) {
            mn = Math.min(mn, nums[i]);
            mx = Math.max(mx, nums[i]);
        }
        int size = (mx - mn) / n + 1; // 每个桶存储数的范围大小,使得数尽量均匀地分布在各个桶中,保证最少存储一个
        int cnt = (mx - mn) / size + 1; // 桶的个数,保证桶的个数至少为1
        List<Integer>[] buckets = new List[cnt]; // 声明cnt个桶
        for (int i = 0; i < cnt; i++) {
            buckets[i] = new ArrayList<>();
        }
        // 扫描一遍数组,将数放进桶里
        for (int i = 0; i < n; i++) {
            int idx = (nums[i] - mn) / size;
            buckets[idx].add(nums[i]);
        }
        // 对各个桶中的数进行排序,这里用库函数快速排序
        for (int i = 0; i < cnt; i++) {
            buckets[i].sort(null); // 默认是按从小打到排序
        }
        // 依次将各个桶中的数据放入返回数组中
        int index = 0;
        for (int i = 0; i < cnt; i++) {
            for (int j = 0; j < buckets[i].size(); j++) {
                nums[index++] = buckets[i].get(j);
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {19, 27, 35, 43, 31, 22, 54, 66, 78};
        BucketSort bucketSort = new BucketSort();
        bucketSort.bucketSort(nums);
        for (int num: nums) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

C++

#include <iostream>
#include <vector>

using namespace std;

class BucketSort {
public:
    void bucketSort(vector<int> &nums) {
        int n = nums.size();
        int mn = nums[0], mx = nums[0];
        for (int i = 1; i < n; i++) {
            mn = min(mn, nums[i]);
            mx = max(mx, nums[i]);
        }
        int size = (mx - mn) / n + 1;   // size 至少要为1
        int cnt = (mx - mn) / size + 1; // 桶的个数至少要为1
        vector<vector<int>> buckets(cnt);
        for (int i = 0; i < n; i++) {
            int idx = (nums[i] - mn) / size;
            buckets[idx].push_back(nums[i]);
        }
        for (int i = 0; i < cnt; i++) {
            sort(buckets[i].begin(), buckets[i].end());
        }
        int index = 0;
        for (int i = 0; i < cnt; i++) {
            for (int j = 0; j < buckets[i].size(); j++) {
                nums[index++] = buckets[i][j];
            }
        }
    }
};


int main() {
    vector<int> nums = {19, 27, 35, 43, 31, 22, 54, 66, 78};
    BucketSort().bucketSort(nums);
    for (auto num: nums) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

4. 时间复杂度和空间复杂度分析

最好时间复杂度 : O(n + k) 其中k为桶的个数。即当数据是均匀分散排列的,那么每个桶分到的数据个数都是一样的,这个步骤需要O(k)的书剑复杂度,在对每个桶进行排序的时候,最好情况下是数据都已经是有序的了,那么最好的排序算法的时间复杂度会是O(n),因此总的时间复杂度是 O(n + k) 。

最坏时间复杂度:O(n^2) 当对每个桶中的数据进行排序的时候,所使用的排序算法,最坏情况下是O(n^2),因此总的最坏情况下的时间复杂度为O(n^2)。

平均时间复杂度:O(n + n²/k + k) <=> O(n) 如果k是根据Θ(n)来获取的,那么平均时间复杂度就是 O(n)。

到此这篇关于Java算法之桶排序Bucket Sort详解的文章就介绍到这了,更多相关Java桶排序Bucket Sort内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • 基于Process#waitFor()阻塞问题的解决

    基于Process#waitFor()阻塞问题的解决

    这篇文章主要介绍了Process#waitFor()阻塞问题的解决,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-12-12
  • Java微服务的打包问题解决

    Java微服务的打包问题解决

    本文主要介绍了Java微服务的打包问题解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2023-06-06
  • SpringSecurity OAuth2单点登录和登出的实现

    SpringSecurity OAuth2单点登录和登出的实现

    本文主要介绍了SpringSecurity OAuth2单点登录和登出的实现,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-02-02
  • Eclipse+Java+Swing实现图书管理系统(详细代码)

    Eclipse+Java+Swing实现图书管理系统(详细代码)

    这篇文章主要介绍了Eclipse+Java+Swing实现图书管理系统并附上详细代码,需要的小伙伴可以参考一下,希望对你有所帮助
    2022-01-01
  • java8中parallelStream性能测试及结果分析

    java8中parallelStream性能测试及结果分析

    本篇文章给大家用代码实例做了segmentfaultjava8中parallelStream性能测试,并对测试结果做了说明,需要的朋友学习下吧。
    2018-01-01
  • java实现插入排序算法

    java实现插入排序算法

    插入排序算法是一个对少量元素进行排序的有效算法。插入排序的工作原理与打牌时整理手中的牌的做法类似,开始摸牌时,我们的左手是空的,接着一次从桌上摸起一张牌,并将它插入到左手的正确位置。
    2015-04-04
  • 详解springboot解决第三方依赖jar包的问题

    详解springboot解决第三方依赖jar包的问题

    本篇文章主要介绍了详解springboot解决第三方依赖jar包的问题,解决了第三方依赖jar包的问题,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-09-09
  • 深入学习Java中的SPI机制

    深入学习Java中的SPI机制

    这篇文章主要介绍了深入学习Java中的SPI机制,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-09-09
  • 深入解析Java中的JDBC事务

    深入解析Java中的JDBC事务

    这篇文章主要介绍了深入解析Java中的JDBC事务,包含了Java多线程的事务并发等知识,需要的朋友可以参考下
    2015-08-08
  • JAVA中通过Hibernate-Validation进行参数验证

    JAVA中通过Hibernate-Validation进行参数验证

    这篇文章主要介绍了JAVA中通过Hibernate-Validation进行参数验证,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-04-04

最新评论