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

注此题与《剑指offer》面试题33相同 

首先借鉴别人的思路 http://blog.csdn.net/lands92/article/details/38345533

先看她的代码

package com.cn.qunar.test;

/**
 * @author 刘利娟 liulijuan132@gmail.com
 * @version 创建时间:2014年8月2日 上午7:33:31 类说明： 给定一个整型数组，对这个整数数组排序，使得按序拼接数组各元素得到的值最小。
 *          示例：[3,83,8,13,1],被排序之后的数组为[1,13,3,83,8]。 依次拼接得到最小的数1133838。
 */
public class IntSort {

    public static void main(String[] args) {
        int[] array = new int[] { 3, 83, 8, 101, 10103 };
        String[] strings = new String[array.length];
        for (int i = 0; i < array.length; i++) {
            strings[i] = Integer.toString(array[i]);
            System.out.println(strings[i]);
        }
        for (int i = 0; i < strings.length - 1; i++) {
            for (int j = 0; j < strings.length - i - 1; j++) {
                if (strings[j].compareTo(strings[j + 1]) > 0) {
                    System.out.println(strings[j] + ">" + strings[j + 1]);
                    String temp = strings[j];
                    strings[j] = strings[j + 1];
                    strings[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        for (int i = 0; i < strings.length - 1; i++) {
            int lengths = (strings[i].length() > strings[i + 1].length()) ? strings[i + 1]
                    .length() : strings[i].length();
            System.out.println("长度：" + lengths);
            for (int j = 0; j < lengths; j++) {
                if (strings[i].charAt(j) == strings[i + 1].charAt(j)) {
                    int si = Integer.parseInt(strings[i]);
                    int si1 = Integer.parseInt(strings[i+1]);
                    int sim = 1;
                    for(int k = 0; k < strings[i].length(); k++){
                        sim *= 10;
                    }
                    int si1m = 1;
                    for(int k = 0; k < strings[i+1].length(); k++){
                        si1m *= 10;
                    }
                    if((si * si1m+si1)>(si1 * sim + si)){
                        System.out.println((si * si1m+si1)+">"+(si1 * sim + si));
                        String temp = strings[i];
                        strings[i] = strings[i+1];
                        strings[i+1] = temp;
                    }
                }
            }
        }
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < strings.length; i++){
            sb.append(strings[i]);
        }
        System.out.println("排序结果："+sb);
    }

}

他写的代码是有问题的，问题在于进行过冒泡排序之后，数组呈字典顺序排列。在进行第二次排序的过程中，她的排序只是两两相邻的排序过程，

不是从“小”到“大”的排序，相当于冒泡排序只排了一次。

例如： [3，32,321]---->(只进行从头到尾两两排序结果)[32,321,3]

但是正确结果应该是[321,32,3]，原因是32与321未进行排序。

一下为在源代码基础上做的修改：

/**
 * @author  srzh
 * @version  给定一个整型数组，对这个整数数组排序，使得按序拼接数组各元素得到的值最小。
 *          示例：[3,83,8,13,1],被排序之后的数组为[1,13,3,83,8]。 依次拼接得到最小的数1133838。
 */
public class IntSort {
    
    public static boolean  ComString(String str1,String str2)//是否交换
    {
        int s1=Integer.parseInt(str1);
        int s2=Integer.parseInt(str2);
        int stm1 = 1, stm2 = 1;
        for (int k = 0; k < str1.length(); k++) {
            stm1 *= 10;
        }
        
        for (int k = 0; k < str2.length(); k++) {
            stm2 *= 10;
        }
        if((s1*stm2+s2)>(s2*stm1+s1))
              return true;
        else  return false;
               
    }

    
    public static void main(String[] args) {
        int[] array = new int[] {1,13,3,83,8};
        String[] strings = new String[array.length];
        System.out.println("---初始数组元素---");
        for (int i = 0; i < array.length; i++) {
            strings[i] = Integer.toString(array[i]);
            System.out.print(strings[i]+"  ");
        }
        System.out.print("
");
        //冒泡排序,按字典顺序排列
        for (int i = 0; i < strings.length - 1; i++) {
            for (int j = 0; j < strings.length - i - 1; j++) {
                if (strings[j].compareTo(strings[j + 1]) > 0) {
                    String temp = strings[j];
                    strings[j] = strings[j + 1];
                    strings[j + 1] = temp;
                }
            }
        }
        System.out.println("---完成字典排序---");
        for (int i = 0; i < strings.length; i++) {
            System.out.print(strings[i]+"  ");
        }
        //进行二次排序 
        int s=1;
        for (int i = 0; i < strings.length - 1; i++) {
            
            while((i+s)<strings.length&&strings[i].charAt(0)==strings[i+s].charAt(0) )
                  ++s;
            s--;
            for(int j=0;j<s;j++)
                for(int m=1;m<=(s-j);m++)
                    if(ComString(strings[i+j],strings[i+j+m]))
                    {
                        
                        String temp = strings[i+j];
                        strings[i+j] = strings[i+j+m];
                        strings[i+j+m] = temp;
                    }
            i=i+s+1;
        }
        System.out.println("
---完成二次排序---");
        for (int i = 0; i < strings.length; i++) {
            System.out.print(strings[i]+"  ");
        }        
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < strings.length; i++) {
            sb.append(strings[i]);
        }
        System.out.println("
---输出排序结果---");
        System.out.println(sb);
    }

}

输出结果：

---初始数组元素---
1 13 3 83 8
---完成字典排序---
1 13 3 8 83
---完成二次排序---
1 13 3 83 8
---输出排序结果---
1133838