根据 arr[i] 的总和从低到高对二维 int 数组进行排序

Question

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

这些指令将创建一个接受二维int数组(不一定是矩阵)的函数，并根据内部数组的总和对外部数组进行排序。换句话说，在数组的第一个索引中应该是具有最低总和的内部数组。

Example - input - int[][] array = {{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

除了其他在解释理论和为解决任务奠定基础方面做得很好的答案外，下面是一个完整的工作示例（包含每件事的具体内容和原因的详细文档），希望能对您有所帮助：

/**
 * 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]

Answer 2

你有三分之一。您现在需要什么：

• 在创建包含“内部”数组总和的第一个数组总和之后，只需创建该数组的精确副本，如originalSums
• 然后，对sums的内容进行排序

例如：假设总和和originalSumsare

原文摘要： [ 12， 3， 7]

求和：[3,7,12]

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

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

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

最基本的方法是一次只查看一个指数(就像你做某种冒泡排序一样)。

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

Answer 3

您可以通过流式传输int[]然后调用sum（）来轻松地对它求和[]。从那里开始，只需使用比较器来比较此总和来调用 Arrays.sort：

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