厚积薄发打卡Day95: 排序算法之映射排序＜桶排序＞

最新推荐文章于 2022-10-02 14:29:02 发布

coolgwayne

最新推荐文章于 2022-10-02 14:29:02 发布

阅读量379

点赞数

分类专栏：数据结构文章标签：排序算法算法

本文链接：https://blog.csdn.net/qq_42191980/article/details/121072100

版权

数据结构专栏收录该内容

27 篇文章 1 订阅

订阅专栏

本文介绍了桶排序算法的基本原理和实现方式，包括使用HashMap的桶结构存储数据以及如何通过分治策略进行排序。文章提供了两种实现示例，一种限制了数据范围，另一种则适用于更广泛的元素分布。桶排序是一种稳定的排序算法，其稳定性取决于桶内排序算法的选择。在测试案例中，展示了桶排序在大量随机数据上的效率。

摘要由CSDN通过智能技术生成

桶排序

在这里插入图片描述

概念：

参考：桶排序

桶排序(Bucket Sort)的原理很简单，它是将数组分到有限数量的桶子里。
1. 桶的结构：List<LinkedList<Integer>>，也就是Hash结构，是一种映射
2. Hashmap的储存也是用到了桶结构：
3. 在将数据放到桶中之后，再通过一定的算法，将桶中的数据提出来，并转换成有序数组。就得到我们想要的结果了

实现：

规定桶的数量为100后，随机数字的范围也被限制在了100

public class BucketSort {
    public  List<Integer> sort(List<Integer> A) {
        int k = 100;
        List<LinkedList<Integer>> buckets = new ArrayList<>();
        List<Integer> list = new ArrayList<>();

        for (int i = 0; i < k; i++) {
            buckets.add(new LinkedList<>());
        }

        for (Integer item : A) {
            buckets.get(item % k).add(item);
        }

        for (LinkedList<Integer> bucket : buckets) {
            list.addAll(bucket);
        }
        return list;
    }
}


//测试类：
@Test
public void test_bucketSort() {
    BucketSort bucketSort = new BucketSort();
    ArrayList<Integer> l = new ArrayList<>();

    for (int i = 0; i < 1000000; i++) {
        //超过100则需要对桶内元素进行排序
        l.add((int) (Math.random() * 100));
    }
    long start = System.currentTimeMillis();
    List<Integer> A = bucketSort.sort(l);
    System.out.println("time:" + (System.currentTimeMillis() - start));
    assertSorted(A);
}

此时能在桶内发现众多重复数据，但是因为是范围被限制住了；通过求模运算使得同一个桶内的数组都相同，因此不需要对桶进行排序：

在这里插入图片描述

假设没有限制范围：

在这里插入图片描述

推广至一般桶排序：

public class BucketSort {
    //A：集合。K:桶的数量 max:集合元素最大值 min：集合元素最小值
    public List<Integer> sort(List<Integer> A, int k, int max, int min) {
        List<LinkedList<Integer>> buckets = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        int D = max - min + 1;
        QuickSort quickSort = new QuickSort();
        for (int i = 0; i < k; i++) {
            buckets.add(new LinkedList<>());
        }
        // 放入桶中
        for (Integer item : A) {
            Integer key = (item - min) * k / D;
            buckets.get(key).add(item);
        }
        //从桶中取出值
        for (int i = 0; i < k; i++) {
            //借助快排对桶内元素进行排序
            list.addAll(quickSort.sort(buckets.get(i)));
        }
        return list;
    }
}
//测试类：
    @Test
    public void test_bucketSort1() {
        BucketSort1 bucketSort = new BucketSort1();
        ArrayList<Integer> l = new ArrayList<>();

        for (int i = 0; i < 1000000; i++) {
            l.add(100 + (int) (Math.random() * 1000));
        }
        long start = System.currentTimeMillis();
        List<Integer> A = bucketSort.sort(l, 10, 1100, 100);
        System.out.println("time:" + (System.currentTimeMillis() - start));
        assertSorted(A);
    }

小结：

是稳定的排序算法：
1. 稳定性是指，比如a在b前面，a=b，排序后，a仍然应该在b前面，这样就算稳定的。
2. 桶排序中，假如升序排列，a已经在桶中，b插进来是永远都会a右边的(因为一般是从右到左，如果不小于当前元素，则插入改元素的右侧)
3. 所以桶排序是稳定的
  
  PS:当然了，如果采用元素插入后再分别进行桶内排序，并且桶内排序算法采用快速排序，那么就不是稳定的
4. 更重要：桶排序的稳定性取决于桶内排序使用的算法。