转载：算法：桶排序BucketSort

 

转载：算法：桶排序BucketSort

 

 

原文链接：https://zhuanlan.zhihu.com/p/104111202

动画 | 什么是桶排序 ？

 

我脱下短袖

公众号『算法无遗策』

学过上一篇文章的计数排序之后，特别是归约化分治处理的计数排序（适用于较离散的非负整数序列）。计数排序的局限比较多，在排序之前需要解决负数和小数的问题，而桶排序不需要考虑这些。

桶排序和计数排序一样，不受O(nlogn)时间复杂度下限的影响，它将待排序序列通过遍历方式分到有限数量的桶中，然后每个桶被单独地排序，不管是使用同一个比较类排序算法或者使用不同的排序算法，或者还是递归地使用桶排序。桶排序可以通过比较方式实现，也可以通过非比较方式实现。

 

通过比较方式的桶排序分为4步工作步骤：

1.设定合适数量的分桶；

2.遍历待排序序列，将每个元素放入到对应的桶中；

3.对每个非空桶进行合适的排序算法；

4.按顺序访问桶，将桶中的元素依次放回到原序列中对应的位置。

 

关于如何设置合适数量的分桶，我们这里分为两种：设定简单的分桶和归约化的分桶。

 

设定简单的分桶

假设我们输入数组[13, 9, 15, 1, 7, 11, 25, 21, 29, 17, 5]，求数组中的最大值和最小值，max = 29，min = 1，设定分桶的情况为max / 10 – min / 10 + 1 = 3。所以我们设定合适的数量为3桶，从0开始。数组中第一个元素是13，进行(13 - min) / 10的运算，得2，放入到第3 个桶；数组中第2个元素是9，(9 - min) / 10 = 0，放入到第1个桶；依此类推。

分布完之后按顺序访问桶，将桶中的元素依次放回到原序列中对应的位置。

动画：简单分桶

算法动画视频 地址   https://www.bilibili.com/video/av85226110/?p=2

[清晰 480P] 桶排序_P1_桶排序 简单分桶 [最优化的质量和大小].flv

Code：简单分桶

 

Code：插排

 

 

归约化分桶

如果元素之间的大小跨度比较大，例如我们输入[103, 9, 105, 1, 7, 101, 205, 201, 209, 107, 5]，按照简单分桶情况的话，它的桶数量是209 / 10 – 1 / 10 + 1 = 21是极为不合理的，中间会浪费掉比较多的空桶。

所以和计数排序的归约化分治一样，桶排序也做归约化分桶，桶设为(array[i] - min) / (max - min) * array.length。

我们采用HashMap的方式记录桶的情况，每次将数组中的元素输入到桶去，得到的分桶值作为key，添加元素的动态数组对象作为value。 数组遍历完之后也按顺序访问桶，将桶中的元素依次放回到原序列中对应的位置。

动画：归约分桶

算法动画视频 地址  https://www.bilibili.com/video/av85226110?p=2

[清晰 480P] 桶排序_P2_桶排序 归约 [最优化的质量和大小].flv

Code：归约化分桶

 

package cn.study.sort;

 

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

 

public class BucketSort2 {

       //简单分桶

       public static void bucketSort(int[] array){

              int max = array[0];

              int min = array[0];

              for (int arr : array) {

                    if(arr > max){

                           max = arr;

                    }else if(arr < min){

                           min = arr;

                    }

              }//end of for

             

              //设定分桶情况

              int bucketNum = max / 10 - min / 10 + 1;

              List<List<Integer>> bucketList = new ArrayList<List<Integer>>();

              //创建桶

              for (int i = 0; i < bucketNum; i++) {

                    bucketList.add(new ArrayList<Integer>());

              }

              //向桶里添加对应的元素

              for (int i = 0; i < array.length; i++) {

                    int index = (array[i] - min) / 10;

                    bucketList.get(index).add(array[i]);

              }

              List<Integer> bucket = null;

              int index = 0;

              //对每个桶分别进行插排

              for(int i = 0; i < bucketNum; i++){

                    bucket = bucketList.get(i);

                    insertSort(bucket);//进行插排

                    for(int k : bucket){array[index++] = k;}

              }

       }//end of method bucketSort

      

       //规约化分桶

       public static void bucketSort2(int[] array){

              int max = array[0];

              int min = array[0];

              for (int arr : array) {

                    if(arr > max){

                           max = arr;

                    }else if(arr < min){

                           min = arr;

                    }

              }//end of for

             

              HashMap<Integer, ArrayList<Integer>> bucketMap = new HashMap<Integer, ArrayList<Integer>>();

              //向桶里添加对应的元素

              for (int i = 0; i < array.length; i++) {

                    int index = (int)((float)(array[i] - min) / (max - min) * array.length);

                    if(!bucketMap.containsKey(index)){

                           ArrayList<Integer> arrList = new ArrayList<Integer>();

                           arrList.add(array[i]);

                           bucketMap.put(index, arrList);

                    }else{

                           bucketMap.get(index).add(array[i]);

                    }

              }//end of for

              List<Integer> bucket = null;

              int index = 0;

              //对每个桶分别进行插排

              Iterator<Integer> iterKey = bucketMap.keySet().iterator();

              while(iterKey.hasNext()){

                    bucket = bucketMap.get(iterKey.next());

                    insertSort(bucket);//进行插排

                    for(int k : bucket){array[index++] = k;}

              }

       }//end of method bucketSort2

 

       //插排

       public static void insertSort(List<Integer> bucket){

              for(int i = 1; i < bucket.size(); i++){

                    int insertVal = bucket.get(i);

                    int j = i;

                    for(; j > 0 && insertVal < bucket.get(j - 1); j--){

                           bucket.set(j, bucket.get(j - 1));

                    }

                    bucket.set(j, insertVal);

              }

       }//end of method insertSort

      

       public static void main(String[] args) {

              int[] array = {13,9,15,1,7,11,25,21,29,17,5};

//            bucketSort(array);//[1, 5, 7, 9, 11, 13, 15, 17, 21, 25, 29]

              bucketSort2(array);//[1, 5, 7, 9, 11, 13, 15, 17, 21, 25, 29]

              System.out.println(Arrays.toString(array));

             

       }

}

 

 

喜欢本文的朋友，微信搜索「算法无遗策」公众号，收看更多精彩的算法动画文章