把数组排成最小的数

import java.util.*;

public class Solution {
    public String PrintMinNumber(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return "";
        }
        Integer[] nums = Arrays.stream(numbers).boxed().toArray(Integer[]::new);
        Arrays.sort(nums, (o1, o2) -> ("" + o1 + o2).compareTo("" + o2 + o1));
        StringBuilder sb = new StringBuilder();
        for (int num : nums) {
            sb.append(num);
        }
        return sb.toString();
    }
}

    /*
    思路：
    把各个数转为字符串，放到list里用Collections进行排序。
    小的放到前面，这样排序完后就是结果。
    
    定义compare的规则：
    由于每个字符串的长度不同，不能直接比较。
    但是可以去比较它们拼接后的字符串(c1=s1+s2.c2=s2+s1)
    举个例子，如s1=3,s2=32
    c小的要放到前面，也等价于对应的s也要放到前面。
    所以return c1.compareTo(c2)
    
    s1+s2  s2+s1  (s1+s2).compareTo(s2+s1)是关键
    */
    public String PrintMinNumber(int [] numbers) {
        ArrayList<String> list = new ArrayList<>();
        for(int i = 0;i < numbers.length;i++){
            //int转String，为String的静态方法，String.valueOf()
            list.add(String.valueOf(numbers[i]));
        }
        /*
        Collections.sort与Arrays.sort的区别：
        它们都可以定义comparator。
        它们的参数不同，Collections.sort的参数为list，
        而Arrays.sort的参数为数组。
        
        可以多用Colections.sort
        */
        //Comparator的包也要导入
        Collections.sort(list,new Comparator<String>(){
            //c小的放前面，与s的放置规则等价。
            @Override
            public int compare(String s1,String s2){
                return (s1+s2).compareTo(s2+s1);
            }
        });
        StringBuilder sb = new StringBuilder();
        for(String item : list){
            sb.append(item);
        }
        return sb.toString();
    }

import java.util.*;

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

import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Solution {
    public String PrintMinNumber(int[] nums) {
        return IntStream.of(nums).mapToObj(String::valueOf)
          .sorted((s1, s2) -> (s1 + s2).compareTo(s2 + s1))
          .collect(Collectors.joining());
    }
}

import java.util.ArrayList;

public class Solution {
    public String PrintMinNumber(int[] numbers) {

        int max = 0; // 最大位数

        // 找出最大位数
        for (int i = 0; i < numbers.length; i++) {
            int temp = numbers[i];
            int length = 0;
            while (temp != 0) {
                length++;
                temp /= 10;
            }
            if (length > max) {
                max = length;
            }
        }

        int[] clone = numbers.clone();

        // 补齐数位，比如32的个位是2，长度为3，那么我们就需要将其转化成322
        for (int i = 0; i < numbers.length; i++) {
            while (clone[i] /(int) Math.pow(10, max - 1) == 0) {
                clone[i] = clone[i] * 10 + clone[i] % 10;
            }
        }

        // 构建二维数组集合，第一个位置存clone[i],第二个位置为numbers[i]，相当于对应键找值。
        ArrayList<int[]> list = new ArrayList<>();

        for (int i = 0; i < clone.length; i++) {
            list.add(new int[]{clone[i],numbers[i]});
        }

        int[] temp = new int[clone.length];

        sort(clone, 0, clone.length - 1, temp);

        StringBuffer buffer = new StringBuffer();

        //对应clone找numbers
        for (int i = 0; i < clone.length; i++) {
            for (int j = 0; j < list.size(); j++) {
                if (list.get(j)[0] == clone[i]) {
                    buffer.append(list.get(j)[1]);
                    list.remove(list.get(j));
                }
            }
        }

        return buffer.toString();
    }

    //归并排序的实现
    private void sort(int[] arr, int left, int right, int[] temp) {

        int mid = (left + right) / 2;

        if (left < right) { //记住：这里是if，别再写while了
            sort(arr, left, mid, temp);
            sort(arr, mid + 1, right, temp);
            mergeSort(arr, left, mid, right, temp);
        }
    }

