把数组排成最小的数

输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

示例 1:
输入: [10,2]
输出: “102”
示例 2:
输入: [3,30,34,5,9]
输出: “3033459”
提示:
0 < nums.length <= 100
leetcode题目链接

解题思路：

此题求拼接起来的最小数字，本质上是一个排序的问题
设nums数组中任意两个数为x和y
有"xy">"yx"则x与y互换
例如数组3,32,37,9,1

• 332>323–>32,3,37,1,9
• 337<373 -->32,3,37,1,9
• 371>137–>32,3,1,37,9
• 379<937–>32,3,1,37,9

这是完成的第一遍循环，一眼看过去是不是发现1应该放在第一位呢…
或者说像这种依次遍历当大于时则交换的过程有点眼熟呢，对了，冒泡！

冒泡算法描述

1. 依次比较数组中相邻两个元素大小，若 a[j] > a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后
2. 重复以上步骤，直到整个数组有序

求拼接最小数的本质可以看成’xy’与’yx’的比较，接下来只是单纯排序算法的运用和拼接比较的技巧了。
这里展示的是冒泡排序，当然有兴趣的可以自己改成快排或者其他排序算法。

class Solution {
    public String minNumber(int[] nums) {
        String[] s = new String[nums.length];
        for(int i=0;i<nums.length;i++){
            s[i]=String.valueOf(nums[i]);
        }
        //优化后的冒泡排序
        int n = nums.length-1;
        while(true){
            int last = 0;
            String temp;
            for(int i=0;i<n;i++){
                if((s[i]+s[i+1]).compareTo(s[i+1]+s[i])>=0){
                    temp = s[i];
                    s[i] = s[i+1];
                    s[i+1] = temp;
                    last = i;
                }
            }
            n = last;
            if(n==0) break;
        }
        //拼接
        StringBuilder res = new StringBuilder();
        for(String str:s){
            res.append(str);
        }
        return res.toString();
    }
}

有人可能说这也不是冒泡呀
别急，接着看

普通冒泡

public static void bubble(int[] a) {
    for (int j = 0; j < a.length - 1; j++) {
        // 一轮冒泡
        for (int i = 0; i < a.length - 1 - j; i++) {
            if (a[i] > a[i + 1]) {
                Utils.swap(a, i, i + 1);
            }
        }
    }
}

• 优化点1：每经过一轮冒泡，内层循环就可以减少一次
• 优化点2：如果某一轮冒泡没有发生交换，则表示所有数据有序，可以结束外层循环

public static void bubble(int[] a) {
    for (int j = 0; j < a.length - 1; j++) {
        // 一轮冒泡
        boolean swapped = false; // 是否发生了交换
        for (int i = 0; i < a.length - 1 - j; i++) {
            if (a[i] > a[i + 1]) {
                Utils.swap(a, i, i + 1);
                swapped = true;
            }
        }
        if (!swapped) {
            break;
        }
    }
}

在这个基础上再进一步优化

• 每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为零，表示整个数组有序，直接退出外层循环即可

public static void bubble_v2(int[] a) {
    int n = a.length - 1;
    while (true) {
        int last = 0; // 表示最后一次交换索引位置
        for (int i = 0; i < n; i++) {
            if (a[i] > a[i + 1]) {
                Utils.swap(a, i, i + 1);
                last = i;
            }
        }
        n = last;
        if (n == 0) {
            break;
        }
    }
}