字符串低位优先排序真的只能排序字符串相同的字符么？

最近在刷剑指Offer上的题时遇到一题：

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

突然想到使用LSD算法,

package com.roysatm.niuke;


/**
 * Created by roysatm on 2016/5/30.
 */
public class SolutionPrintMinNumber {

    /**
     * 采用LSD(低位优先排序)思想，可以说能把高位优先排序取代。
     * 基本是O(n)时间复杂度完成，没有使用任何java集合框架
     * 代码可能不是最优，特别是空间复杂度方面
     */
    public String PrintMinNumber(int[] numbers) {

        if (numbers == null || numbers.length == 0) {
            return "";
        }

        String[] str = new String[numbers.length];
        int w = 0;
        //将int数组转成string数组
        for (int i = 0; i < numbers.length; i++) {
            str[i] = numbers[i] + "";
        }
        //计算出str数组中长度最长的字符串长度
        for (int i = 0; i < str.length; i++) {
            if (str[i].length() > w) {
                w = str[i].length();
            }
        }

        StringBuilder sb = new StringBuilder();

        String[] array = PrintMinNumber(str, w);
        //将String数组转换成String字符串
        for (int i = 0; i < array.length; i++) {
            sb.append(array[i]);
        }
        return sb.toString();
    }

    public String[] PrintMinNumber(String[] str, int w) {

        /**
         * 低位优先排序，主要看点是getCharAt(String s, int index)函数的变化
         由于getCharAt(String s, int index)函数的改变，LSD可以排长度不同的字符串
         * **/

        int R = 256;
        int N = str.length;
        String[] aux = new String[N];

        for (int i = w - 1; i >= 0; i--) {

            int[] count = new int[R + 1];

            for (int j = 0; j < N; j++) {
                count[getCharAt(str[j], i) + 1]++;
            }

            for (int j = 0; j < R; j++) {
                count[j + 1] += count[j];
            }

            for (int j = 0; j < N; j++) {
                aux[count[getCharAt(str[j], i)]++] = str[j];
            }

            for (int j = 0; j < N; j++) {
                str[j] = aux[j];
            }
        }

        return str;
    }

    private char getCharAt(String s, int index) {

        if (s.length() <= index) {
            return s.charAt(s.length() - 1);
        } else {
            return s.charAt(index);
        }
    }

    public static void main(String[] args) {
        int[] a = {12, 2, 34, 13, 54};
        SolutionPrintMinNumber spm = new SolutionPrintMinNumber();
        String str = spm.PrintMinNumber(a);
        System.out.print(str + " ");

    }
}

以上算法是LSD排序算法升级版，不仅能排序字符串长度相同的数组，还能像高位优先一样排序字符串不同的数组。

下次有时间再详细写写.......