按每行的平均值对二维数组进行排序

Question

我有一项复杂的任务，需要手动对二维数组进行不同的排序。到目前为止，我完成了这些任务：

用户需要输入 10 - 20 的行大小，
生成二维数组，其中行大小是用户输入，列大小从 10-50 随机生成，
每个数组都填充了从 100 - 999 随机生成的数字，
按降序输出每个数组行，
输出数组每行的平均值，
屏幕数组输出最大平均值，
到目前为止我无法解决任务 Nr。 7.输出按每行平均值排序的二维数组。试图在循环中实现新的 arrayAverage 以对它不起作用的行进行排序。只需要对数组进行排序，无需创建新数组。

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class SortArray2D {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Sorting two dimensional arrays!!!");
        System.out.print("Enter arrays 1st dimension size 10 - 20: ");
        int array1stDsize = sc.nextInt();
        int array2ndDsize = new Random().nextInt(40) + 10;
        System.out.println();
        sc.close();

        if (array1stDsize > 20 || array1stDsize < 10) {
            System.out.println("The number you entered is too big or too small!!!");
        } else {
            //initializing array 
            int[][] array = new int[array1stDsize][array2ndDsize];
            for (int i = 0; i < array.length; i = i + 1) {
                for (int j = 0; j < array[i].length; j = j + 1) {
                    int input = new Random().nextInt(900) + 100;
                    array[i][j] = input;
                }
            }
            System.out.println("Array element output: ");
            arrayOutput(array);
            // array element sorting from biggest to smallest 
            for (int k = 0; k < array.length; k++) {
                for (int i = 1; i < array[k].length; i++) {
                    for (int j = i; j > 0; j--) {
                        if (array[k][j] > array[k][j - 1]) {
                            int element = array[k][j];
                            array[k][j] = array[k][j - 1];
                            array[k][j - 1] = element;
                        }
                    }
                }
            }
            System.out.println();
            System.out.println("Descending Array element output: ");
            arrayOutput(array);

            System.out.println();
            System.out.println("Average value output by array: ");
            float[] arrayAverage = new float[array1stDsize];
            float average = 0;
            for (int i = 0; i < array.length; i = i + 1) {
                for (int j = 0; j < array[i].length; j = j + 1) {
                    average = average + array[i][j];
                }
                average = (float) (Math.round((average / array[i].length) * 100.0) / 100.0);
                System.out.println(i + ". array average value: " + average);
                arrayAverage[i] = average;
            }

            System.out.println();
            System.out.println("New array from average values: ");
            System.out.println(Arrays.toString(arrayAverage));

            System.out.println();
            System.out.println("Most valuest array is: ");
            double max = 100;
            int row = 0;
            for (int i = 0; i < arrayAverage.length; i++) {

                if (max < arrayAverage[i]) {
                    max = arrayAverage[i];
                    row = i;
                }
            }
            System.out.print("Its founded " + row + ". row and it's value is: ");
            for (int j = 0; j < array[row].length; j = j + 1) {
                System.out.print(" " + array[row][j]);
            }

            System.out.println();
            System.out.println();

            //2D array sorting by average values
        }
    }

    public static int[][] arrayOutput(int[][] array) {
        for (int i = 0; i < array.length; i = i + 1) {
            for (int j = 0; j < array[i].length; j = j + 1) {
                if (j == 0) {
                    System.out.print("{ " + array[i][j]);
                } else {

                    System.out.print(", " + array[i][j]);
                }
            }
            System.out.print(" }");
            System.out.println();

        }
        return array;
    }
}

Answer 1

计算平均值的代码部分：

    float[] arrayAverage = new float[array1stDsize];
    float average = 0;
    for (int i = 0; i < array.length; i = i + 1) {
        for (int j = 0; j < array[i].length; j = j + 1) {
            average = average + array[i][j];
        }
        average = (float) (Math.round((average / array[i].length) * 100.0) / 100.0);
        System.out.println(i + ". array average value: " + average);
        arrayAverage[i] = average;
    }

有点错误，你需要在计算下一行的平均值之前将average变量设置为零：

  ...
  arrayAverage[i] = average;
  average = 0;

使用 Java Streams 可以非常优雅地得到按行平均排序的矩阵，即：

Arrays.sort(array, comparingDouble(row -> IntStream.of(row)
                                                   .average()
                                                   .getAsDouble()));

要对数组进行排序，请使用方法 Arrays.sort，然后为每一行获取其平均值作为双精度值 IntStream.of(row).average().getAsDouble()，并用作排序参数 comparingDouble(....)。

一个运行例子：

import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.IntStream;
import static java.util.Comparator.comparingDouble;

public class Test {
    public static void main(String[] args) {
        int array[][] = {{10, 20, 30},{40, 50, 60}, {1,2,3} };
        Arrays.sort(array, comparingDouble(row -> IntStream.of(row).average().getAsDouble()));
        Arrays.stream(array).map(Arrays::toString).forEach(System.out::println);
    }
}

输出：

[1, 2, 3]
[10, 20, 30]
[40, 50, 60]

相反的顺序使用：

Arrays.sort(array, comparing(row -> IntStream.of(row).average().getAsDouble(), reverseOrder()));

输出：

[40, 50, 60]
[10, 20, 30]
[1, 2, 3]

编辑：没有流

在不使用流的情况下，您可以执行以下操作：

1 - 获取矩阵行平均值的数组：

float[] arrayAverage = average(matrix);

您已经知道如何计算平均值，因此您只需要从您创建的代码中提取一个方法，即：

