把数组排成最小的数

题目

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

解题

对两个数a、b拼成一个数c
c的可能只有两种：ab或者bc
题目要求拼成的数最小，选取ab、bc中最小的那个数作为答案
当有三个数的时候：a、b、c
拼接方式有六种：abc、acb、bac、bca、cab、cba
可以这样考虑：
先拼接其中两个数使得拼成的数最小，最后拼成的数和其余数进行拼接，使得拼成的数最小
这是一个递归的过程
当有n个数的时候，选取两个数使得拼成后的这两个数最小，这里时间复杂度是$O(N^2)$

import java.util.*;

import java.util.ArrayList;

public class Solution {
    public static void main(String []args){
        int[] p = new int[]{3,5,1,4,2};
        Solution s = new Solution();
        String res = s.PrintMinNumber(p);
        System.out.println(res);

    }


    public String PrintMinNumber(int [] numbers) {
        String result = "";
        if(numbers == null || numbers.length == 0)
            return result;
        ArrayList<Integer> A = new ArrayList<Integer>();
        for(int num:numbers){
            A.add(num);
        }
        while(A.size()!=1){
            toMinNumbers(A);
            for(int a:A){
                System.out.print(a+"\t");
            }
            System.out.println();
        }
        return A.get(0)+"";
    }
    public void toMinNumbers(ArrayList<Integer> A){

        int size = A.size();
        int aId = -1;
        int bId = -1;
        int a,b;
        int min = Integer.MAX_VALUE;
        for(int i=0;i<size;i++){
            a = A.get(i);
            for(int j = i+1;j<size;j++){
                b = A.get(j);
                int ab = join(a,b);
                if(ab< min){
                    aId = i;
                    bId = j;
                    min = ab;
                }
                int ba = join(b,a);
                if(ba< min){
                    aId = j;
                    bId = i;
                    min = ba;
                }   
            }
        }
        // 先去除大的的id
        if(aId<bId){
            A.remove(bId);
            A.remove(aId);
        }else{
            A.remove(aId);
            A.remove(bId);
        }
        A.add(min);
    }
    public int joinStr(int a,int b){
        String l = a+"";
        String r = b+"";
        String lr = l + r;
        return Integer.valueOf(lr);
    }
    public int join(int a,int b){
        int n = 1;
        int tmpb= b;
        while(tmpb!=0){
            n *=10;
            tmpb/=10;
        }
        return a*n+b;
    }
}

然而上面程序提交是不对的
对数组：3,5,1,4,2
输出结果：

3   5   1   4   2
3   5   4   12  
5   12  34  
34  125 
12534   

每次根据合并后结果最小的进行合并，可以看出合并操作不是全局最小值的操作，这是因为其他数可能在合并的两个数中间。

局部最小值不是全局最小值，不能根据两个数合并的值大小来判断，问题的重点是谁应该在前谁应该在后。

当a在b前的时候，c可能在a、b的中间，所有不能立即将a、b合并，而应该确定a、b先后的位置，对c根据合并大小，放在a、b合适的位置。这样就是一个排序问题，排序规则要重新定义：比较的是a、b合并后的大小
快速排序算法

import java.util.ArrayList;

public class Solution {
    public String PrintMinNumber(int [] numbers) {
        String result = "";
        if(numbers == null || numbers.length == 0)
            return result;
        int left = 0;
        int right = numbers.length - 1;
        quickSort(numbers,left,right);
        for(int num:numbers){
            result +=num;
        }
        return result;
    }
    //快排
    public void quickSort(int[] numbers,int left,int right){
        if(left>right)
            return;
        int id = partition(numbers,left,right);
        quickSort(numbers,left,id-1);
        quickSort(numbers,id+1,right);

    }
    //划分id
    public int partition(int[] numbers,int left,int right){
        int x = numbers[right];
        int i = left - 1;
        for(int j = left ;j< right;j++){
            if(compare(numbers[j],x) <=0){
                i++;
                swap(numbers,i,j);
            }
        }
        i++;
        swap(numbers,i,right);
        return i;
    }
    // 交换
    public void swap(int[] numbers,int i,int j){
        int tmp = numbers[i];
        numbers[i] = numbers[j];
        numbers[j] = tmp;
    }
    // 比较规则
    public int compare(int a,int b){
        String l = a+"";
        String r = b+"";
        String lr = l + r;
        String rl = r + l;
        return lr.compareTo(rl);
    }

}