桶排序

import java.util.*;

/**
 * 桶排序，是一種線性時間的排序算法，需要創建若干個桶來協助排序，每個桶代表一個區間範圍，裏面可以承載一到多個元素
 * 時間複雜度：平均複雜度爲O(n)
 * 第一步：求數列最大、最小值，運算量爲n
 * 第二步：創建崆峒，運算量爲n
 * 第三步：把原始數據的元素分配到各個桶中，運算量爲n
 * 第四步：在每個桶內部做排序，在元素分配相對均勻的情況下，所有桶的運算量之和爲n
 * 第五步：輸出排序數列，運算量爲n
 * 因此，桶排序的總體時間複雜度爲O(n)
 * 桶排序的性能並非絕對穩定，如果元素極不均衡，在極端情況下，第一個桶中有n-1個元素，最後一個桶中只有一個元素，此時的時間複雜度爲O(nlogn)，而且還白白創建了許多空桶
 */
public class BucketSort {

    public static double[] bucketSort(double[] arr) {
        //1、得到數組的最大值、最小值和差值d
        double max = arr[0];
        double min = arr[0];
        for (double i : arr) {
            if (i > max) {
                max = i;
            }
            if (i < min) {
                min = i;
            }
        }
        double d = max - min;
        //2、初始化桶
        int bucketNum = arr.length;
        List<LinkedList<Double>> bucketList = new ArrayList<>();
        for (int i = 0; i < bucketNum; i++) {
            bucketList.add(new LinkedList<>());
        }
        //3、遍歷原始數組，將每個元素放入桶中
        for (double i : arr) {
            int num = (int) ((i - min) * (bucketNum - 1) / d);
            bucketList.get(num).add(i);
        }
        //4、對每個桶內部進行排序
        for (LinkedList item : bucketList) {
            Collections.sort(item);
        }
        //5、輸出全部元素
        double[] sortArray = new double[arr.length];
        int index = 0;
        for (LinkedList<Double> item : bucketList) {
            System.out.println("----" + Arrays.toString(item.toArray()));
            for (double i : item) {
                sortArray[index++] = i;
            }
        }
        return sortArray;
    }

    public static void main(String[] args) {
        double[] array = new double[]{4.12, 6.421, 0.0023, 3.0, 2.123, 8.122, 4.12, 10.09};
        double[] sortArray = bucketSort(array);
        System.out.println(Arrays.toString(sortArray));
    }
}