题目描述
给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
示例 1：
输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]示例 2：
输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]提示：
-
m == matrix.length -
n == matrix[0].length -
1 <= m, n <= 200 -
-2^31 <= matrix[i][j] <= 2^31 - 1
进阶：
-
一个直观的解决方案是使用 O(mn) 的额外空间，但这并不是一个好的解决方案。
-
一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
-
你能想出一个仅使用常量空间的解决方案吗？
解题思路
这道题的核心是原地修改，难点在于：当我们遍历到某个 0 时，如果立即将其所在行和列置零，会影响后续遍历，导致原本不是 0 的位置被误判为 0，从而错误地将更多行列置零。
因此，我们需要先标记哪些行和列需要被置零，最后再统一进行置零操作。
下面介绍三种解法，从直观到最优。
解法一：使用额外矩阵（O(mn)空间）
算法思想
创建一个同样大小的标记矩阵，先遍历原矩阵记录 0 的位置，然后根据标记矩阵将原矩阵的对应行列置零。
代码实现
java
class Solution {
public void setZeroes(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
boolean[][] mark = new boolean[m][n];
// 第一遍遍历：记录0的位置
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (matrix[i][j] == 0) {
mark[i][j] = true;
}
}
}
// 第二遍遍历：根据标记置零
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (mark[i][j]) {
// 将第i行置零
for (int col = 0; col < n; col++) {
matrix[i][col] = 0;
}
// 将第j列置零
for (int row = 0; row < m; row++) {
matrix[row][j] = 0;
}
}
}
}
}
}复杂度分析
-
时间复杂度： O(m×n×(m+n))，最坏情况下需要多次置零
-
空间复杂度： O(m×n)，需要额外矩阵
解法二：使用两个标记数组（O(m+n)空间）
算法思想
用两个布尔数组 row 和 col 分别记录哪些行和列需要被置零。先遍历矩阵，如果 matrix[i][j] == 0，则将 row[i] 和 col[j] 设为 true。最后根据这两个标记数组将对应行列置零。
代码实现
java
class Solution {
public void setZeroes(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
boolean[] row = new boolean[m]; // 记录哪些行需要置零
boolean[] col = 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;
col[j] = true;
}
}
}
// 第二遍遍历：根据标记置零
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (row[i] || col[j]) {
matrix[i][j] = 0;
}
}
}
}
}图解示例
以 matrix = [[1,1,1],[1,0,1],[1,1,1]] 为例：
| 步骤 | 操作 | matrix | row数组 | col数组 |
|---|---|---|---|---|
| 初始 | - | [[1,1,1],[1,0,1],[1,1,1]] |
[false,false,false] |
[false,false,false] |
| 遍历 | 发现(1,1)=0 | - | [false,true,false] |
[false,true,false] |
| 置零 | row[1]=true 或 col[1]=true 的位置置零 | [[1,0,1],[0,0,0],[1,0,1]] |
- | - |
复杂度分析
-
时间复杂度： O(m×n)，只需两次遍历
-
空间复杂度： O(m+n)，需要两个标记数组
解法三：使用第一行和第一列作为标记（O(1)空间）【最优解】
算法思想
这是满足进阶要求的常量空间解法。核心思想是：用矩阵的第一行和第一列来记录对应行列是否需要置零。
但这样会有一个问题：第一行和第一列本身是否需要置零会被覆盖。因此需要两个额外的变量 firstRowZero 和 firstColZero 来单独记录第一行和第一列的状态。
算法步骤
-
检查第一行和第一列：记录它们是否原本包含 0
-
使用第一行和第一列作为标记 ：遍历除第一行第一列外的元素，如果
matrix[i][j] == 0，则将matrix[0][j]和matrix[i][0]设为 0 -
根据标记置零 ：遍历除第一行第一列外的元素，如果
matrix[0][j] == 0或matrix[i][0] == 0，则将该元素置零 -
处理第一行和第一列：根据第一步的记录，将第一行和/或第一列置零
代码实现
java
class Solution {
public void setZeroes(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
// 1. 检查第一行和第一列是否包含0
boolean firstRowZero = false;
boolean firstColZero = false;
for (int j = 0; j < n; j++) {
if (matrix[0][j] == 0) {
firstRowZero = true;
break;
}
}
for (int i = 0; i < m; i++) {
if (matrix[i][0] == 0) {
firstColZero = true;
break;
}
}
// 2. 使用第一行和第一列作为标记
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (matrix[i][j] == 0) {
matrix[0][j] = 0; // 标记列
matrix[i][0] = 0; // 标记行
}
}
}
// 3. 根据标记置零（除第一行第一列）
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (matrix[0][j] == 0 || matrix[i][0] == 0) {
matrix[i][j] = 0;
}
}
}
// 4. 处理第一行
if (firstRowZero) {
for (int j = 0; j < n; j++) {
matrix[0][j] = 0;
}
}
// 5. 处理第一列
if (firstColZero) {
for (int i = 0; i < m; i++) {
matrix[i][0] = 0;
}
}
}
}图解示例
以 matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]] 为例：
第一步：检查第一行和第一列
| 检查 | 结果 |
|---|---|
| 第一行包含0？ | true（位置[0,0]和[0,3]是0） |
| 第一列包含0？ | true（位置[0,0]是0） |
第二步：使用第一行第一列标记（遍历 i=1..m-1, j=1..n-1）
遍历过程：
-
i=1,j=1: matrix[1][1]=4，不处理
-
i=1,j=2: matrix[1][2]=5，不处理
-
i=1,j=3: matrix[1][3]=2，不处理
-
i=2,j=1: matrix[2][1]=3，不处理
-
i=2,j=2: matrix[2][2]=1，不处理
-
i=2,j=3: matrix[2][3]=5，不处理
此时矩阵状态（第一行和第一列作为标记）：
java
[0,1,2,0]
[3,4,5,2]
[1,3,1,5]标记行（第一行）：[0,1,2,0] → 第0列和第3列被标记为0
标记列（第一列）：[0,3,1] → 第0行被标记为0
第三步：根据标记置零（除第一行第一列）
检查每个元素：
-
i=1,j=1: matrix[0][1]=1≠0, matrix[1][0]=3≠0 → 保持4
-
i=1,j=2: matrix[0][2]=2≠0, matrix[1][0]=3≠0 → 保持5
-
i=1,j=3: matrix[0][3]=0 → 置0
-
i=2,j=1: matrix[0][1]=1≠0, matrix[2][0]=1≠0 → 保持3
-
i=2,j=2: matrix[0][2]=2≠0, matrix[2][0]=1≠0 → 保持1
-
i=2,j=3: matrix[0][3]=0 → 置0
此时矩阵：
java
[0,1,2,0]
[3,4,5,0]
[1,3,1,0]第四步：处理第一行（因为 firstRowZero=true）
将第一行全部置零：
java
[0,0,0,0]
[3,4,5,0]
[1,3,1,0]第五步：处理第一列（因为 firstColZero=true）
将第一列全部置零：
java
[0,0,0,0]
[0,4,5,0]
[0,3,1,0]复杂度分析
-
时间复杂度： O(m×n)，只需常数次遍历
-
空间复杂度： O(1)，只使用了两个布尔变量
解法对比
| 解法 | 时间复杂度 | 空间复杂度 | 优点 | 缺点 |
|---|---|---|---|---|
| 额外矩阵法 | O(m×n×(m+n)) | O(m×n) | 思路最直观 | 空间效率差，时间效率也差 |
| 标记数组法 | O(m×n) | O(m+n) | 时间效率好 | 不满足O(1)空间要求 |
| 标记行列法 | O(m×n) | O(1) | 满足进阶要求，最优解 | 需要理解标记复用技巧 |
代码要点详解
1. 为什么需要单独记录第一行和第一列？
因为第一行和第一列被用作标记区域，它们本身是否包含 0 的信息会被覆盖。如果不单独记录，就会丢失这部分信息。
2. 处理顺序很重要
正确的顺序是：
-
先记录第一行第一列的原始状态
-
用第一行第一列标记其他区域
-
根据标记处理其他区域
-
最后处理第一行第一列
如果先处理第一行第一列，标记信息就会被破坏。
3. 边界条件处理
当矩阵只有一行或一列时，代码也需要正确处理：
-
只有一行：
firstColZero不需要检查（因为没有第1列） -
只有一列：
firstRowZero不需要检查（因为没有第1行）
常见错误与注意事项
-
立即置零的错误：不能在遍历过程中立即置零，否则会影响后续判断
-
标记顺序错误：必须先记录第一行第一列的原始状态
-
忘记处理第一行第一列：最后必须根据记录的原始状态处理第一行第一列
-
重复置零：注意不要对同一个位置多次置零，但因为是赋值为0，重复也不影响结果
-
索引混淆：注意 i 是行索引，j 是列索引
面试建议
-
优先写出标记数组法：如果时间紧张，先写出 O(m+n) 空间的解法，思路清晰不易错
-
再优化到 O(1) 空间：在标记数组法的基础上，解释如何用第一行第一列复用空间
-
强调为什么需要额外变量：解释为什么需要 firstRowZero 和 firstColZero
-
画图演示：面试时用简单例子演示算法过程，帮助面试官理解
相关题目推荐
-
力扣 289. 生命游戏（类似的状态标记问题）
-
力扣 54. 螺旋矩阵（矩阵遍历）
-
力扣 48. 旋转图像（原地修改矩阵）
-
力扣 36. 有效的数独（行列标记思想）
以上就是力扣73题"矩阵置零"的Java解法详细解析，重点掌握标记行列法这一最优解法，它是原地修改矩阵的经典技巧。如果觉得文章不错，欢迎点赞、收藏、关注三连支持！