基数排序

参考资料：算法导论

性能：给定n个d位数，每一个数位可以取k种可能的值，基数排序算法时间为O(d(n+k))，当d为常数，k=O(n)时，基数排序为O(n)时间

优点：稳定排序

缺点：不是原地排序

实现代码（用户需要提供一个RSHelper的实现即可完成排序，本例给出一个随意的实现仅作示意）

RadixSort.java

package sorts;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

import test.RSHelper;

public class RadixSort {
    
    private RadixSort() {
        
    }
    
    public static <K extends Comparable<K>, T> void sort(RSHelper<K, T> helper) {
        // initialize
        Set<K> keys = helper.keys();
        Map<K, Queue<T>> map = new HashMap<K, Queue<T>>();
        List<Queue<T>> queues = new ArrayList<Queue<T>>();
        for (int i = 0; i < keys.size(); i++) {
            queues.add(new LinkedList<T>());
        }
        int i = 0;
        for (K k : keys) {
            map.put(k, queues.get(i++));
        }
        int dataLength = helper.dataLength();
        // sort
        T data = null;
        K key = null;
        for (i = 0; i < dataLength; i++) {
            while (helper.hasNext()) {
                data = helper.next();
                key = helper.key(data, i);
                map.get(key).offer(data);
            }
            for (Queue<T> queue : queues) {
                while (!queue.isEmpty()) {
                    data = queue.poll();
                    helper.put(data);
                }
            }
        }
    }
    
}

RSHelper.java

package test;

import java.util.Set;

public interface RSHelper<K extends Comparable<K>, T> {
    /**
     * @return true if there's still data available, false otherwise.
     * */
    boolean hasNext();
    /**
     * @return the next data. 
     * */
    T next(); 
    /**
     * @param index starts from 0 (the lowest index)
     * @param data the data where the key is from.
     * @return the key at the specified index in the data.
     * */
    K key(T data, int index);
    /**
     * @return the keys that will be involved while sorting. The set must be sorted according
     * to the natural order of the keys.
     * */
    Set<K> keys();
    
    /**
     * @return the number of keys in one data object.
     * */
    int dataLength();
    /**
     * Put the data back to the client, in a sequential manner
     * that the client can receive the result of one round of sorting.
     * */
    void put(T data);
}

TestRadixSort.java

package test;

import java.util.Arrays;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

import sorts.RadixSort;

class DataType {
    
    Integer[] arr = new Integer[3];
    public DataType(int a, int b, int c) {
        if (a > 9 || b > 9 || c > 9) {
            throw new IllegalArgumentException("Argument should be no more than 9.");
        }
        arr[0] = a;
        arr[1] = b;
        arr[2] = c;
    }
    int get(int index) {
        return arr[3-index-1];
    }
    void set(int index, int value) {
        arr[3-index-1] = value;
    }
    static int dataLength() {
        return 3;
    }
    @Override
    public String toString() {
        return arr[0] + "" + arr[1] + "" + arr[2];
    }
}

class MyRSHelper implements RSHelper<Integer, DataType> {
    
    static Set<Integer> keySet = new TreeSet<>();
    static {
        for (int i = 0; i < 10; i++) {
            keySet.add(i);
        }
    }
    
    int index = 0;
    DataType[] arr = new DataType[10];
    
    public MyRSHelper() {
        int bound = 10;
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new DataType(random.nextInt(bound), 
                    random.nextInt(bound), random.nextInt(bound));
        }
    }

    @Override
    public boolean hasNext() {
        return (index < arr.length);
    }

    @Override
    public DataType next() {
        DataType result = arr[index];
        arr[index] = null;
        index++;
        return result;
    }

    @Override
    public Integer key(DataType data, int index) {
        return data.get(index);
    }

    @Override
    public Set<Integer> keys() {
        return keySet;
    }

    @Override
    public int dataLength() {
        return DataType.dataLength();
    }

    @Override
    public void put(DataType data) {
        if (index == arr.length) {
            index = 0;
        }
        arr[index++] = data;
        if (index == arr.length) {
            index = 0;
        }
    }
    
    @Override
    public String toString() {
        return Arrays.toString(arr);
    }

}

public class TestRadixSort {
    // test
    public static void main(String[] args) {
        MyRSHelper helper = new MyRSHelper();
        RadixSort.sort(helper);
        System.out.println(helper);
    }
}