    private void mergeSort(int[] arr, int left, int mid, int right, int[] temp) {

        int i = left;
        int j = mid + 1;
        int index = left;

        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                temp[index++] = arr[i++];
            } else {
                temp[index++] = arr[j++];
            }
        }

        while (i <= mid) {
            temp[index++] = arr[i++];
        }

        while (j <= right) {
            temp[index++] = arr[j++];
        }

        while (left <= right) {
            arr[left] = temp[left++];
        }
    }
}

import java.util.ArrayList;

public class Solution {
    // 思路：按照其他题解，要合理的给numbers排序的话，首先要有合理的排序规则，
    // 即两数拼接时较小的情况的次序作为他们之间的大小顺序，
    // 下面是我对归并排序的变式来对这个思路进行优化。
    public String PrintMinNumber(int[] numbers) {

        int[] temp = new int[numbers.length];

        diffSort(numbers, 0, numbers.length - 1, temp);

        StringBuffer buffer = new StringBuffer();

        for (int i = 0; i < numbers.length; i++) {
            buffer.append(numbers[i]);
        }

        return buffer.toString();
    }

    private void diffSort(int[] numbers, int left, int right, int[] temp) {

        int mid = (left + right) / 2;

        if (left < right) {
            diffSort(numbers, left, mid, temp);
            diffSort(numbers, mid + 1, right, temp);
            diffMergeSort(numbers, left, mid, right, temp);
        }
    }

    private void diffMergeSort(int[] numbers, int left, int mid, int right, int[] temp) {

        int i = left;
        int j = mid + 1;
        int index = left;

        while (i <= mid && j <= right) {
            String a = String.valueOf(numbers[i]);
            String b = String.valueOf(numbers[j]);
            if (Integer.parseInt(a + b) < Integer.parseInt(b + a)) {
                temp[index++] = numbers[i++];
            } else {
                temp[index++] = numbers[j++];
            }
        }

        while (i <= mid) {
            temp[index++] = numbers[i++];
        }

        while (j <= right) {
            temp[index++] = numbers[j++];
        }

        while (left <= right) {
            numbers[left] = temp[left++];
        }
    }
}

public class Solution {
    public String PrintMinNumber(int [] numbers) {
        //首先要每一次筛选最高项的大小，选出最小的，进行数组的移动
        int[] result=new int[numbers.length];
        String str="";
        //首先获得数组中所有元素的最高位数
        int maxbit=0;
        for(int k=0;k<numbers.length;k++){
            int bitnum=getMaxbit(numbers[k]);
            if(maxbit<bitnum){
                maxbit=bitnum;
            }
        }
        
        int[] poll_array=Polish(numbers,maxbit);
        int counter=0;
        for(int m=0;m<poll_array.length;m++){//查到最小的数得到其下标，然后加入到result中
            int minindex=0;
            int minnum=poll_array[0];
            for(int n=0;n<poll_array.length;n++){
                if(poll_array[n]<minnum){
                    minnum=poll_array[n];
                    minindex=n;
                }
            }
            poll_array[minindex]*=10;
            result[counter]=numbers[minindex];//将获得的结果加入到result中
            counter++;
        }
        
        
        for(int i=0;i<result.length;i++){
            str+=result[i];
        }
        return str;
    }
    
    public int getMaxbit(int num){//得到数字的位数
        int div=1;
        int bit=0;
        while(num/div!=0){
            bit++;
            div*=10;
        }
        return bit;
    }
    
    //根据位数，不够位的按最后一位补齐
    public int[] Polish(int[] nums,int maxbits){
        int[] polishing_array=new int[nums.length];
        for(int i=0;i<nums.length;i++){
            int numbits=getMaxbit(nums[i]);
            int tempnum=nums[i];
            if(numbits<maxbits){
                int lastnum=nums[i]%10;
                for(int j=numbits;j<maxbits;j++){
                    tempnum=tempnum*10+lastnum;
                }
            }
            polishing_array[i]=tempnum;
        }
        return polishing_array;
    }
    
}