最大数目，允许一次交换

这个主题要讨论的是如何在允许一次交换的情况下，使得一个数组中的数字组成的最大数尽可能大。我们假设数组中的数字都是非负整数。

算法设计

我们首先来分析一下问题的性质。对于一个数字，则在它的高位上的数字越大，这个数字就越大。因此，我们需要对数组中的数字进行排序。但排序可能会改变数组中数字的相对次序，因此我们需要找到一种排序方式，使得排序后仍然能够保留原来数字的相对次序。

假设有两个数字 A 和 B，它们的十进制表示分别是 a1a2...an 和 b1b2...bm。我们需要比较它们谁更大。

当 a1>b1 时，A 更大；当 a1<b1 时，B 更大。这是显然的。

当 a1=b1 时，我们需要比较 a2 和 b2 的大小。这时要分为两种情况：

• 当 a2>b2 时，我们可以把 a 放到 B 的前面，使得结果更大。
• 当 a2<b2 时，我们可以把 b 放到 A 的前面，使得结果更大。

以此类推，直到某一个数的所有位数都比另一个数大，那么这个数就更大。

我们可以看到，这是一种特殊的排序方式，叫做字典排序。我们只需要实现一种可以按照字典排序方式比较两个数的函数，就可以对数组进行排序了。排完序后，我们将数组中的数字按顺序拼接起来，就是最大的数字了。

我们需要特别注意一些细节问题，比如：

• 如果数组中全是 0，则最大的数字应该是 0。
• 如果数组中有重复的数字，应该只按照一次计算。比如 [1,2,2,3] 最大的数字应该是 3212，而不是 3221。

算法实现

以下是 Java 代码实现，时间复杂度 O(n log n)：

class Solution {
    public String largestNumber(int[] nums) {
        String[] numStrs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            numStrs[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(numStrs, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return (b + a).compareTo(a + b);
            }
        });
        if (numStrs[0].equals("0")) {
            return "0";
        }
        StringBuilder sb = new StringBuilder();
        for (String numStr : numStrs) {
            sb.append(numStr);
        }
        return sb.toString();
    }
}

上面的代码使用了字符串比较来实现字典排序。这里还有一个使用 lambda 表达式的版本：

class Solution {
    public String largestNumber(int[] nums) {
        String[] numStrs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            numStrs[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(numStrs, (a, b) -> (b + a).compareTo(a + b));
        if (numStrs[0].equals("0")) {
            return "0";
        }
        StringBuilder sb = new StringBuilder();
        for (String numStr : numStrs) {
            sb.append(numStr);
        }
        return sb.toString();
    }
}

算法分析

这个算法的时间复杂度是 O(n log n)，因为涉及到了排序操作。空间复杂度是 O(n)，因为我们需要把整个数组都转换成字符串并存起来。

需要注意的是，由于使用了字符串比较，实际的比较操作比较耗时。因此，如果数据量很大，可能会超时。这时可以考虑实现一个自定义比较器，使用快速排序等算法来进行排序。