【问题标题】:Sort 2D array by average value of each line按每行的平均值对二维数组进行排序
【发布时间】:2023-04-03 04:25:02
【问题描述】:

我有复杂的任务来手动对二维数组进行不同的排序。 到目前为止,我已经完成了这些任务:

  1. 用户需要输入从 10 到 20 的行大小,

  2. 生成二维数组,其中行大小是用户输入,列大小是从 10-50 随机生成的,

  3. 每个数组都填充了从 100 到 999 的随机生成的数字,

  4. 按降序输出每个数组行,

  5. 输出每个数组行的平均值,

  6. 在屏幕上输出平均值最大的数组,

  7. 到目前为止,我无法解决任务 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;
    }
}

【问题讨论】:

    标签: java arrays multidimensional-array columnsorting


    【解决方案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,并且上述解决方案可以在性能方面进行改进。

    【讨论】:

      【解决方案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;
          }
      }
      
      

      【讨论】:

        【解决方案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]
        

        【讨论】:

          猜你喜欢
          • 2013-08-17
          • 2020-02-13
          • 1970-01-01
          • 1970-01-01
          • 2011-10-25
          • 2018-06-02
          • 2015-06-16
          • 1970-01-01
          相关资源
          最近更新 更多