2014年去哪儿网笔试题--给定一个整型数组，对这个整型素组排序，使得按序拼接数组各元素得到的值最小

2014年去哪儿网笔试题--给定一个整型数组，对这个整型素组排序，使得按序拼接数组各元素得到的值最小。

我的大致思路是把这个整型数组转换成String数组，然后通过String类的compareTo方法对这个数组进行第一次排序，排序得到的结果恰好是按字典序排序，而字典序又恰好是数字从0-9的顺序，恰好符合这个要求。最后进行检验下，有的可能需要调换下顺序使得数最小。

[java]  view plain copy

1. package com.cn.qunar.test;  
2.   
3. /** 
4.  * @author 刘利娟 liulijuan132@gmail.com 
5.  * @version 创建时间:2014年8月2日 上午7:33:31 类说明： 给定一个整型数组，对这个整数数组排序，使得按序拼接数组各元素得到的值最小。 
6.  *          示例：[3,83,8,13,1],被排序之后的数组为[1,13,3,83,8]。 依次拼接得到最小的数1133838。 
7.  */  
8. public class IntSort {  
9.   
10.     public static void main(String[] args) {  
11.         int[] array = new int[] { 3, 83, 8, 101, 10103 };  
12.         String[] strings = new String[array.length];  
13.         for (int i = 0; i < array.length; i++) {  
14.             strings[i] = Integer.toString(array[i]);  
15.             System.out.println(strings[i]);  
16.         }  
17.         for (int i = 0; i < strings.length - 1; i++) {  
18.             for (int j = 0; j < strings.length - i - 1; j++) {  
19.                 if (strings[j].compareTo(strings[j + 1]) > 0) {  
20.                     System.out.println(strings[j] + ">" + strings[j + 1]);  
21.                     String temp = strings[j];  
22.                     strings[j] = strings[j + 1];  
23.                     strings[j + 1] = temp;  
24.                 }  
25.             }  
26.         }  
27.         for (int i = 0; i < strings.length; i++) {  
28.             System.out.println(strings[i]);  
29.         }  
30.         for (int i = 0; i < strings.length - 1; i++) {  
31.             int lengths = (strings[i].length() > strings[i + 1].length()) ? strings[i + 1]  
32.                     .length() : strings[i].length();  
33.             System.out.println("长度：" + lengths);  
34.             for (int j = 0; j < lengths; j++) {  
35.                 if (strings[i].charAt(j) == strings[i + 1].charAt(j)) {  
36.                     int si = Integer.parseInt(strings[i]);  
37.                     int si1 = Integer.parseInt(strings[i+1]);  
38.                     int sim = 1;  
39.                     for(int k = 0; k < strings[i].length(); k++){  
40.                         sim *= 10;  
41.                     }  
42.                     int si1m = 1;  
43.                     for(int k = 0; k < strings[i+1].length(); k++){  
44.                         si1m *= 10;  
45.                     }  
46.                     if((si * si1m+si1)>(si1 * sim + si)){  
47.                         System.out.println((si * si1m+si1)+">"+(si1 * sim + si));  
48.                         String temp = strings[i];  
49.                         strings[i] = strings[i+1];  
50.                         strings[i+1] = temp;  
51.                     }  
52.                 }  
53.             }  
54.         }  
55.         StringBuffer sb = new StringBuffer();  
56.         for(int i = 0; i < strings.length; i++){  
57.             sb.append(strings[i]);  
58.         }  
59.         System.out.println("排序结果："+sb);  
60.     }  
61.   
62. }  

虽然效率不是很高= =，但好歹是自己想出来的。已验证该知道答案均不正确。http://zhidao.baidu.com/question/489460060.html

2015-01-15 修改

这个方法遇到有值相同的数组时就得不到正确结果。昨天刷oj时，看到一类似题目，使得按序拼接数组各元素所得值最大，结果没有通过用例，才发现的问题。之后，在讨论区看到很多很好的解法。

[java]  view plain copy

1. class StringComparator implements Comparator<String> {  
2.     public int compare(String a, String b) {  
3.         if (a.length() == b.length()) {  
4.             return b.compareTo(a);  
5.         } else {  
6.             String ab = a + b;  
7.             String ba = b + a;  
8.             return ba.compareTo(ab);  
9.         }  
10.     }  
11. }  
12.   
13. public class Solution {  
14.     public String largestNumber(int[] num) {  
15.         StringBuffer sbuf = new StringBuffer();  
16.         ArrayList<String> numstrings = new ArrayList<String>(num.length);  
17.   
18.         for (int i : num) numstrings.add(String.valueOf(i));  
19.         Collections.sort(numstrings,  new StringComparator());  
20.         for (String s : numstrings) sbuf.append(s);  
21.   
22.         String res = sbuf.toString();  
23.         if (res.length() > 0 && res.charAt(0) == '0') return "0";  
24.   
25.         return res;  
26.     }  

以上方式使用了java API中的Collections静态工具类中sort方法，通过实现Comparator接口，重写compare方法，使得排序按照题目要求的顺序进行。