根据arr[i]之和对二维int数组从低到高排序

Question

我在对整数二维数组进行排序的作业中遇到了死胡同。

指令是创建一个采用二维 int 数组的函数 （不一定是矩阵）并根据内部数组的总和对外部数组进行排序。换句话说，数组的第一个索引应该是总和最小的内部数组。

示例 - 输入 - int[][] 数组 = {{2, 4, 1,9,9,9,9}, {6, 8}, {7, 3, 6, 5, 1}};

输出 - 数组 = {{6, 8}, {7, 3, 6, 5, 1}, {2, 4, 1,9,9,9,9}}；

到目前为止，我的逻辑是创建一个包含总和的新一维数组 来自主数组的每个内部数组。 并根据它进行排序。

public static int[] arraysCalculator(int[][] arr) { 
int[] sums = new int[arr.length];
int sum= 0;
for(int i = 0; i  < arr.length; i++)
{
    for(int j = 0; j < arr[i].length; j++)
    {
        sum += arr[i][j];
    }
    sums[i] = sum;
    sum = 0;
}

Answer 1

您可以通过流式传输然后调用sum() 轻松总结int[]。从那里，只需使用比较器调用Arrays.sort 来比较这个总和：

Arrays.sort(array, Comparator.comparingInt(a -> Arrays.stream(a).sum()));

Answer 2

你得到了三分之一。你现在需要什么：

• 在创建包含“内部”数组sums的第一个数组sums后，您只需创建该数组的精确副本，例如originalSums
• 那么，你排序sums的内容

例如：说sums 和originalSums 是[ 12, 3, 7]。排序后得到：

originalSums:[ 12, 3, 7]

sums:[ 3, 7, 12]

问题是：通过查看两个数组，您可以决定如何交换内部数组以匹配 sums 现在显示的顺序。

在上面的示例中，您注意到12 的原始索引为 0。排序后，它的索引为 2。因此您知道必须将内部数组“交换”为 0 和 2。您还可以推断3 应该转到索引 0，7 应该转到索引 2。

当然，确保交换成功仍然需要一些工作（就像您最好不要交换任何索引两次）。

让整个事情顺利进行的最基本方法是一次只查看一个索引（就像您进行某种冒泡排序一样）。

长话短说：有很多不同的方法可以解决这个问题。我建议你从最简单的路径开始。

Answer 3

除了其他出色地解释了理论并为解决您的任务奠定了基础的答案之外，这里还有一个完整的工作示例（带有关于每件事的作用和原因的详细文档） em> 希望能有所帮助：

/**
 * This method will sort the inner arrays of a given two dimensional array
 * from lowest to highest value according to the sum of it's elements.
 */
private static int[][] arrayCalc(int[][] arr)
{
    /*
     * We're working with a TreeMap here because this type
     * of map is allowed to have duplicate key entries
     */
    java.util.Map<Integer, Integer[]> map = new java.util.TreeMap<>();
    /*
     * This value represents the largest inner array
     * size found in 2d array passed as parameter
     */
    int largestSize = 0;
    for (int[] inner : arr) {
        /*
         * Convert the inner array to an array of Integer
         * objects so it can be placed inside a map
         */
        Integer[] integers = IntStream.of(inner).boxed().toArray(Integer[]::new);
        map.put(IntStream.of(inner).sum(), integers);
        /*
         * Check if this inner array has a larger value
         * then the largest array we processed so far
         */
        if (inner.length > largestSize) {
            largestSize = inner.length;
        }
    }

    int[][] result = new int[map.size()][largestSize];
    /*
     * Iterate over the map and copy it's values which are represented
     * as Integer arrays into inner arrays of our return value
     */
    java.util.Iterator<java.util.Map.Entry<Integer, Integer[]>> iter = map.entrySet().iterator();
    for (int i = 0; i < result.length && iter.hasNext(); i++)
    {
        java.util.Map.Entry<Integer, Integer[]> entry = iter.next();
        /*
         * We can just return our value as an array of Integer objects
         * but for the sake of this exercise we will convert it to a
         * primitive 2D int array so it's consistent with our method parameter
         */
        Integer[] integers = entry.getValue();
        result[i] = java.util.Arrays.stream(integers).mapToInt(Integer::intValue).toArray();
    }
    return result;
}

public static void main(String[] args)
{
    int[][] array = {{2, 4, 1,9,9,9,9}, {6, 8}, {7, 3, 6, 5, 1}};
    int[][] result = arrayCalc(array);

    for (int[] iResult : result) {
        System.out.println(Arrays.toString(iResult));
    }
}

输出

[6, 8]
[7, 3, 6, 5, 1]
[2, 4, 1, 9, 9, 9, 9]