机试题之自定义字符串排序

需求

您将编写一个程序，它接受包含整数和单词的字符串列表，并返回该列表的排序版本
目标是对这个列表进行排序，使所有单词都按字母顺序排列，所有整数都按数字顺序排列
此外，如果列表中的第n个元素是整数，则它必须保持整数，如果是单词，则它必须保持单词

输入规格：
输入将包含一个单独的（可能为空）字符串，其中包含一个用空格分隔的要排序的字符串列表。单词不包含空格，将只包含小写字母a-z
整数的范围为-999999到999999，包括小写字母a-z。行的长度最多为1000个字符

输出规格：
程序必须输出按上述要求排序的字符串列表。字符串必须以一个空格开头，行首不带前导空格，行尾不带尾随空格

例子一：
输入：
car truck bus
输出：
bus car truck

例子二：
输入：
8 4 6 1 -2 9 5
输出：
-2 1 4 5 6 8 9

例子三:
输入：
car truck 8 4 bus 6 1
输出：
bus car 1 4 truck 6 8

代码

public class SortString {

    public static String sort(String unsortedstr) {
        String[] splits = unsortedstr.split(" ");

		// 存放intgers
        StringBuffer integers = new StringBuffer();
 		// 存放strings
        StringBuffer strings = new StringBuffer();

        int idx = 0;
        // 用来记录integers在splits中的位置
        Map<Integer, Integer> intmap = new HashMap<Integer, Integer>();
        for (String str : splits) {
            char c = str.charAt(0);
            if (c < 'a' || c >  'z') {
                integers.append(str);
                integers.append(" ");

                intmap.put(idx, idx);
            }  else {
                strings.append(str);
                strings.append(" ");
            }
            idx++;
        }

        StringBuffer sb = new StringBuffer();
        if (integers.length() > 0 && strings.length() == 0) {
			// 只包含数字
            Arrays.sort(splits);
            for (String str : splits) {
                sb.append(str);
                sb.append(" ");
            }
        } else if (integers.length() == 0 && strings.length() > 0) {
	 		// 只包含字符串
            Map<Character, String> map = new HashMap<Character, String>();
            char[] chars = new char[splits.length];
            for (int i = 0; i < splits.length; i++) {
                chars[i] = splits[i].charAt(0);
                map.put(splits[i].charAt(0), splits[i]);
            }
            Arrays.sort(chars);

            for (char c1 : chars) {
                for (Character c2 : map.keySet()) {
                    if (c1 == c2) {
                        sb.append(map.get(c2));
                        sb.append(" ");
                    }
                }
            }
        } else {
			// 既包含数字又包含字符串
            integers.deleteCharAt(integers.lastIndexOf(" "));
            String[] sortint = sort(integers.toString()).split(" ");

            strings.deleteCharAt(strings.lastIndexOf(" "));
            String[] sortstr = sort(strings.toString()).split(" ");

            int count = 0;
            int intidx = 0;
            int stridx = 0;
            for (int i = 0; i < splits.length; i++) {
                if (intmap.containsKey(count)) {
                    sb.append(sortint[intidx]);
                    intidx++;
                } else {
                    sb.append(sortstr[stridx]);
                    stridx++;
                }
                sb.append(" ");
                count++;
            }
        }

        sb.deleteCharAt(sb.lastIndexOf(" "));
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println("例子一：");
        String s1 = "car truck bus";
        System.out.println("排序前：" + s1 + " 长度为：" + s1.length());
        String sorted1 = sort(s1);
        System.out.println("排序后：" + sorted1 + " 长度为：" + sorted1.length());

        System.out.println("例子二：");
        String s2 = "8 4 6 1 -2 9 5";
        System.out.println("排序前：" + s2 + " 长度为：" + s2.length());
        String sorted2 = sort(s2);
        System.out.println("排序后：" + sorted2 + " 长度为：" + sorted2.length());

        System.out.println("例子三：");
        String s3 = "car truck 8 4 bus 6 1";
        System.out.println("排序前：" + s3 + " 长度为：" + s3.length());
        String sorted3 = sort(s3);
        System.out.println("排序后：" + sorted3 + " 长度为：" + sorted3.length());
    }

输出

例子一：
排序前：car truck bus 长度为：13
排序后：bus car truck 长度为：13
例子二：
排序前：8 4 6 1 -2 9 5 长度为：14
排序后：-2 1 4 5 6 8 9 长度为：14
例子三：
排序前：car truck 8 4 bus 6 1 长度为：21
排序后：bus car 1 4 truck 6 8 长度为：21

Process finished with exit code 0