179. Largest Number（compare的一些思考）

题目链接：https://leetcode.com/problems/largest-number/

Given a list of non negative integers, arrange them such that they form the largest number.

Example 1:

Input: [10,2]
Output: "210"

Example 2:

Input: [3,30,34,5,9]
Output: "9534330"

Note: The result may be very large, so you need to return a string instead of an integer.

思路：

重写比较器，改为两个String比较大小。

然后再用Arrays.sort方法.

AC 4ms :

class Solution {
    public String largestNumber (int[] nums) {
        if(nums==null||nums.length==0)
            return "";
        String[] strs=new String[nums.length];
        for(int i=0;i<nums.length;i++){
            strs[i]=String.valueOf(nums[i]);
        }
        Comparator<String> com=new Comparator<String>(){
            @Override
            public int compare(String s1,String s2){
                return (s2+s1).compareTo(s1+s2);
            }
        };
        Arrays.sort(strs,com);
        if(strs[0].equals("0"))
            return "0";
        StringBuilder sb=new StringBuilder();
        for(String s:strs){
            sb.append(s);
        }
        return sb.toString();
    }
}

 补充：

至于为什么重写的compare方法的原因：

虽然32<321,但是32321>32132,所以32要排在321前面。所以在比较时会将ab与ba进行比较,

按照两数组合的降序进行排列。

按照这种比较规则，比如有[4,43,432,4321],以前两个元素为例，

输入时S1=“4”，S2=“43”。

O1=443（省去引号，下同）

O2=434；

443是大于434的，所以在String数组中，4和43的位置不发生交换。

最终排序结果为[4,43,432,4321].

再比如[1,2,3]

12小于21，在String数组中，1和2的位置发生交换（swap）,

最终排序结果为[3,2,1].

以上只是基于源码说了何时会触发数组元素的swap，具体的要比这复杂很多，有兴趣的可以去看sort相关源码。

仅仅从compare的宏观调用来看，它是根据返回值的 1,0，-1来决定输入的两个数组元素是否进行swap的。

测试1：

import java.util.*;
public class t {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer[] nums={1,2,3,4,5,6,7,8,9,0};
		String[] strs=new String[nums.length];
        for(int i=0;i<nums.length;i++){
            strs[i]=String.valueOf(nums[i]);
        }
        Comparator<String> com=new Comparator<String>(){
            @Override
            public int compare(String s1,String s2){
                String order1 = s1 + s2;
                String order2 = s2 + s1;
                return order2.compareTo(order1);//降序
            }
        };
        Arrays.sort(strs,com);
		for(String str:strs) {
			System.out.print(str+" ");
		}
	}

}

输出：9 8 7 6 5 4 3 2 1 0

 

测试2 ：

import java.util.*;
public class t {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer[] nums={4,43,432,4321,43210};
		String[] strs=new String[nums.length];
        for(int i=0;i<nums.length;i++){
            strs[i]=String.valueOf(nums[i]);
        }
        Comparator<String> com=new Comparator<String>(){
            @Override
            public int compare(String s1,String s2){
                String order1 = s1 + s2;
                String order2 = s2 + s1;
                return order2.compareTo(order1);//降序
            }
        };
        Arrays.sort(strs,com);
		for(String str:strs) {
			System.out.print(str+" ");
		}
	}

}

输出：4 43 432 4321 43210  

至于升序还是降序的问题，如果仅仅是对两个原始元素比较大小,比如 int a=1,int b=2;

或者String s1="wer",String s2="vfg",而不涉及两个变量的加减等操作的话，

这个升序或者降序 就对应 数组排序后的 升序或降序，不然就会出现不太符合直观预期的情况，

比如上面例子的降序输出  [4,43,432,4321,43210].

compareTo()用法；