Java 中查找二进制矩阵中含零最多的列

---

在 Java 中，数组是一个对象。它是一种非基本数据类型，用于存储相同数据类型的多个值。Java 中的矩阵只不过是一个多维数组，它表示多行多列。

二进制矩阵是由 0 和 1 组成的矩阵，其中每个元素只能是两个可能值中的一个。

这里我们给出一个包含二进制元素的二进制矩阵，根据题意，我们需要找到包含最多 0 的列。

让我们开始吧！

举几个例子

示例 1

给定二进制矩阵 =

1 1 0 0
0 1 0 1
0 0 1 1
1 1 1 1

• 包含最多零的列是：1 和 3

示例 2

给定二进制矩阵 =

0 0 1 1 1
1 0 1 0 0
0 0 0 1 1
0 1 1 1 0
0 1 0 0 1

• 包含最多零的列是：1

示例 3

给定二进制矩阵 =

1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1

• 包含最多零的列是：不存在这样的列

算法

算法 1：（使用嵌套 for 循环）

• 步骤 1 − 程序初始化一个二进制矩阵和两个变量，用于存储最大零计数及其对应的列索引。

• 步骤 2 − 然后循环遍历矩阵的每一列，并计算该列中零的数量。

• 步骤 3 − 如果当前列的零的数量更多，则更新最大零计数及其对应的列索引。

• 步骤 4 − 最后，打印包含最多零的列，或者如果矩阵中没有零，则打印“给定矩阵不包含任何零”。

算法 2：（使用 Java 流）

• 步骤 1 − 程序初始化一个二进制矩阵和两个变量，用于存储最大零计数及其对应的列索引。

• 步骤 2 − 然后循环遍历矩阵的每一列，并使用 Java 流来计算该列中零的数量。

• 步骤 3 − 如果当前列的零的数量更多，则更新最大零计数及其对应的列索引。

• 步骤 4 − 最后，打印包含最多零的列，或者如果矩阵中没有零，则打印“给定矩阵不包含任何零”。

• 步骤 5 − Java 流提供了一种用于处理数据的函数式编程方法，可以显著减少执行集合数据上的复杂操作所需的代码量。

语法

Java 中的Matrix.length()方法返回给定矩阵的长度。

以下是其语法：

inputMatrix.lenght

其中，'inputMatrix' 指的是给定的矩阵。

Arrays.stream(matrix) 将二维整数数组矩阵转换为数组流，其中流中的每个数组表示矩阵中的一行。

Arrays.stream(matrix)

.mapToInt(row -> row[column]) 将流中的每个数组（行）映射到与指定列索引处的元素对应的整数值。

.mapToInt(row -> row[column]) 

多种方法

我们提供了不同的方法来解决这个问题。

• 使用嵌套 for 循环

• 使用 Java 流

让我们一一查看程序及其输出。

方法 1：使用嵌套 for 循环

在这种方法中，二进制矩阵元素将在程序中初始化。然后调用一个用户定义的方法，并将矩阵作为参数传递，在方法内部，根据算法 1 使用嵌套 for 循环计算给定二进制矩阵中包含最多 0 的列。

示例

public class Main {
   public static void main(String[] args) {
      
      // Create a binary matrix
      int[][] matrix = {{1, 0, 1, 0}, {0, 1, 0, 1}, {1, 0, 0, 0}, {0, 1, 1, 0}};
      
      // Initialize variables to store the maximum zero count and its corresponding column index
      int maxZeroCount = -1;
      int maxZeroColumn = -1;
      
      // Loop through each column of the matrix and count the number of zeros in that column
      for (int j = 0; j < matrix[0].length; j++) {
         int zeroCount = 0;
         for (int[] row : matrix) {
            if (row[j] == 0) {
               zeroCount++;
            }
         }
         
         // Update the maximum zero count and its corresponding column index if the current column has more zeros
         if (zeroCount > maxZeroCount) {
            maxZeroCount = zeroCount;
            maxZeroColumn = j;
         }
      }
      
      // Print the result
      if (maxZeroCount == 0) {
         System.out.println("The given matrix does not contain any zeros.");
      } else {
         System.out.print("The column(s) with the maximum number of zeros is/are: ");
         for (int j = 0; j < matrix[0].length; j++) {
            int zeroCount = 0;
            for (int[] row : matrix) {
               if (row[j] == 0) {
                  zeroCount++;
               }
            }
            if (zeroCount == maxZeroCount) {
               System.out.print(j + " ");
            }
         }
      }
   }
}

输出

The column(s) with the maximum number of zeros is/are: 3

方法 2：使用 Java 流

在这种方法中，二进制矩阵元素将在程序中初始化。然后调用一个用户定义的方法，并将矩阵作为参数传递，在方法内部，根据算法 2 使用 Java 流计算给定二进制矩阵中包含最多 0 的列。

示例

import java.util.Arrays;
public class Main {
   public static void main(String[] args) {
      
      // Create a binary matrix
      int[][] matrix = {{1, 0, 0, 0}, {0, 1, 0, 1}, {1, 0, 0, 0}, {0, 1, 1, 0}};
      
      // Initialize variables to store the maximum zero count and its corresponding column index
      int maxZeroCount = -1;
      int maxZeroColumn = -1;
      
      // Loop through each column of the matrix and count the number of zeros in that column using a lambda expression
      for (int j = 0; j < matrix[0].length; j++) {
         final int column = j; // Make a copy of j to use inside the lambda expression
         int zeroCount = (int) Arrays.stream(matrix)
               .mapToInt(row -> row[column])
               .filter(value -> value == 0)
               .count();
      
         // Update the maximum zero count and its corresponding column index if the current column has more zeros
         if (zeroCount > maxZeroCount) {
            maxZeroCount = zeroCount;
            maxZeroColumn = j;
         }
      }
      
      // Print the result
      if (maxZeroCount == 0) {
         System.out.println("The given matrix does not contain any zeros.");
      } else {
         System.out.print("The column(s) with the maximum number of zeros is/are: ");
         for (int j = 0; j < matrix[0].length; j++) {
            final int column = j; // Make a copy of j to use inside the lambda expression
            int zeroCount = (int) Arrays.stream(matrix)
               .mapToInt(row -> row[column])
               .filter(value -> value == 0)
               .count();
            if (zeroCount == maxZeroCount) {
               System.out.print(j + " ");
            }
         }
      }
   }
}

输出

The column(s) with the maximum number of zeros is/are: 2 3

在本文中，我们探讨了使用 Java 编程语言查找二进制矩阵中包含最多 0 的列的不同方法。