最大数

class Solution
{
public:
    /**
     * 最大数
     * @param nums int整型vector
     * @return string字符串
     */
    string solve(vector<int> &nums)
    {
        // write code here
        vector<string> a;
        for (auto &s : nums)
            a.push_back(to_string(s));

        sort(a.begin(), a.end(), cmp);

        string s;
        for (auto &ch : a)
            s = s + ch;

        if (s[0] == '0')
            s = "0";

        return s;
    }

    static bool cmp(string a, string b)
    {
        return a + b > b + a;
    }
};

思路：来自于别人的思想，如果有不对的地方请指出

类似于冒泡，从数组中拿出a和b，转化成String，组合成ab，ba然后再转化为整数类型， 比较大小。一只冒泡到最后，把能组成最大值的放在前面,最后全部合起来转化为一个string返回即可。

// 函数入口
public String maxStr(int[] arr){
    // 边界值
    if (arr == null || arr.length == 0) return "";
    // 开始冒泡
    for (int i = 0; i < arr.length - 1; ++i){
        for (int j = 0; j < arr.length - i - 1; ++j){
            // 把int转为String
            String a = String.valueOf(arr[j]); // 也可以直接 arr[j] + "" ,我这里不知道两个的速度比较
            String b = String.valueOf(arr[j + 1]);  // 就随便用了
            String sum1 = a + b,sum2 = b + a;
            if (!compare(sum1,sum2)) {
                // 交换
                swap(arr,j,j + 1);
            }
        }
    } 
    // 换完之后，结果是能组成最大的数都在前面，所以转化为一个String返回即可
    String res = "";
    for (int i = 0; i < arr.length ;++i){
        res += (arr[i] + "");
    }
    return res;
}
// 比较ab，ba大小 ，sum1是  ab ,sum2 是ba
public boolean compare(String sum1, String sum2){
    int i = Integer.parseInt(sum1),j = Integer.parseInt(sum2);
    return i >= j?  true : false;
}
// 交换
public void swap(int[] arr,int i ,int j ){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

class Solution {
public:
    /**
     * 最大数
     * @param nums int整型vector 
     * @return string字符串
     */
    static bool cmp(string &a, string& b){
        return a+b>b+a;
    }
    string solve(vector<int>& nums) {
        // write code here
        vector<string>vec;
        //将整型的数字转化为字符串
        for(int i=0;i<nums.size();i++){
            vec.push_back(to_string(nums[i]));
        }
        //排序
        sort(vec.begin(),vec.end(),cmp);
        if(vec[0]=="0") return "0";
        
        string res="";
        for(int i=0;i<vec.size();i++){
            res+=vec[i];
        }
        return res;
    }
};

class Solution {
public:
    /**
     * 最大数
     * @param nums int整型vector 
     * @return string字符串
     */
    static bool cmp(string a, string b){
        if((a+b) > (b+a)){
            return true;
        }
        else{
            return false;
        }
    }
    string solve(vector<int>& nums) {
        // write code here
        if(nums.size() == 0) return "0";
        vector<string> s;
        for(int i = 0; i < nums.size(); ++i){
            s.push_back(to_string(nums[i]));
        }
        sort(s.begin(), s.end(), cmp);
        if(s[0] == "0") return "0";
        string res = "";
        for(int i = 0; i < s.size(); ++i){
            res += s[i];
        }
        return res;
    }
};

import java.util.*;


public class Solution {
    /**
     * 最大数
     * @param nums int整型一维数组 
     * @return string字符串
     */
    public String solve (int[] nums) {
        String[] strArr = new String[nums.length];
        for (int i = 0 ; i < nums.length ;i++){
            strArr[i]= String.valueOf(nums[i]);
        }
        Arrays.sort(strArr, (o1, o2) -> Integer.parseInt(o2+o1) - Integer.parseInt(o1+o2));
        StringBuilder maxString = new StringBuilder();
        if(strArr[0].equals( "0")){
            return "0";
        }
        for (int i = 0 ; i < strArr.length;i++){
            
            maxString.append(strArr[i]);
        }
        return maxString.toString();
        // write code here
    }
}

import java.util.*;
 
 
public class Solution {
    /**
     * 最大数
     * @param nums int整型一维数组 
     * @return string字符串
     */
    public String solve (int[] nums) {
        // write code here
        //冒泡排序，降序排列，小的数往后冒
        for(int i = 0; i < nums.length; i++){
            for(int j = 0; j < nums.length - i - 1; j++){
                //数值排序时，考虑十位数与个位数的拼接
                
                //保存拼接的字符串，拼接字符串
                String a = String.valueOf(nums[j]);
                String b = String.valueOf(nums[j+1]);
                String sum1 = a+b,sum2 = b+a;
                
                //转换成基本数据类型才能比较
                int temp1 = Integer.parseInt(sum1),temp2=Integer.parseInt(sum2);
                
                //若temp1>temp2，则说明a（nums[j]）在拼接时放在前面，nums[j]与nums[j+1]不用交换
                //若temp1<temp2，则说明b（nums[j+1]）在拼接时放在前面，发生交换
                if(temp1<temp2){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        
        String str = new String();
        for(int i = 0; i < nums.length; i++){
            str += nums[i];
        }
        if(str.length()!=0 && str.charAt(0) == '0'){
            return "0";
        }else{
            return str;
        }
         
    }

    
}

public String solve (int[] nums) {
    // write code here
    StringBuilder res=new StringBuilder();
    PriorityQueue<Integer> queue=new PriorityQueue<Integer>(new Comparator<Integer>(){
        @Override
        public int compare(Integer num1 ,Integer num2){
            return (num2+""+num1).compareTo(num1+""+num2);
        }
    });
    for(int num:nums){
        queue.add(num);
    }
    while(!queue.isEmpty()){
        res.append(queue.poll());
    }
    return res.charAt(0)=='0'?"0":res.toString();
}

package main

import "strconv"
import "sort"
import "strings"

/**
 * 最大数
 * @param nums int整型一维数组 
 * @return string字符串
*/
func solve( nums []int ) string {
    arr:=[]string{}
    for _,x:=range nums{
        arr=append(arr,strconv.Itoa(x))
    }
    sort.Slice(arr,func(i,j int)bool{
        if arr[i]+arr[j]>arr[j]+arr[i]{
            return true
        }
        return false
    })
    for arr[0]=="0"&&len(arr)>1{
        arr=arr[1:]
    }
    return strings.Join(arr,"")
}