private static float[]average(int[][] array) {
    float[] arrayAverage = new float[array.length];
    float sum = 0;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            sum += array[i][j];
        }
        arrayAverage[i] = (float) (Math.round((sum / array[i].length) * 100.0) / 100.0);
        sum = 0;
    }
    return arrayAverage;
}

2 - 创建一个数组来表示行并初始化如下：

int [] row_position = new int [arrayAverage.length];
for(int i = 0; i < row_position.length; i++)
    row_position[i] = i;

3 - 使用最简单的冒泡排序对 arrayAverage 进行排序。在对该数组进行排序时，相应地更新存储在 row_position:

上的位置

for(int i=0; i < arrayAverage.length; i++){
    for(int j=1; j < (arrayAverage.length-i); j++){
        if(arrayAverage[j-1] > arrayAverage[j]){
            float temp = arrayAverage[j-1];
            arrayAverage[j-1] = arrayAverage[j];
            arrayAverage[j] = temp;
            int temp_pos = row_position[j-1];
            row_position[j-1] = row_position[j];
            row_position[j] = temp_pos;
        }
    }
}

4 - 现在您有了 row_positions 数组，告诉您应该如何重新排列已排序的行，您只需要相应地交换行：

    int[][] tmp_matrix = new int [matrix.lenght][];
    for (int i = 0; i < tmp_matrix.length; i++) {
        tmp_matrix[i] = matrix[row_position[i]];
    }
    matrix = new_matrix;

但是请记住，为了简单起见，我假设二次矩阵为 NxN，并且上述解决方案可以在性能方面得到改进。

Answer 2

终于成功了，看起来像这样。

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class SortArray2D {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Sorting two dimensional arrays!!!");
        System.out.print("Enter arrays 1st dimension size 10 - 20: ");
        int array1stDsize = sc.nextInt();
        System.out.println();
        sc.close();

        if (array1stDsize > 20 || array1stDsize < 10) {
            System.out.println("The number you enteraed is too big or too small!!!");
        } else {

            int[][] array = new int[array1stDsize][];
            Random random = new Random();
            for (int i = 0; i < array.length; i++) {
                array[i] = new int[random.nextInt(31) + 10];
                for (int j = 0; j < array[i].length; j++) {
                    int input = new Random().nextInt(900) + 100;
                    array[i][j] = input;
                }
            }
            System.out.println("Array element output: ");
            arrayOutput(array);
            // array element sorting from biggest to smallest
            for (int k = 0; k < array.length; k++) {
                for (int i = 1; i < array[k].length; i++) {
                    for (int j = i; j > 0; j--) {
                        if (array[k][j] > array[k][j - 1]) {
                            int element = array[k][j];
                            array[k][j] = array[k][j - 1];
                            array[k][j - 1] = element;

                        }
                    }
                }
            }
            System.out.println();
            System.out.println("Descending Array element output: ");
            arrayOutput(array);

            System.out.println();
            System.out.println("Average value output by array: ");
            float[] arrayAverage = new float[array1stDsize];

            for (int i = 0; i < array.length; i = i + 1) {
                float sum = 0;
                for (int j = 0; j < array[i].length; j = j + 1) {
                    sum = sum + array[i][j];
                }
                float average = (float) (Math.round((sum / array[i].length) * 100.0) / 100.0);
                System.out.println(i + ". array average value: " + average);
                arrayAverage[i] = average;
            }
            // array lines sorting from by average value increasing
            for (int i = 0; i < arrayAverage.length; i = i + 1) {
                for (int j = i; j > 0; j--) {
                    if (arrayAverage[j] < arrayAverage[j - 1]) {
                        float tmpor = arrayAverage[j];
                        arrayAverage[j] = arrayAverage[j - 1];
                        arrayAverage[j - 1] = tmpor;

                        int[] tmp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = tmp;
                    }
                }
            }
            System.out.println();
            System.out.print("Array from average values sorted: ");
            System.out.println(Arrays.toString(arrayAverage));
            System.out.println();
            System.out.println("Incerasing Array line output: ");
            arrayOutput(array);
            System.out.println();
            System.out.print("Most valuest array is array: ");
            double max = 100;
            int row = 0;
            for (int i = 0; i < arrayAverage.length; i++) {

                if (max < arrayAverage[i]) {
                    max = arrayAverage[i];
                    row = i;

                }
            }
            for (int j = 0; j < array[row].length; j = j + 1) {
                System.out.print(" " + array[row][j]);
            }
        }
    }

    public static int[][] arrayOutput(int[][] array) {
        for (int i = 0; i < array.length; i = i + 1) {
            for (int j = 0; j < array[i].length; j = j + 1) {
                if (j == 0) {
                    System.out.print("{ " + array[i][j]);
                } else {

                    System.out.print(", " + array[i][j]);
                }
            }
            System.out.print(" }");
            System.out.println();

        }
        return array;
    }
}

Answer 3

按升序输出排序的二维数组：

int[][] arr = {
        {12, 54, 87},  // avg 51
        {98, 56, 32},  // avg 62
        {19, 73, 46}}; // avg 46

Arrays.stream(arr)
        // sort an array by the
        // average value of the row
        .sorted(Comparator.comparingDouble(row ->
                // get the average value or 0 if the row is empty {}
                Arrays.stream(row).average().orElse(0)))
        // string representation
        // of the row content
        .map(Arrays::toString)
        // output line by line
        .forEach(System.out::println);

输出：

[19, 73, 46]
[12, 54, 87]
[98, 56, 32]

按每行的平均值对二维数组进行排序

Sort 2D array by average value of each line

java

arrays

multidimensional-array

columnsorting