【算法Algorithm】桶（Bucket）排序

算法思想

确定待排序数列（n个数）的最小值和最大值，确定桶的数量k；然后把这个n个数“均匀的”放到k个桶中；再对每个桶中的数列进行排序（可以使用其他排序算法）；最后依次读取每个桶中的数就是排好序的整个数列。

使用一个映射函数来达到把n个数放到k个桶的操作，其规则是“左侧”桶（先放置的）中的数全部小于“右侧”桶中的数列，即每个桶都有一个取值范围（如：第一个桶存放1-5，第二个桶存放6-10），不在这个范围的就是一个空桶。

代码实现

private static void main(String[] args) {
    Random r = new Random();    
    int[] arr = new int[10];
    for (int i = 0; i < 10; i++) {
        arr[i] = r.nextInt(20);
    }
    System.out.println("待排序数组：" + Arrays.toString(arr));
    sort(arr);
    System.out.println("最终结果：" + Arrays.toString(arr));
}

/**
* 排序算法
*
* @param arr        待排序数组
* @param bucketSize 一个桶中存放的数量
*/
private static void sort(int[] arr, int bucketSize) {
    // 确定待排序数组的最大值和最小值
    int min = arr[0];
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
        if (arr[i] > max) { 
            max = arr[i];
        }
    }
    // 如果最大值和最小值相等，说明整个待排序数组就是同一个数
    if (min == max) {
        return;
    }
    // 确定桶的数量
    int count = (int) Math.floor((max- min) / bucketSize) + 1;
    // 定义桶；利用list可以防止不确定每个桶存放数的数量，也可以避免每次都要扩充数组
    List<List<Integer>> bucket = new ArrayList<>();
    for (int i = 0; i < count; i++) {
        bucket.add(new ArrayList<>());
    }
    // 把待排序数列放到桶里
    for (int i = 0; i < arr.length; i++) {
        // 取商，则大数存放的桶的序号就大
        int index = (int) Math.floor((arr[i] - min) / bucketSize);
        bucket.get(index).add(arr[i]);
    }
    // 对每个桶进行希尔排序
    for (int i = 0; i < bucket.size(); i++) {
        if (list.size() > 1) {
            Integer[] tmp = bucket.get(i).toArray(new Integer[bucket.get(i).size()]);
            shellSort(tmp, 0, tmp.length);
            bucket.set(i, Arrays.asList(tmp));
        }
    }

    // 排列
    int k = 0;
    for (int i = 0; i < bucket.size(); i++) {
        List<Integer> tmp = bucket.get(i);
        for (int j = 0; j < tmp.size(); j++) {
            arr[k++] = tmp.get(j);
        }
    }
}

/**
* 应用于每个桶中的排序算法
*/
private static void shellSort(Integer[] arr, int left, int right) {
    if (left >= right) {
        return;
    }
    int mid = (left + right) / 2;
    shellSort(arr, left, mid);
    shellSort(arr, mid + 1, right);
    
    for (int i = left; i < right; i++) {
        for (int j = i; j > 0; j--) {
            if (arr[j - 1] > arr[j]) {
                int tmp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

复杂度和稳定性

时间复杂度

• 最好时间复杂度：O(n+k)
• 最坏时间复杂度：O()
• 平均时间复杂度：O(n+k)

空间复杂度：O(n+k)

稳定性：稳定

参考文章

https://www.runoob.com/w3cnote/bucket-sort.html