突然发现自己对这三种排序算法一无所知。
他们是基于不比较类型的算法。
在特殊情况下，时间复杂度可以达到 O(n)

看下面三篇文章，讲得很好。

Radix sort:
https://en.wikipedia.org/wiki/Radix_sort

Counting sort:
http://www.geeksforgeeks.org/counting-sort/

Bucket sort:
http://www.geeksforgeeks.org/bucket-sort-2/

我自己写了下Radix sort, 他是基于counting sort的。

My code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

public class Solution {
    public void radixSort(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return;
        }
        
        int max = getMax(nums);
        for (int i = 1; i <= max; i = i * 10) {
            countingSort(nums, nums.length, i);
        }
    }
    
    private int getMax(int[] nums) {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            max = Math.max(max, nums[i]);
        }
        
        return max;
    }
    
    private void countingSort(int[] nums, int n, int digit) {
        int[] counters = new int[10];
        int[] temp = new int[n];
        for (int i = 0; i < n; i++) {
            counters[(nums[i] / digit) % 10]++;
        }
        
        for (int i = 1; i < 10; i++) {
            counters[i] += counters[i - 1];
        }
        
        for (int i = n - 1; i >= 0; i--) {
            temp[counters[(nums[i] / digit) % 10] - 1] = nums[i];
            counters[(nums[i] / digit) % 10]--;
        }
        
        for (int i = 0; i < n; i++) {
            nums[i] = temp[i];
        }
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        int[] nums = new int[]{170, 45, 75, 90, 802, 24, 2, 66};
        test.radixSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "_");
        }
    }
}

这里有个细节是，counting sort 只能从右往左扫描。因为我们要维持稳定的排序。即，假设两个两位数，在按照第三位排序的时候，他们原来的顺序不能被破坏。

Anyway, Good luck, Richardo! -- 09/01/2016