剑指--把数组排成最小的数

剑指–把数组排成最小的数

1，题目：

2，思路：

方法一：用List，实质也是排序：

• 通过在排序时传入一个自定义的 Comparator 实现，重新定义 String 列表内的排序方法，
• 若拼接 s1 + s2 > s2 + s1，那么显然应该把 s2 在拼接时放在前面，
• 以此类推，将整个 String 列表排序后再拼接起来。

方法二：自定义排序：

• 1,初始化： 字符串列表 strs ，保存各数字的字符串格式；

• 2,列表排序： 应用以上 “排序判断规则” ，对 strs 执行排序；

  • x+y > y+x 则,x>y

  • x+y < y+x 则,x<y

• 3,返回值： 拼接 strs 中的所有字符串，并返回。

方法三：用内置函数：

Arrays.sort(strs, (x, y) -> (x + y).compareTo(y + x));

其中补充的：

• 默认升序排列：Arrays.sort(b);
• 降序：Arrays.sort(b, (x,y) ->y.compareTo(x));

3，代码：

方法一：用List，实质也是排序：

//用的list，其实实质也是排序，先排序在拼接
/*
通过在排序时传入一个自定义的 Comparator 实现，重新定义 String 列表内的排序方法，
若拼接 s1 + s2 > s2 + s1，那么显然应该把 s2 在拼接时放在前面，
以此类推，将整个 String 列表排序后再拼接起来。


*/
class Solution {
    public String minNumber(int[] nums) {
        List<String> strList = new ArrayList<>();
        for (int num : nums) {
            strList.add(String.valueOf(num));//先转换成字符数组
        }
        strList.sort((s1, s2) -> (s1 + s2).compareTo(s2 + s1));//用这个比较器（降序）
        StringBuilder sb = new StringBuilder();
        for (String str : strList) {
            sb.append(str);
        }
        return sb.toString();
    }
}

方法二：自定义排序：

class Solution {
    public String minNumber(int[] nums) {
        /*
    1,初始化： 字符串列表 strs ，保存各数字的字符串格式；
    2,列表排序： 应用以上 “排序判断规则” ，对 strs 执行排序；
          x+y > y+x 则,x>y
          x+y < y+x 则,x<y
    3,返回值： 拼接 strs 中的所有字符串，并返回。
*/


        String[] strs = new String[nums.length];
        for(int i = 0; i < nums.length; i++)
            strs[i] = String.valueOf(nums[i]);//数值转换成字符串
        fastSort(strs, 0, strs.length - 1);
        StringBuilder res = new StringBuilder();
        for(String s : strs)
            res.append(s);
        return res.toString();
    }
    void fastSort(String[] strs, int l, int r) {
        if(l >= r) return;
        int i = l, j = r;
        String tmp = strs[i];
        while(i < j) {
            //x+y > y+x 则,x>y
            //x+y < y+x 则,x<y
            while((strs[j] + strs[l]).compareTo(strs[l] + strs[j]) >= 0 && i < j) 
                j--;//以此循环，找出strs[j] < strs[l]的此时的j，此时j指向30
            while((strs[i] + strs[l]).compareTo(strs[l] + strs[i]) <= 0 && i < j) 
                i++;//以此循环，找出strs[i] > strs[l]的此时的j，此时i指向30
            tmp = strs[i];
            strs[i] = strs[j];
            strs[j] = tmp;
        }
        strs[i] = strs[l];
        strs[l] = tmp;//这时候确定了i的位置
        fastSort(strs, l, i - 1);
        fastSort(strs, i + 1, r);
    }
}

方法三：用内置函数：

class Solution {
    public String minNumber(int[] nums) {
        String[] strs = new String[nums.length];
        for(int i = 0; i < nums.length; i++) 
            strs[i] = String.valueOf(nums[i]);
        Arrays.sort(strs, (x, y) -> (x + y).compareTo(y + x));
        StringBuilder res = new StringBuilder();
        for(String s : strs)
            res.append(s);
        return res.toString();
    }
}