考思维，拼数组问题

Question

填充9只是为了方便做而已，不然你每一位都要再排序一下如果不用我说的方法，你可以考虑用类似基数排序的算法，将基数排序反过来用如果填充9了 就可以按字典序排序直接出拼接方案了比如 98 9 988
按2L做法是错误的
按4L做法就不得不取出每一位如果填充9 的话98  -> 989
9   -> 999
988 -> 988
按字典序倒序排列 999 989 988  还原为原本的数字，那么顺序就是 9 98 988
最后拼接结果就是 998988 最大

Answer 1

按照你的这种说法 
应该是 "9">"12" "9">"4" "4">"12" 
1.想办法消除重复，
2，比较整数的首位，首位大就说明数值大，如果首位相等，继续比较次位，次位大则数值大，依次类推由于这里我充分利用java提供的API，示例代码：
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;class IntegerCompareComparator implements Comparator {
    public int compare(Object i, Object j) {// 实现接口方法，必须遵循比较规则
// 比较整数的首位，首位大就说明数值大，如果首位相等，继续比较次位，次位大则数值大，依次类推
return i.toString().compareTo(j.toString()) > 0 ? 1 : (i.toString()
.compareTo(j.toString()) == 0 ? 0 : -1);
    }
}public class ReadLine {    public static void main(String[] args) {
int integers[] = { 9, 12, 4 };
TreeSet sortset = new TreeSet<Integer>(new IntegerCompareComparator());// 添加比较器
for (int i = 0; i < integers.length; i++) {
    sortset.add(integers[i]);// TreeSet自动会消除重复，还能根据比较器排序
} String tempString = "";
// 最先遍历的是最小的 比如 12 4 9
for (Iterator<Integer> iterator = sortset.iterator(); iterator
.hasNext();) {
    Integer i = iterator.next();
    tempString = i.intValue() + tempString;// 构建字符串，右边为“最小”的整数
}
int i = Integer.parseInt(tempString);
System.out.println(i);//output    }
}
/*output:
9412
 */

Answer 2

先把代码弄出来再说public class FindMaxTest
{
public static void main(String[] args)
{
int[] buf = {9, 12, 4};
findMax(buf);
}

public static void findMax(int[] buf)
{
Record[] record = new Record[buf.length];

for (int i = 0; i < buf.length; i++)
{
record[i] = new Record(buf[i], buf[i]);
while (record[i].flag >= 10)
{
record[i].flag %= 10;
}
}

Arrays.sort(record);

String s = "";
for (int i = record.length - 1 ; i >= 0; i--)
{
s += record[i].original + "";
}

System.out.println("最大的自然数是：" + Integer.parseInt(s));
}
}class Record implements Comparable<Record>
{
int original, flag;

public Record(int original, int flag)
{
this.original = original;
this.flag = flag;
} @Override
public int compareTo(Record r)
{
return this.flag - r.flag;
}
}

Answer 3

填充9也不对，比如说“78 7 788”，按照你的说法
78  -> 789
7   -> 799
788 -> 788
按字典倒序排列：799 789 788; 还原之后为： 7 78 788
可答案应该是 788 78 7

Answer 4

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
//我在第8楼已经补充了说明：
//如果“123”和“12”比较（"12"只能比较两次）；这时的大小决定于位数，将会是"123">"12"
//既然你认为是多位数还要进行比较，那就稍微修改一下：
class IntegerCompareComparator implements Comparator {
    public int compare(Object i, Object j) {// 实现接口方法，必须遵循比较规则
// 比较整数的首位，首位大就说明数值大，如果首位相等，继续比较次位，次位大则数值大，依次类推 String temp1 = i.toString();
String temp2 = j.toString();
int len1 = temp1.length();
int len2 = temp2.length();

if (len1 == len2)
    return i.toString().compareTo(j.toString()) > 0 ? 1 : (i.toString()
    .compareTo(j.toString()) == 0 ? 0 : -1); else if (len1 > len2) {
    String temp = temp1.substring(0, len2);
    if (temp.equals(temp2)) {
return temp1.charAt(len2) - temp1.charAt(len2 - 1);
    } else
return i.toString().compareTo(j.toString()) > 0 ? 1 : (i
.toString().compareTo(j.toString()) == 0 ? 0 : -1); } else {
    String temp = temp2.substring(0, len1);
    if (temp.equals(temp1)) {
return temp2.charAt(len1) - temp2.charAt(len1 - 1);
    } else
return i.toString().compareTo(j.toString()) > 0 ? 1 : (i
.toString().compareTo(j.toString()) == 0 ? 0 : -1);
}    }
}public class ReadLine {    public static void main(String[] args) { System.out.println("1234".compareTo("12"));
int integers[] = { 9, 12, 4,78,786 };
TreeSet sortset = new TreeSet<Integer>(new IntegerCompareComparator());// 将比较器也添加进去
for (int i = 0; i < integers.length; i++) {
    sortset.add(integers[i]);// 自动会消除重复
} String tempString = "";
// 最先遍历的是最小的 比如 12 4 9
for (Iterator<Integer> iterator = sortset.iterator(); iterator
.hasNext();) {
    Integer i = iterator.next();
    tempString = i.intValue() + tempString;// 构建字符串，右边为“最小”的整数
}
int i = Integer.parseInt(tempString);
System.out.println(i);//output    }
}
/*output:
978786412
 */

Answer 5

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
//上面的程序还是写得比较啰嗦，所以简化一下，能达到一样的效果class IntegerCompareComparator implements Comparator {
    public int compare(Object o1, Object o2) {// 实现接口方法，必须遵循c此比较规则
// 比较整数的首位，首位大就说明数值大，如果首位相等，继续比较次位，次位大则数值大，依次类推
String temp1 = o1.toString();
String temp2 = o2.toString();
int len1 = temp1.length();
int len2 = temp2.length();
int i=0,j=0;
for(; i<len1&&i<len2; i++){
    if(temp1.charAt(i)>temp2.charAt(i)) return 1;//o1>o2
    else if(temp1.charAt(i)<temp2.charAt(i)) return -1;//o1<o2
    //相等的时候往后边比较
}
if(i == len1 && i==len2){//o1,o2长度相等
    return 0;//所有字符都相等
}
else if(i==len1){//o2要长
    if(temp2.charAt(i) > temp2.charAt(i-1)) return -1;//o1<o2
    else  return 1;//o1>o2
}
else {//o1要长
    if(temp1.equals("786")&&temp2.equals("78"))System.out.println(temp1.charAt(i) +"   " + temp1.charAt(i-1));
    if(temp1.charAt(i) < temp1.charAt(i-1)) return -1;//o1<o2
    else  return 1;//o1>o2
}

    }
}public class ReadLine {    public static void main(String[] args) {
int integers[] = { 9, 12, 4,765,76 };
TreeSet sortset = new TreeSet<Integer>(new IntegerCompareComparator());// 将比较器也添加进去
for (int i = 0; i < integers.length; i++) {
    sortset.add(integers[i]);// 自动会消除重复
} String tempString = "";
// 最先遍历的是最小的 比如 12 4 9
for (Iterator<Integer> iterator = sortset.iterator(); iterator
.hasNext();) {
    Integer i = iterator.next();
    tempString = i.intValue() + tempString;// 构建字符串，右边为“最小”的整数
}
int i = Integer.parseInt(tempString);
System.out.println(i);//output    }
}
/*output:
978786412
 */

Answer 6

import java.util.*;
//不过改起来也很简单，只要把Set改为ArrayList就OK了class IntegerCompareComparator implements Comparator {
    public int compare(Object o1, Object o2) {// 实现接口方法，必须遵循c此比较规则
// 比较整数的首位，首位大就说明数值大，如果首位相等，继续比较次位，次位大则数值大，依次类推
String temp1 = o1.toString();
String temp2 = o2.toString();
int len1 = temp1.length();
int len2 = temp2.length();
int i=0,j=0;
for(; i<len1&&i<len2; i++){
    if(temp1.charAt(i)>temp2.charAt(i)) return 1;//o1>o2
    else if(temp1.charAt(i)<temp2.charAt(i)) return -1;//o1<o2
    //相等的时候往后边比较
}
if(i == len1 && i==len2){//o1,o2长度相等
    return 0;//所有字符都相等
}
else if(i==len1){//o2要长
    if(temp2.charAt(i) > temp2.charAt(i-1)) return -1;//o1<o2
    else  return 1;//o1>o2
}
else {//o1要长
    if(temp1.equals("786")&&temp2.equals("78"))System.out.println(temp1.charAt(i) +"   " + temp1.charAt(i-1));
    if(temp1.charAt(i) < temp1.charAt(i-1)) return -1;//o1<o2
    else  return 1;//o1>o2
}
    }
}public class ReadLine {
    public static void main(String[] args) {
int integers[] = { 56,56,564 };
ArrayList arrayList = new ArrayList();
for (int i = 0; i < integers.length; i++) {
    arrayList.add(integers[i]);
}
Collections.sort(arrayList,new IntegerCompareComparator());
String tempString = "";
// 最先遍历的是最小的 比如 12 4 9
for (Iterator<Integer> iterator = arrayList.iterator(); iterator
.hasNext();) {
    Integer i = iterator.next();
    tempString = i.intValue() + tempString;// 构建字符串，右边为“最小”的整数
}
int i = Integer.parseInt(tempString);
System.out.println(i);//output
    }
}
/*output:
5656564
 */

Answer 7

class IntegerCompareComparator implements Comparator {
    public int compare(Object o1, Object o2) {
String temp1 = o1.toString();
String temp2 = o2.toString();
int len1 = temp1.length();
int len2 = temp2.length();
int i=0,j=0;
for(; i<len1&&i<len2; i++){
    if(temp1.charAt(i)>temp2.charAt(i)) return 1;//o1>o2
    else if(temp1.charAt(i)<temp2.charAt(i)) return -1;//o1<o2
    //相等的时候往后边比较
}
if(i == len1 && i==len2){//o1,o2长度相等
    return 0;//所有字符都相等
}
else if(i==len1){//o2要长
    if(temp2.charAt(i) > temp2.charAt(0)) return -1;//o1<o2 //把i-1 改成 0
    else  return 1;//o1>o2
}
else {//o1要长
    if(temp1.equals("786")&&temp2.equals("78"))System.out.println(temp1.charAt(i) +"   " + temp1.charAt(i-1));
    if(temp1.charAt(i) < temp1.charAt(0)) return -1;//o1<o2//把i-1 改成 0
    else  return 1;//o1>o2
}
    }
}public class ReadLine {
    public static void main(String[] args) {
int integers[] = { 56, 85, 856 };
ArrayList arrayList = new ArrayList();
for (int i = 0; i < integers.length; i++) {
    arrayList.add(integers[i]);
}
Collections.sort(arrayList,new IntegerCompareComparator());
String tempString = "";
for (Iterator<Integer> iterator = arrayList.iterator(); iterator
.hasNext();) {
    Integer i = iterator.next();
    tempString = i.intValue() + tempString;
}
int i = Integer.parseInt(tempString);
System.out.println(i);//output
    }
}
/*output:将comparator中改为 i-1 改为 下标0 ，刚才切换包的时候乱了一套。
8585656
 */

Answer 8

其实就是个排序问题，给出两个数，只要决定谁排在前面就可以了。import java.util.Arrays;
import java.util.Comparator;
public class MyMain {
public static void main(String[] args) {
Integer[] a = {23,56,11,141234,343,1234};
MyComp myComp = new MyComp();
Arrays.sort(a,myComp);
System.out.println(Arrays.toString(a));
}
}
class MyComp implements Comparator<Integer>{
public int compare(Integer o1, Integer o2) {
String s1 = String.valueOf(o1);
String s2 = String.valueOf(o2);
int a = Integer.parseInt(s1 + s2);
int b = Integer.parseInt(s2 + s1);
return b - a;
}
}