桶排序

2019-07-13

分类	排序算法
数据结构	数组
最坏时间复杂度	$O(n^2)$
平均时间复杂度	$O(n+k)$
最坏空间复杂度	$O(n\ast k)$

桶排序（Bucket sort）或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶里。每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间$o(n)$。但桶排序并不是比较排序，他不受到$O(n{\log }_{2}n)$下限的影响。

定义

假定：输入是由一个随机过程产生的[0, 1)区间上均匀分布的实数。将区间[0, 1)划分为n个大小相等的子区间（桶），每桶大小1/n：[0, 1/n)， [1/n, 2/n)， [2/n, 3/n)，…，[k/n, (k+1)/n )，…将n个输入元素分配到这些桶中，对桶中元素进行排序，然后依次连接桶输入0 ≤A[1…n] <1辅助数组B[0…n-1]是一指针数组，指向桶（链表）。

说明

1）桶排序是稳定的；
2）桶排序是常见排序算法中最快的一种，大多数情况下比快排和归并排序还要快；
3）桶排序非常快但是也非常消耗空间，典型的以空间换时间，基本上是最耗内存的一种排序算法。

算法原理

1.设置一个定量的数组当作空桶子。
2.寻访序列，并且把项目一个一个放到对应的桶子去。
3.对每个不是空的桶子进行排序。可以继续使用桶排序或者其他排序算法，如插入排序
4.从不是空的桶子里把项目再放回原来的序列中。

代码实现

/**
 * @Date: 2019/7/13 18:41
 * @Description: 1 设置一个定量的数组当作空桶子。
 * 2 寻访串行，并且把项目一个一个放到对应的桶子去。
 * 3 对每个不是空的桶子进行排序。
 * 4 从不是空的桶子里把项目再放回原来的串行中。
 */
public class BucketSort {

    private int indexFor(int a, int min, int step) {
        return (a - min) / step;// 返回当前元素a对应的桶的编号
    }

    public void bucketSort(int[] arr) {

        int max = arr[0], min = arr[0];
        for (int a : arr) {//找出arr数组中的最大元素和最小元素
            if (max < a)
                max = a;
            if (min > a)
                min = a;
        }

        // 定义桶数量，该值也可根据实际情况进行选择
        int bucketNum = max / 10 - min / 10 + 1;
        List buckList = new ArrayList<List<Integer>>();

        //建立桶
        for (int i = 1; i <= bucketNum; i++) {
            buckList.add(new ArrayList<Integer>());
        }

        // 将元素加入相应的桶中
        for (int i = 0; i < arr.length; i++) {
            int index = indexFor(arr[i], min, 10);
            ((ArrayList<Integer>) buckList.get(index)).add(arr[i]);
        }

        ArrayList<Integer> bucket;
        int index = 0;
        for (int i = 0; i < bucketNum; i++) {
            bucket = (ArrayList<Integer>) buckList.get(i);
            insertSort(bucket);
            for (int k : bucket) {
                arr[index++] = k;
            }
        }
        
        System.out.println(Arrays.toString(arr));

    }

    // 对桶内元素进行插入排序
    private void insertSort(List<Integer> bucket) {
        for (int i = 1; i < bucket.size(); i++) {
            int temp = bucket.get(i);
            int j = i - 1;
            for (; j >= 0 && bucket.get(j) > temp; j--) {
                bucket.set(j + 1, bucket.get(j));
            }
            bucket.set(j + 1, temp);
        }
    }

    @Test
    public void testBucketSort() {
        int[] array = {5, 74, 532234, 15, 144, 845, 60, 41, 1, 21, 4, 7, 4445, 29, 9333339, 84, 73};
        int a[] = {35, 11, 24, 52, 77, 69, 8, 3, 6, 62};
        int b[] = {7, 9, 3, 2, 5, 8, 6};
        bucketSort(array);
        bucketSort(a);
        bucketSort(b);
//        System.out.println(Arrays.toString(array));
//        System.out.println(Arrays.toString(a));
//        System.out.println(Arrays.toString(b));
    }
}
/*
Output:
[1, 4, 5, 7, 15, 21, 29, 41, 60, 73, 74, 84, 144, 845, 4445, 532234, 9333339]
[3, 6, 8, 11, 24, 35, 52, 62, 69, 77]
[2, 3, 5, 6, 7, 8, 9]
 */