在Java中替换矩阵中的零

我开始读著名的《破解密码面试》一书，我想做以下练习

编写一个算法，如果MxN矩阵中的元素为0，则其整行和整列都设置为0

以下是作者的解决方案：

public static void setZeros(int[][] matrix) {
int[] row = new int[matrix.length];
int[] column = new int[matrix[0].length];
// Store the row and column index with value 0
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[0].length;j++) {
        if (matrix[i][j] == 0) {
            row[i] = 1;
            column[j] = 1;
        }
    }
}

// Set arr[i][j] to 0 if either row i or column j has a 0
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[0].length; j++) {
        if ((row[i] == 1 || column[j] == 1)) {
             matrix[i][j] = 0;
        }
    }
 }
}

publicstaticvoidsetzero（int[][]矩阵）{
int[]行=新的int[matrix.length]；
int[]列=新int[矩阵[0]。长度]；
//存储值为0的行和列索引
对于（int i=0；i

我同意作者的主要观点。我们不必存储矩阵中“0”的位置，只需存储相关行和列的位置。但我在她的解决方案中发现了一点“奇怪”，那就是在最后，她在矩阵的所有单元上做了一个循环，这在我看来是不必要的

以下是我的解决方案：

static int[][] replaceMatrix(int[][] matrix){
  int M = matrix.length;
  int N = matrix[0].length;

  boolean[] row = new boolean[M] ;
  boolean[] column = new boolean[N];

  for (int i =0; i< M; i++) {
    for (int j = 0; j<N; j++ ){
         if (matrix[i][j] == 0) {
            row[i] = true;
            column[j] = true;
         }
    }
  }

  for (int i =0; i<M; i++){
    if (row[i]){
        for (int k =0; k<N; k++){
            matrix[i][k]=0;
        }
    }
  }

  for (int j =0; j<N; j++){
    if (column[j]){
        for (int k =0; k<M; k++){
            matrix[k][j]=0;
        }
    }
  }  

静态int[][]替换矩阵（int[][]矩阵）{
int M=矩阵长度；
int N=矩阵[0]。长度；
布尔值[]行=新布尔值[M]；
布尔[]列=新布尔[N]；
for（int i=0；i对于（int j＝0；j＜p>），在技术上和作者的解决方案上没有差别，因为两个都已经遍历整个矩阵。因此，如果我们必须考虑大O符号**/p>，则两个代码都是相同的**。
事实上，作者的代码有点（我指的不是不同的时间复杂度）更好

假设在您的布尔行数组中，所有行都设置为true，那么在您的例子中，您将遍历所有行以及基本上遍历整个矩阵的每行的每个元素

假设在列的布尔数组中，所有列都设置为true，那么在本例中，您将遍历所有列以及基本上遍历整个矩阵的每列的每个元素

因此实际上，您将遍历整个矩阵两次。但是代码的时间复杂度是相同的，因为O（M*N）和O（2*M*N）是相同的

自从使用布尔数据类型以来，您已经节省了空间。
上两个for循环的时间复杂度仍然是O（M*N）在最坏的情况下，内部for循环将运行k次的最大值。
任何查询都可以。让我们假设矩阵为3x3，第一个循环是9次迭代，第二个循环是9次迭代，所以在原始解决方案中是18次。现在在您的解决方案中，第一个循环是相同的，所以是9次迭代。然后在所有行上循环，其中是3次，并设置所有的coll，其中也就是3，这是9次迭代。但是你需要再次这样做，对于cols，所以你需要在另一个循环中再进行9次迭代。如果你存储受影响行的索引，你可以挤出一点。但在最坏的情况下，你仍然会对整个数组进行两次检查。@是的，你是对的。我在计算中犯了一个错误。我的复杂性是O（M*N）不是O（M+N）。我错了。因为我们执行第二个循环和第三个循环（不是or），所以有乘法而不是加法。如果我错了，请纠正我。谢谢！在很多情况下，你的版本提供的迭代次数更少。如果你只存储索引，在更多情况下会更好（fe.如果最后一个元素是NaN，你就需要检查所有的东西。）但在最坏的情况下，所有的解都是2*M*I现在我明白了。我在计算中犯了一个错误。我想我的复杂性是O（M+N），但它是O（2*MN）（O（MN）事实上正如你所解释的。谢谢！关于空间复杂性，作者说“为了提高空间利用率，我们可以使用位向量而不是布尔数组。”正是这一点我没有弄清楚。@salamanka44长度为n的位向量总是占用n位的空间，但长度为n的布尔数组占用的空间是机器dependent@salamanka44如果你喜欢我的答案，那么你也可以投票表决。