LeetCode 179. 最大数 & 剑指Offer: 45 把数组排成最小的数（Java解法）

剑指 Offer: 45 把数组排成最小的数；

LeetCode: 179. 最大数

https://leetcode-cn.com/problems/largest-number/

这两题看着名字不一样，其实思想是一样的，都是寻找一种排序的规则，然后把排序好的数组的元素进行逐个拼接。
重点就在寻找一个排序规则。
我原来的思想是按照各种数字的大小的比较顺序，写的及其的复杂，这个思路当时写的，我现在看着都有点想不起来当时是怎么想的了。后来多次提交后，觉得绝望了。。

截图为证，我当时真的是。。当时就卡在了最后那个测试例子上

当时的那个排序的逻辑，超级复杂，我现在自己看起来，因为当时写的着急，没有注释，现在我自己看起来说不清楚了：

以下是没有work的代码（就是错误代码），看不懂的就跳过好了：

class Solution {
    public String largestNumber(int[] nums) {
        StringBuilder ans = new StringBuilder();
		if (nums==null || nums.length==0) {
			return ans.toString();
		}
        ArrayList<String> list = new ArrayList<String>();
        for (int item : nums) {
            list.add(item + "");
        }
        list.sort(new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				char o1First = o1.charAt(0);
				char o2First = o2.charAt(0);
				while (o1.length() > 0 && o2.length() > 0) {
					if (o1.charAt(0) != o2.charAt(0)) {
						return o2.charAt(0) - o1.charAt(0);
					} else {
						if (o1.length() == 1 && o2.length() > 1) {
							int count = 1;
							while (count < o2.length() && o2.charAt(count) == o1First) {
								count++;
							}
							if (count == o2.length()) {
								return o1.length() - o2.length();
							}
							return o2.charAt(count) - o1First;
						} else if (o1.length() > 1 && o2.length() == 1) {
							int count = 1;
							while (count < o1.length() && o1.charAt(count) == o2First) {
								count++;
							}
							if (count == o1.length()) {
								return o1.length() - o2.length();
							}
							return o2First - o1.charAt(count);
						} else {
							o1 = o1.substring(1);
							o2 = o2.substring(1);
						}
					}
				}
				return 0;
			}
			
		});
        for (String item : list) {
        	System.out.println(item);
        	ans.append(item);
        }
        String ansString = ans.toString();
        while (ansString.length() > 1) {
        	if (ansString.charAt(0) == '0') {
        		ansString = ansString.substring(1);
        	} else {
				break;
			}
        }
        return ansString;
    }
}

虽然只剩下了最后的两个例子了，但是我开始思考，是不是我的思路出现了问题，可能不是进行比数字的。
就开始闭目思考，突然灵光一闪：为什么不进行两个数字直接拼接后的对位比较大小，然后进行排序？
这个想法两个比较的时候当然是可行的，但是是否具有传递性就不得而知了。但是不影响我们先试试看呗。
后来看看直接两个数进行不同的前后位置的拼接，位数相同，接下来我们要考虑的是比较的方式的问题，一般来说，我们有两种比较方式：
（1）转化为整型，然后进行两个数字的比较方法；
（2）还有一种就是，转化为字符串，然后进行对位比较.
其实一般题目做的多了，我们的第一选择一般是第二个。因为第二个比较方式不会受到大数的影响。因为我们已经知道了两个被比较的数字肯定是一样的位数：所以我们用下面这这段代码就可以完成：

String o1o2 = o1 + o2;
String o2o1 = o2 + o1;
for (int i = 0, len = o1o2.length(); i < len; ++i) {
  if (o1o2.charAt(i) > o2o1.charAt(i)) {
    return -1;
  } else if (o1o2.charAt(i) < o2o1.charAt(i)) {
    return 1;
  }
}

还有一点，这题其实涉及一个比较复杂的数学证明，因为要符合传递性才可以证明这个思路可行。
我这里是经过很多个实例的比较的比较才推测出的结果，每个经过数学的证明，虽然正确，却不完整。
ＳＨＯＷ　ＴＨＥ　ＣＯＤＥ

class Solution {
    public String largestNumber(int[] nums) {
        StringBuilder ans = new StringBuilder();
        if (nums==null || nums.length==0) {
            return ans.toString();
        }
        ArrayList<String> list = new ArrayList<String>();
        for (int item : nums) {
            list.add(item + "");
        }
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                String o1o2 = o1 + o2;
                String o2o1 = o2 + o1;
                for (int i = 0, len = o1o2.length(); i < len; ++i) {
                    if (o1o2.charAt(i) > o2o1.charAt(i)) {
                        return -1;
                    } else if (o1o2.charAt(i) < o2o1.charAt(i)) {
                        return 1;
                    }
                }
                return 0;
            }
        });
        for (String item : list) {
            System.out.println(item);
            ans.append(item);
        }
        String ansString = ans.toString();
        while (ansString.length() > 1) {
            if (ansString.charAt(0) == '0') {
                ansString = ansString.substring(1);
            } else {
                break;
            }
        }
        return ansString;
    }
}