桶排序

参考资料：算法导论

note1:桶排序是另外一种以O(n)或者接近O(n)的复杂度排序的算法. 它假设输入的待排序元素是等可能的落在等间隔的值区间内.一个长度为N的数组使用桶排序, 需要长度为N的辅助数组. 等间隔的区间称为桶, 每个桶内落在该区间的元素. 桶排序是基数排序的一种归纳结果

note2:待排序元素越均匀, 桶排序的效率越高. 均匀意味着每个桶在中间过程中容纳的元素个数都差不多,不会出现特别少或者特别多的情况, 这样在排序子程序进行桶内排序的过程中会达到最优效率.

note3:将元素通过恰当的映射关系将元素尽量等数量的分到各个桶(值区间)里面, 这个映射关系就是桶排序算法的关键.桶的标记(数组索引Index)的大小也要和值区间有对应关系

代码：

package sorts;

import java.util.Arrays;
import java.util.Random;

class Bucket {
    private double data;
    private Bucket next;
    public double getData() {
        return data;
    }
    public void setData(double data) {
        this.data = data;
    }
    public Bucket getNext() {
        return next;
    }
    public void setNext(Bucket next) {
        this.next = next;
    }
    @Override
    public String toString() {
        return Double.toString(data);
    }
}

public class BucketSort {
    
    /**
     * Input element MUST be in the range [0, 1). Or
     * the program may not function properly.
     * */
    public static void sort(double[] a) {
        // init
        Bucket[] buckets = new Bucket[a.length];
        int n = a.length;
        // sort
        for (int i = 0; i < a.length; i++) {
            addBucket(buckets, (int)(a[i] * n), a[i]);
        }
        retrieveBuckets(buckets, a);
    }
    
    private static void retrieveBuckets(Bucket[] buckets, double[] a) {
        Bucket iterator = null;
        int index = 0;
        for (int i = 0; i < buckets.length; i++) {
            iterator = buckets[i];
            while (iterator!=null) {
                a[index++] = iterator.getData();
                iterator = iterator.getNext();
            }
        }
    }

    // no need for insertion sort
    private static void addBucket(Bucket[] buckets, int index, double data) {
        Bucket iterator = buckets[index];
        if (iterator == null) {
            Bucket tmp = new Bucket();
            tmp.setData(data);
            tmp.setNext(buckets[index]);
            buckets[index] = tmp;
        } else {
            Bucket tmp = new Bucket();
            Bucket previous = iterator;
            tmp.setData(data);
            while ((iterator!=null) && 
                    (data > iterator.getData())) {
                previous = iterator;
                iterator = iterator.getNext();
            }
            if (iterator==previous) {
                tmp.setNext(iterator.getNext());
                iterator.setNext(tmp);
            } else {
                previous.setNext(tmp);
                tmp.setNext(iterator);
            }
        }
    }
    
    // test
    public static void main(String[] args) {
        Random random = new Random();
        int num = 10;
        double[] a = new double[num];
        for (int i = 0; i < num; i++) {
            a[i] = random.nextDouble();
        }
        BucketSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
    
}