从矩阵中删除行和列_java

“找到矩阵中的最大元素，并从矩阵中删除包含它的所有行和列”。

我做了方法。 在其中之一中，我找到了矩阵中最大的数字。 在第二个中，我从矩阵中删除包含最大数字的行和列。 但是，只有最大的数字是唯一的，它才能正常工作。 如何删除包含最大数字的所有行和所有列？

private void deleteRowCol() {
    int[][] matrix = getMatrix();
    int max = matrix[0][0];
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[0].length; j++) {
            if (max < matrix[i][j]) {
                max = matrix[i][j];
            }
        }
    }
    int[] m = findIdMax(matrix, max);
    int[][] outMatrix = new int[matrix.length - 1][matrix[0].length - 1];
    int r = 0;
    for (int i = 0; i < outMatrix.length; i++) {
        if (i > m[0] - 1) {
            r = 1;
        }
        int c = 0;
        for (int j = 0; j < outMatrix[0].length; j++) {
            if (j > m[1] - 1) {
                c = 1;
            }
            outMatrix[i][j] = matrix[i + r][j + c];
        }
    }
    System.out.println(" ");
    outputMatrix(outMatrix);
}

private int[] findIdMax(int[][] matrix, int max) {
    int[] id = {0, 0};
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[0].length; j++) {
            if (max == matrix[i][j]) {
                id[0] = i;
                id[1] = j;
            }
        }
    }
    return id;
}

预期输出：使用此矩阵

  4  2  0 -3
  4 -1  4  1
  0  2 -4  3
 -4 -1 -4 -2

应该带来

 -2  3
 -1 -2

我找不到您当前代码的修复程序。 一个问题是，您始终假定使用int[][] outMatrix = new int[matrix.length - 1][matrix[0].length - 1];删除1行和1列int[][] outMatrix = new int[matrix.length - 1][matrix[0].length - 1]; 。 如果我在您的代码周围放一个循环，那么如果最大值位于矩阵的1,2和1,4位置（应该只删除1行，但删除2列），它将失败。

因此，也许其他人可以仔细查看您的实现并看到直接的修正而无需进行太多更改。 相反，我从头开始考虑用例，并尝试自己完成任务。 我最终得到了以下代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

class Main{
  private Set<Integer> rowsToDelete,
                       columnsToDelete;

  public static void main(String[] a){
    Main program = new Main();

    int[][] matrix = program.getMatrix();
    System.out.println("Before:");
    program.prettyPrintMatrix(matrix);
    System.out.println();

    int[][] modifiedMatrix = program.deleteRowCol(matrix);
    System.out.println("After:");
    program.prettyPrintMatrix(modifiedMatrix);
  }

  private int[][] getMatrix(){
    // Test:
    return new int[][]{
      { 4, 2, 0,-3},
      { 4,-1, 4, 1},
      { 0, 2,-4, 3},
      {-4,-1,-4,-2}
    };
  }

  private int[][] deleteRowCol(int[][] matrix) {
    int max = findMax(matrix);
    determineCoordinatesMax(matrix, max);

    // Some debug prints:
    System.out.println("Maximum: "+max);
    System.out.println("Rows to delete: "+rowsToDelete);
    System.out.println("Columns to delete: "+columnsToDelete);
    System.out.println();

    int[][] modifiedMatrix = deleteRows(matrix);
    modifiedMatrix = deleteColumns(modifiedMatrix);

    return modifiedMatrix;
  }

  private int findMax(int[][] matrix){
    int max = matrix[0][0];
    for(int[] row : matrix){
      for(int value : row){
        if(value > max){
          max = value;
        }
      }
    }
    return max;
  }

  private void determineCoordinatesMax(int[][] matrix, int max) {
    rowsToDelete = new HashSet<>();
    columnsToDelete = new HashSet<>();

    for(int r=0; r<matrix.length; r++){
      for(int c=0; c<matrix[r].length; c++){
        if(matrix[r][c] == max){
          rowsToDelete.add(r);
          columnsToDelete.add(c);
        }
      }
    }
  }

  private int[][] deleteRows(int[][] matrix){
    int rowsToLeave = matrix.length - rowsToDelete.size();
    int[][] modifiedMatrix = new int[rowsToLeave][];
    int i = 0;
    for(int r=0; r<matrix.length; r++){
      if(!rowsToDelete.contains(r)){
        modifiedMatrix[i] = matrix[r];
        i++;
      }
    }
    return modifiedMatrix;
  }

  private int[][] deleteColumns(int[][] matrix){
    int columnsAlreadyDeleted = 0;
    for(int columnToDelete : columnsToDelete){
      // Delete the columns one by one:
      int[][] modifiedMatrix = new int[matrix.length][matrix[0].length - 1];
      for(int r=0; r<matrix.length; r++){
        int i=0;
        for(int c=0; c<matrix[r].length; c++){
          if(c != columnToDelete - columnsAlreadyDeleted){
            modifiedMatrix[r][i] = matrix[r][c];
            i++;
          }
        }
      }
      columnsAlreadyDeleted++;
      matrix = modifiedMatrix;
    }
    return matrix;
  }

  private void prettyPrintMatrix(int[][] matrix){
    for(int[] row : matrix){
      System.out.println(Arrays.toString(row));
    }
  }
}

删除列可能需要一些调整，因为我现在有三个嵌套循环（循环以删除列；内部循环遍历矩阵行；内部循环遍历矩阵列）。 但是它可以正常工作，并且可以按预期删除int[][]的行和列。

您可以在此处查看实际操作：

从矩阵中删除行和列

问题描述

1楼