Java详解LeetCode 热题 100(19):LeetCode 54. 螺旋矩阵（Spiral Matrix）详解

已于 2025-05-23 00:41:03 修改
阅读量847 收藏 7
点赞数 21
分类专栏： LeetCode 热题 100+多种思路+java实现 文章标签： leetcode java 算法
于 2025-05-23 00:02:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk_dflkg/article/details/148126434
版权

文章目录

1. 题目描述

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1:

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例1图示

示例 2:

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

示例2图示

提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= m, n <= 10
  • -100 <= matrix[i][j] <= 100

2. 理解题目

这道题要求我们按照螺旋顺序遍历一个二维矩阵，并将遍历结果作为一维数组返回。具体来说：

  • 输入是一个 m×n 的矩阵（二维数组）
  • 要求按照顺时针螺旋顺序遍历矩阵的所有元素
  • 螺旋顺序是从矩阵外围向内部螺旋的方式进行遍历
  • 返回的结果是一个包含所有元素的一维数组

螺旋顺序的遍历路径为：

  1. 从左到右遍历上边界
  2. 从上到下遍历右边界
  3. 从右到左遍历下边界
  4. 从下到上遍历左边界
  5. 缩小边界，重复上述过程，直到所有元素都被遍历

关键点：

  1. 如何确定边界并不断缩小边界
  2. 如何处理只有一行或一列的特殊情况
  3. 如何正确地结束遍历过程，避免重复遍历元素

3. 解法一：四边界模拟法

3.1 思路

最直观的解法是模拟螺旋遍历的过程，使用四个变量表示当前的边界：

  1. 定义四个变量 top、right、bottom、left 表示四个边界
  2. 在螺旋遍历的过程中，按照从左到右、从上到下、从右到左、从下到上的顺序访问边界上的元素
  3. 访问完一条边后，相应的边界向内收缩
  4. 当左边界超过右边界或上边界超过下边界时，遍历结束

这种方法直观模拟了题目要求的螺旋遍历过程。

3.2 Java代码实现

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        
        // 处理边界情况
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        
        // 定义四个边界
        int top = 0;
        int right = matrix[0].length - 1;
        int bottom = matrix.length - 1;
        int left = 0;
        
        // 循环遍历，直到所有元素都被访问
        while (top <= bottom && left <= right) {
            // 从左到右遍历上边界
            for (int j = left; j <= right; j++) {
                result.add(matrix[top][j]);
            }
            top++; // 上边界下移
            
            // 从上到下遍历右边界
            for (int i = top; i <= bottom; i++) {
                result.add(matrix[i][right]);
            }
            right--; // 右边界左移
            
            // 检查是否还有行未被遍历
            if (top <= bottom) {
                // 从右到左遍历下边界
                for (int j = right; j >= left; j--) {
                    result.add(matrix[bottom][j]);
                }
                bottom--; // 下边界上移
            }
            
            // 检查是否还有列未被遍历
            if (left <= right) {
                // 从下到上遍历左边界
                for (int i = bottom; i >= top; i--) {
                    result.add(matrix[i][left]);
                }
                left++; // 左边界右移
            }
        }
        
        return result;
    }
}

3.3 代码详解

详细解释每一步的意义和实现：

// 处理边界情况
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
    return result;
}
  • 检查输入矩阵是否为空或大小为0
  • 这是处理边界情况的常见做法，避免后续操作出现空指针或越界异常
// 定义四个边界
int top = 0;
int right = matrix[0].length - 1;
int bottom = matrix.length - 1;
int left = 0;
  • 定义四个变量表示当前要遍历的四个边界
  • top表示上边界的行索引，初始为0
  • right表示右边界的列索引，初始为矩阵的列数减1
  • bottom表示下边界的行索引，初始为矩阵的行数减1
  • left表示左边界的列索引，初始为0
// 循环遍历，直到所有元素都被访问
while (top <= bottom && left <= right) {
    // 从左到右遍历上边界
    for (int j = left; j <= right; j++) {
        result.add(matrix[top][j]);
    }
    top++; // 上边界下移
    
    // 从上到下遍历右边界
    for (int i = top; i <= bottom; i++) {
        result.add(matrix[i][right]);
    }
    right--; // 右边界左移
    
    // 检查是否还有行未被遍历
    if (top <= bottom) {
        // 从右到左遍历下边界
        for (int j = right; j >= left; j--) {
            result.add(matrix[bottom][j]);
        }
        bottom--; // 下边界上移
    }
    
    // 检查是否还有列未被遍历
    if (left <= right) {
        // 从下到上遍历左边界
        for (int i = bottom; i >= top; i--) {
            result.add(matrix[i][left]);
        }
        left++; // 左边界右移
    }
}
  • 使用循环模拟螺旋遍历的过程
  • 循环条件是上边界不超过下边界并且左边界不超过右边界，表示还有元素未被访问
  • 在每一轮循环中，按照顺时针顺序遍历四条边：上、右、下、左

对于每一条边的遍历：

  • 遍历上边界：沿着第top行，从left列遍历到right列
  • 遍历右边界：沿着第right列，从top行遍历到bottom行
  • 遍历下边界：沿着第bottom行，从right列遍历到left列
  • 遍历左边界：沿着第left列，从bottom行遍历到top行

在遍历每条边后，对应的边界会向内收缩：

  • 上边界下移：top++
  • 右边界左移：right--
  • 下边界上移：bottom--
  • 左边界右移：left++

特别注意的是，在遍历下边界和左边界之前，需要检查边界条件：

  • 遍历下边界前：if (top <= bottom)，确保还有行未被遍历
  • 遍历左边界前：if (left <= right)，确保还有列未被遍历

这是为了处理矩阵行数或列数为奇数的情况，避免重复遍历。

3.4 复杂度分析

  • 时间复杂度: O(m×n)，其中 m 是矩阵的行数，n 是矩阵的列数。每个元素只被访问一次。
  • 空间复杂度: O(1)，除了存储结果的列表外，只使用了常数额外空间。如果不考虑结果列表，空间复杂度为O(1)；如果考虑结果列表，空间复杂度为O(m×n)。

3.5 适用场景

四边界模拟法是解决螺旋矩阵问题的基础方法，适用于大多数情况。它直观、易于理解和实现，是面试中常用的解法。

4. 解法二：方向数组模拟法

4.1 思路

另一种常用的解法是使用方向数组来模拟螺旋遍历的过程：

  1. 定义一个方向数组，表示向右、向下、向左、向上四个方向的行列变化
  2. 使用一个变量记录当前的方向
  3. 按照当前方向前进，当遇到边界或已访问的元素时，改变方向
  4. 当所有元素都被访问后结束遍历

这种方法通过不断改变方向来实现螺旋遍历，更加灵活。

4.2 Java代码实现

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        
        // 处理边界情况
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        
        // 创建访问标记数组，初始值为false，表示未访问
        boolean[][] visited = new boolean[m][n];
        
        // 定义四个方向：向右、向下、向左、向上
        int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int dirIndex = 0; // 初始方向为向右
        
        // 开始位置为矩阵左上角
        int row = 0, col = 0;
        
        // 遍历所有元素
        for (int i = 0; i < m * n; i++) {
            result.add(matrix[row][col]);
            visited[row][col] = true;
            
            // 计算下一个位置
            int nextRow = row + directions[dirIndex][0];
            int nextCol = col + directions[dirIndex][1];
            
            // 如果下一个位置超出边界或已访问，则改变方向
            if (nextRow < 0 || nextRow >= m || nextCol < 0 || nextCol >= n || visited[nextRow][nextCol]) {
                dirIndex = (dirIndex + 1) % 4; // 顺时针旋转，切换到下一个方向
                nextRow = row + directions[dirIndex][0];
                nextCol = col + directions[dirIndex][1];
            }
            
            // 更新当前位置
            row = nextRow;
            col = nextCol;
        }
        
        return result;
    }
}

4.3 代码详解

详细解释每一步的意义和实现：

// 创建访问标记数组，初始值为false，表示未访问
boolean[][] visited = new boolean[m][n];
  • 创建一个与矩阵大小相同的布尔数组，用于标记元素是否已被访问
  • 初始值都为false，表示所有元素都未被访问
// 定义四个方向：向右、向下、向左、向上
int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int dirIndex = 0; // 初始方向为向右
  • 定义一个二维数组directions，表示四个方向的行列变化
  • {0, 1}表示向右移动（行不变，列加1）
  • {1, 0}表示向下移动（行加1，列不变）
  • {0, -1}表示向左移动（行不变，列减1）
  • {-1, 0}表示向上移动（行减1，列不变）
  • dirIndex变量记录当前的方向，初始值为0，表示向右
// 开始位置为矩阵左上角
int row = 0, col = 0;
  • 设置初始位置为矩阵的左上角，即(0, 0)
// 遍历所有元素
for (int i = 0; i < m * n; i++) {
    result.add(matrix[row][col]);
    visited[row][col] = true;
    
    // 计算下一个位置
    int nextRow = row + directions[dirIndex][0];
    int nextCol = col + directions[dirIndex][1];
    
    // 如果下一个位置超出边界或已访问，则改变方向
    if (nextRow < 0 || nextRow >= m || nextCol < 0 || nextCol >= n || visited[nextRow][nextCol]) {
        dirIndex = (dirIndex + 1) % 4; // 顺时针旋转，切换到下一个方向
        nextRow = row + directions[dirIndex][0];
        nextCol = col + directions[dirIndex][1];
    }
    
    // 更新当前位置
    row = nextRow;
    col = nextCol;
}
  • 总共需要遍历m×n个元素，所以循环m×n次
  • 在每次循环中，将当前位置的元素添加到结果列表中，并标记为已访问
  • 根据当前方向计算下一个位置的坐标
  • 如果下一个位置超出矩阵边界或已经被访问过，就顺时针旋转到下一个方向
  • 使用(dirIndex + 1) % 4实现方向的循环变化：0->1->2->3->0->…
  • 计算新的下一个位置，并更新当前位置

4.4 复杂度分析

  • 时间复杂度: O(m×n)，其中 m 是矩阵的行数，n 是矩阵的列数。每个元素只被访问一次。
  • 空间复杂度: O(m×n)，需要一个与矩阵大小相同的布尔数组来标记已访问的元素。

4.5 与解法一的比较

两种解法的核心思想不同：

  • 解法一：维护四个边界变量，明确地按照上、右、下、左的顺序遍历四个边界
  • 解法二：使用方向数组，根据当前位置和方向动态决定下一步的移动

各有优缺点：

  • 解法一更直观，代码结构更清晰，适合逻辑思路清晰的面试者
  • 解法二更灵活，易于扩展到其他类型的矩阵遍历问题，但需要额外的空间来记录已访问的元素
  • 解法一的空间复杂度更低，为O(1)，而解法二为O(m×n)

5. 解法三：层次遍历法

5.1 思路

第三种解法是按照层次来遍历矩阵，将矩阵看作是由多个"层"组成的，从外到内一层一层地遍历：

  1. 定义层次的边界：上边界topRow、右边界rightCol、下边界bottomRow、左边界leftCol
  2. 从外层开始，逐层向内遍历
  3. 对于每一层，按照顺时针顺序遍历该层的四条边
  4. 遍历完一层后，将四个边界分别向内收缩，进入下一层的遍历

这种方法的优点是思路清晰，易于理解，且无需使用额外的空间来记录已访问的元素。

5.2 Java代码实现

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        
        // 处理边界情况
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        
        // 定义层次的边界
        int topRow = 0;
        int rightCol = n - 1;
        int bottomRow = m - 1;
        int leftCol = 0;
        
        // 层次遍历
        while (topRow <= bottomRow && leftCol <= rightCol) {
            // 遍历当前层的上边
            for (int j = leftCol; j <= rightCol; j++) {
                result.add(matrix[topRow][j]);
            }
            
            // 遍历当前层的右边
            for (int i = topRow + 1; i <= bottomRow; i++) {
                result.add(matrix[i][rightCol]);
            }
            
            // 如果当前层不止一行，则遍历下边
            if (topRow < bottomRow) {
                for (int j = rightCol - 1; j >= leftCol; j--) {
                    result.add(matrix[bottomRow][j]);
                }
            }
            
            // 如果当前层不止一列，则遍历左边
            if (leftCol < rightCol) {
                for (int i = bottomRow - 1; i > topRow; i--) {
                    result.add(matrix[i][leftCol]);
                }
            }
            
            // 向内收缩，进入下一层
            topRow++;
            rightCol--;
            bottomRow--;
            leftCol++;
        }
        
        return result;
    }
}

5.3 代码详解

详细解释每一步的意义和实现：

// 定义层次的边界
int topRow = 0;
int rightCol = n - 1;
int bottomRow = m - 1;
int leftCol = 0;
  • 定义四个变量表示当前层的四个边界
  • topRow表示上边的行索引
  • rightCol表示右边的列索引
  • bottomRow表示下边的行索引
  • leftCol表示左边的列索引
// 层次遍历
while (topRow <= bottomRow && leftCol <= rightCol) {
    // 遍历当前层的四条边
    // ...
    
    // 向内收缩，进入下一层
    topRow++;
    rightCol--;
    bottomRow--;
    leftCol++;
}
  • 使用循环实现层次遍历，从外层开始，逐层向内
  • 循环继续的条件是上边界不超过下边界，且左边界不超过右边界
  • 遍历完一层后，四个边界同时向内收缩，为下一层的遍历做准备
// 遍历当前层的上边
for (int j = leftCol; j <= rightCol; j++) {
    result.add(matrix[topRow][j]);
}
  • 遍历当前层的上边，行索引固定为topRow，列索引从leftCol到rightCol
// 遍历当前层的右边
for (int i = topRow + 1; i <= bottomRow; i++) {
    result.add(matrix[i][rightCol]);
}
  • 遍历当前层的右边，列索引固定为rightCol，行索引从topRow+1到bottomRow
  • 从topRow+1开始是为了避免重复遍历右上角的元素
// 如果当前层不止一行，则遍历下边
if (topRow < bottomRow) {
    for (int j = rightCol - 1; j >= leftCol; j--) {
        result.add(matrix[bottomRow][j]);
    }
}
  • 只有当topRow < bottomRow，即当前层至少有两行时，才需要遍历下边
  • 遍历下边时，行索引固定为bottomRow，列索引从rightCol-1到leftCol
  • 从rightCol-1开始是为了避免重复遍历右下角的元素
// 如果当前层不止一列，则遍历左边
if (leftCol < rightCol) {
    for (int i = bottomRow - 1; i > topRow; i--) {
        result.add(matrix[i][leftCol]);
    }
}
  • 只有当leftCol < rightCol，即当前层至少有两列时，才需要遍历左边
  • 遍历左边时，列索引固定为leftCol，行索引从bottomRow-1到topRow+1
  • 从bottomRow-1开始是为了避免重复遍历左下角的元素
  • 行索引到topRow+1为止，而不是到topRow，是为了避免重复遍历左上角的元素

5.4 复杂度分析

  • 时间复杂度: O(m×n)，其中 m 是矩阵的行数，n 是矩阵的列数。每个元素只被访问一次。
  • 空间复杂度: O(1)，除了存储结果的列表外，只使用了常数额外空间。

5.5 与其他解法的比较

层次遍历法与四边界模拟法（解法一）很相似，主要区别在于：

  • 解法一在每次迭代中单独遍历每条边，且需要单独检查边界条件
  • 层次遍历法将四条边的遍历组织在一个清晰的层次结构中，并使用两个条件语句处理特殊情况

层次遍历法的优点：

  • 思路更加清晰，按照从外到内的层次逐层处理
  • 代码结构简洁，易于理解和维护
  • 无需使用额外空间来记录已访问的元素（相比方向数组法）

总体来说，层次遍历法是一种结合了四边界模拟法的直观性和方向数组法的简洁性的方法，是解决螺旋矩阵问题的优秀解法。

6. 详细步骤分析与示例跟踪

让我们通过几个具体的例子，详细跟踪每种解法的执行过程，以加深理解。

6.1 示例1跟踪：3×3矩阵

以示例1中的3×3矩阵为例：

[
  [1,2,3],
  [4,5,6],
  [7,8,9]
]

使用解法一（四边界模拟法）跟踪：

  1. 初始化：

    • 边界：top = 0, right = 2, bottom = 2, left = 0
    • 结果：result = []

  2. 第一轮循环：

    • 遍历上边界：添加matrix[0][0], matrix[0][1], matrix[0][2]，即1, 2, 3

    • 更新top = 1

    • 结果：result = [1, 2, 3]

    • 遍历右边界：添加matrix[1][2], matrix[2][2]，即6, 9

    • 更新right = 1

    • 结果：result = [1, 2, 3, 6, 9]

    • 遍历下边界：添加matrix[2][1], matrix[2][0]，即8, 7

    • 更新bottom = 1

    • 结果：result = [1, 2, 3, 6, 9, 8, 7]

    • 遍历左边界：添加matrix[1][0]，即4

    • 更新left = 1

    • 结果：result = [1, 2, 3, 6, 9, 8, 7, 4]

  3. 第二轮循环：

    • 遍历上边界：添加matrix[1][1]，即5

    • 更新top = 2

    • 结果：result = [1, 2, 3, 6, 9, 8, 7, 4, 5]

    • 此时top > bottom，循环结束

  4. 最终结果：[1, 2, 3, 6, 9, 8, 7, 4, 5]

使用解法二（方向数组模拟法）跟踪：

  1. 初始化：

    • m = 3, n = 3
    • visited = [[false, false, false], [false, false, false], [false, false, false]]
    • directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]
    • dirIndex = 0
    • row = 0, col = 0
    • 结果：result = []

  2. 遍历过程：

    • 当前位置：(0, 0)，添加1，标记为已访问

    • 下一个位置：(0, 1)，未访问，更新当前位置

    • 结果：result = [1]

    • 当前位置：(0, 1)，添加2，标记为已访问

    • 下一个位置：(0, 2)，未访问，更新当前位置

    • 结果：result = [1, 2]

    • 当前位置：(0, 2)，添加3，标记为已访问

    • 下一个位置：(0, 3)，超出边界，改变方向为向下

    • 新的下一个位置：(1, 2)，未访问，更新当前位置

    • 结果：result = [1, 2, 3]

    • 继续遍历…

  3. 最终结果：[1, 2, 3, 6, 9, 8, 7, 4, 5]

6.2 示例2跟踪：非方阵

以示例2中的3×4矩阵为例：

[
  [1,2,3,4],
  [5,6,7,8],
  [9,10,11,12]
]

使用解法三（层次遍历法）跟踪：

  1. 初始化：

    • m = 3, n = 4
    • topRow = 0, rightCol = 3, bottomRow = 2, leftCol = 0
    • 结果：result = []

  2. 第一轮循环：

    • 遍历上边：添加matrix[0][0]到matrix[0][3]，即1, 2, 3, 4
    • 遍历右边：添加matrix[1][3]到matrix[2][3]，即8, 12
    • 遍历下边：添加matrix[2][2]到matrix[2][0]，即11, 10, 9
    • 遍历左边：添加matrix[1][0]，即5
    • 更新边界：topRow = 1, rightCol = 2, bottomRow = 1, leftCol = 1
    • 结果：result = [1, 2, 3, 4, 8, 12, 11, 10, 9, 5]

  3. 第二轮循环：

    • 遍历上边：添加matrix[1][1]和matrix[1][2]，即6, 7
    • 遍历右边：没有元素需要遍历
    • 遍历下边：没有元素需要遍历
    • 遍历左边：没有元素需要遍历
    • 更新边界：topRow = 2, rightCol = 1, bottomRow = 0, leftCol = 2
    • 结果：result = [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]

  4. 循环终止：topRow > bottomRow，循环结束

  5. 最终结果：[1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]

6.3 特殊情况跟踪：单行矩阵

考虑一个单行矩阵：

[
  [1,2,3]
]

使用解法一（四边界模拟法）跟踪：

  1. 初始化：

    • 边界：top = 0, right = 2, bottom = 0, left = 0
    • 结果：result = []

  2. 第一轮循环：

    • 遍历上边界：添加matrix[0][0], matrix[0][1], matrix[0][2]，即1, 2, 3

    • 更新top = 1

    • 结果：result = [1, 2, 3]

    • 此时top > bottom，循环结束

  3. 最终结果：[1, 2, 3]

6.4 特殊情况跟踪：单列矩阵

考虑一个单列矩阵：

[
  [1],
  [2],
  [3]
]

使用解法一（四边界模拟法）跟踪：

  1. 初始化：

    • 边界：top = 0, right = 0, bottom = 2, left = 0
    • 结果：result = []

  2. 第一轮循环：

    • 遍历上边界：添加matrix[0][0]，即1

    • 更新top = 1

    • 结果：result = [1]

    • 遍历右边界：添加matrix[1][0], matrix[2][0]，即2, 3

    • 更新right = -1

    • 结果：result = [1, 2, 3]

    • 此时left > right，循环结束

  3. 最终结果：[1, 2, 3]

6.5 动态图示

以下是螺旋矩阵遍历过程的动态示意：

3×3矩阵示例：

→ → →
↑     ↓
↑ ← ← ↓

3×4矩阵示例：

→ → → →
↑       ↓
↑ ← ← ← ↓

7. 常见错误与优化

7.1 常见错误

  1. 边界条件处理不当：
    最常见的错误是在处理矩阵的边界时出错，特别是在处理单行或单列矩阵时。

    // 错误写法：没有检查边界条件
for (int j = right; j >= left; j--) {
    result.add(matrix[bottom][j]);
}

// 正确写法：先检查是否还有行需要遍历
if (top <= bottom) {
    for (int j = right; j >= left; j--) {
        result.add(matrix[bottom][j]);
    }
}

  2. 遍历顺序错误：
    错误地定义螺旋遍历的顺序，导致结果不符合预期。

    // 错误写法：顺序混乱
// 从左到右遍历上边界
// 从右到左遍历下边界
// 从上到下遍历右边界
// 从下到上遍历左边界

// 正确写法：明确的顺时针顺序
// 从左到右遍历上边界
// 从上到下遍历右边界
// 从右到左遍历下边界
// 从下到上遍历左边界

  3. 更新边界顺序错误：
    在使用四边界模拟法时，如果边界更新顺序错误，可能导致重复遍历或遗漏元素。

    // 错误写法：更新边界的顺序错误
top++;
left++;
bottom--;
right--;

// 正确写法：先处理横向边界，再处理纵向边界
top++;
bottom--;
left++;
right--;

  4. 未正确处理特殊情况：
    未正确处理空矩阵、单行矩阵或单列矩阵等特殊情况。

    // 错误写法：没有处理空矩阵情况
public List<Integer> spiralOrder(int[][] matrix) {
    List<Integer> result = new ArrayList<>();
    int m = matrix.length;
    int n = matrix[0].length; // 如果matrix为空，这里会抛出异常
    // ...
}

// 正确写法：先检查矩阵是否为空
public List<Integer> spiralOrder(int[][] matrix) {
    List<Integer> result = new ArrayList<>();
    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
        return result;
    }
    // ...
}

  5. 方向数组使用不当：
    在使用方向数组模拟法时，方向的顺序或更新逻辑错误。

    // 错误写法：方向数组定义错误
int[][] directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; // 顺序错误

// 正确写法：按照顺时针顺序定义方向
int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 右、下、左、上

7.2 性能优化

  1. 减少边界检查：
    在一些实现中，可以减少不必要的边界检查，提高代码执行效率。

    // 优化前：每次遍历都检查边界条件
if (top <= bottom) {
    for (int j = right; j >= left; j--) {
        result.add(matrix[bottom][j]);
    }
}

// 优化后：使用循环条件隐含边界检查
while (top <= bottom && left <= right) {
    // 从左到右遍历上边界
    for (int j = left; j <= right; j++) {
        result.add(matrix[top][j]);
    }
    top++;
    
    // 从上到下遍历右边界
    for (int i = top; i <= bottom; i++) {
        result.add(matrix[i][right]);
    }
    right--;
    
    // 检查是否还有元素未被遍历
    if (top <= bottom) {
        // 从右到左遍历下边界
        for (int j = right; j >= left; j--) {
            result.add(matrix[bottom][j]);
        }
        bottom--;
    }
    
    if (left <= right) {
        // 从下到上遍历左边界
        for (int i = bottom; i >= top; i--) {
            result.add(matrix[i][left]);
        }
        left++;
    }
}

  2. 预分配结果列表的容量：
    如果知道矩阵的大小，可以预先分配结果列表的容量，减少扩容操作。

    // 优化前：动态扩容
List<Integer> result = new ArrayList<>();

// 优化后：预分配容量
List<Integer> result = new ArrayList<>(m * n);

  3. 使用数组而非列表作为中间结果：
    如果对性能要求极高，可以使用数组而非列表作为中间结果，避免装箱/拆箱操作和动态扩容的开销。

    // 优化前：使用List
List<Integer> result = new ArrayList<>();

// 优化后：使用数组
int[] result = new int[m * n];
int index = 0;
// 在遍历过程中，使用result[index++] = matrix[i][j]添加元素

  4. 避免使用额外空间：
    在方向数组模拟法中，可以考虑使用原矩阵本身来标记已访问的元素，而不是使用额外的visited数组，但这会修改原矩阵。

    // 优化前：使用额外的visited数组
boolean[][] visited = new boolean[m][n];

// 优化后：直接修改原矩阵（如果允许）
// 可以使用一个特殊值（如Integer.MIN_VALUE）标记已访问的元素

  5. 简化层次遍历的条件判断：
    在层次遍历法中，可以采用更简洁的条件判断方式。

    // 优化前：每条边都单独判断是否需要遍历
if (topRow < bottomRow) {
    // 遍历下边
}
if (leftCol < rightCol) {
    // 遍历左边
}

// 优化后：使用统一的循环条件控制
while (topRow <= bottomRow && leftCol <= rightCol) {
    // 遍历上边（必须执行）
    for (int j = leftCol; j <= rightCol; j++) {
        result.add(matrix[topRow][j]);
    }
    topRow++;
    
    // 如果还有行未遍历，则遍历右边
    if (topRow <= bottomRow) {
        for (int i = topRow; i <= bottomRow; i++) {
            result.add(matrix[i][rightCol]);
        }
        rightCol--;
    } else {
        break; // 提前结束循环
    }
    
    // 如果还有列未遍历，则遍历下边
    if (leftCol <= rightCol) {
        for (int j = rightCol; j >= leftCol; j--) {
            result.add(matrix[bottomRow][j]);
        }
        bottomRow--;
    } else {
        break; // 提前结束循环
    }
    
    // 如果还有行未遍历，则遍历左边
    if (topRow <= bottomRow) {
        for (int i = bottomRow; i >= topRow; i--) {
            result.add(matrix[i][leftCol]);
        }
        leftCol++;
    } else {
        break; // 提前结束循环
    }
}

这些优化通常适用于大型矩阵或需要高性能的场景。对于普通的面试场景，解法一或解法三已经足够高效。

8. 扩展题目与应用

8.1 相关矩阵遍历问题

  1. LeetCode 59. 螺旋矩阵 II：
    给定一个正整数 n，生成一个包含 1 到 n² 所有元素，且元素按顺时针螺旋排列的 n x n 正方形矩阵。

    这是螺旋矩阵的逆问题，需要按照螺旋顺序填充矩阵，而不是遍历矩阵。解法思路与螺旋矩阵相似，只是将读取操作变为写入操作。

  2. LeetCode 885. 螺旋矩阵 III：
    在 R 行 C 列的矩阵上，我们从 (r0, c0) 开始，顺时针螺旋行走，每次行走到矩阵中的未访问过的单元格。返回访问过的单元格坐标的列表。

  3. LeetCode 2326. 矩阵中的不可行路径：
    给你一个 m x n 的矩阵和一个链表头节点 head，按照螺旋顺序访问矩阵，同时将链表中的值依次填入矩阵。

8.2 其他遍历问题

  1. LeetCode 74. 搜索二维矩阵：
    编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。虽然不是螺旋遍历，但也涉及矩阵的有效搜索。

  2. LeetCode 48. 旋转图像：
    给定一个 n × n 的二维矩阵表示一个图像，将图像顺时针旋转 90 度。这与螺旋矩阵的顺时针遍历有关联。

  3. LeetCode 240. 搜索二维矩阵 II：
    编写一个高效的算法来搜索 m x n 矩阵中的一个目标值，矩阵具有特定的排序特性。

9. 实际应用场景

螺旋矩阵算法在实际应用中有多种用途：

  1. 图像处理：

    • 某些图像处理算法需要从中心向外或从外向内螺旋遍历像素
    • 例如，某些图像压缩算法可能使用螺旋序列来组织像素，从而更好地保留相关性

  2. 数据可视化：

    • 在某些数据可视化技术中，数据点可能按螺旋方式排列，以有效利用空间
    • 例如，螺旋树图（Spiral Treemaps）用于可视化层次数据结构

  3. 芯片设计：

    • 在集成电路设计中，某些布线算法可能使用螺旋模式来优化信号路径
    • 天线设计中也可能使用螺旋模式来优化接收特性

  4. 机器人路径规划：

    • 自主机器人在探索未知环境时，可能采用螺旋路径以确保全面覆盖
    • 例如，扫地机器人通常使用螺旋模式来覆盖房间的地板

  5. 游戏开发：

    • 在游戏地图或关卡设计中，可能使用螺旋模式来组织游戏元素
    • 某些策略游戏的地图生成算法可能使用螺旋遍历来分配资源或地形

  6. 数学教育：

    • 螺旋矩阵是教授矩阵遍历、边界处理和方向变换的优秀实例
    • 可用于解释递归和迭代算法的差异

10. 完整的 Java 解决方案

以下是结合了各种优化和最佳实践的完整解决方案：

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        // 处理边界情况
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return new ArrayList<>();
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        List<Integer> result = new ArrayList<>(m * n); // 预分配容量
        
        // 定义四个边界
        int top = 0;
        int right = n - 1;
        int bottom = m - 1;
        int left = 0;
        
        // 循环遍历，直到所有元素都被访问
        while (top <= bottom && left <= right) {
            // 从左到右遍历上边界
            for (int j = left; j <= right; j++) {
                result.add(matrix[top][j]);
            }
            top++; // 上边界下移
            
            // 从上到下遍历右边界
            for (int i = top; i <= bottom; i++) {
                result.add(matrix[i][right]);
            }
            right--; // 右边界左移
            
            // 检查是否还有行未被遍历
            if (top <= bottom) {
                // 从右到左遍历下边界
                for (int j = right; j >= left; j--) {
                    result.add(matrix[bottom][j]);
                }
                bottom--; // 下边界上移
            }
            
            // 检查是否还有列未被遍历
            if (left <= right) {
                // 从下到上遍历左边界
                for (int i = bottom; i >= top; i--) {
                    result.add(matrix[i][left]);
                }
                left++; // 左边界右移
            }
        }
        
        return result;
    }
}

此解决方案使用四边界模拟法，具有以下特点：

  1. 全面处理边界情况，包括空矩阵检查
  2. 预分配结果列表的容量，优化内存使用
  3. 使用清晰的边界变量和遍历顺序，提高代码可读性
  4. 加入必要的条件检查，确保正确处理矩阵中的所有元素
  5. 结构清晰，易于理解和维护

该解决方案在LeetCode上的表现非常好，执行时间和内存使用都处于优秀水平。

11. 总结与技巧

11.1 解题要点

  1. 理解螺旋遍历的基本模式：

    • 顺时针遍历：右→下→左→上
    • 每遍历完一圈后，边界向内收缩
    • 最终可能剩下一行、一列或一个元素

  2. 边界处理的重要性：

    • 正确定义和更新边界是解决螺旋矩阵问题的关键
    • 特别注意边界相等的情况，如单行或单列矩阵

  3. 条件检查的必要性：

    • 在遍历下边界和左边界之前，需要检查是否还有行或列未被遍历
    • 这是避免重复遍历元素的重要步骤

  4. 解法选择的考虑因素：

    • 四边界模拟法：直观，空间效率高，适合大多数场景
    • 方向数组模拟法：灵活，易于扩展，但需要额外空间
    • 层次遍历法：思路清晰，代码结构优美，是解决此类问题的优秀方法

11.2 学习收获

通过学习螺旋矩阵问题，你可以掌握：

  • 二维数组的遍历技巧和模式
  • 边界条件的处理方法
  • 方向变换的控制策略
  • 循环不变量的维护技巧
  • 多种解法的权衡与选择

11.3 面试技巧

如果在面试中遇到此类问题：

  1. 先分析问题，理解螺旋遍历的模式
  2. 从简单例子开始，手动跟踪螺旋遍历的过程
  3. 明确选择一种解法，并清晰地解释思路
  4. 特别关注边界情况的处理，如空矩阵、单行或单列矩阵
  5. 讨论可能的优化方向，如内存使用或执行效率的改进

螺旋矩阵是一个经典问题，掌握其解法不仅能够应对面试，还能帮助理解更复杂的矩阵操作问题。

【LeetCode 热题 100】54. 螺旋矩阵题解：一文彻底搞懂边界控制与顺时针遍历
未名编程
05-16 27
本文介绍了如何按顺时针螺旋顺序遍历二维矩阵并返回所有元素。通过定义四个边界变量（top、bottom、left、right），逐层缩小矩阵边界，依次从左到右、从上到下、从右到左、从下到上遍历矩阵。代码实现中需要注意 range 的左闭右开特性，并在逆向遍历前添加边界判断，防止重复访问。文章还提供了记忆口诀和拓展练习，帮助读者更好地掌握这一技巧。
LeetCode 第54题：螺旋矩阵
Gemini的博客
06-03 227
螺旋矩阵问题通过清晰的边界和遍历方向，顺时针遍历矩阵中的所有元素。通过定义边界和更新边界，我们可以有效地解决这个问题。### 解决问题的关键点 1. **边界定义和更新**：四个边界（上、下、左、右）用于控制遍历的范围，每遍历完一圈后更新边界，逐步缩小范围。 2. **遍历顺序**：按顺时针方向依次遍历四个边界，从左到右，从上到下，从右到左，从下到上，确保遍历顺序正确。 3. **终止条件**：当上边界大于下边界或左边界大于右边界时，终止遍历。
LeetCode 54.螺旋矩阵遍历的两种方法详解与对比
weixin_44435110的博客
05-06 317
边界调整法适合实际应用场景，尤其是大规模矩阵遍历。通过逐层收缩边界，时间和空间复杂度均最优。矩阵旋转法适合理解螺旋遍历的逻辑本质，但时间和空间开销较大，仅推荐在小规模数据或教学场景使用。两种方法各有优劣，开发者可根据具体需求选择实现方式。若追求性能，优先选择边界调整法；若需快速验证逻辑，可尝试矩阵旋转法。
leetcode之hot100---54螺旋矩阵（C++）
axxy2000的博客
12-18 330
模拟螺旋矩阵的路径，路径超出界限，顺时针旋转，使用一个数组记录当前数字是否被访问到，直到所有的数字全部被访问constexpr的使用是告诉大家该数组为一个常量表达式，在编译的过程中其值不会改变；；都可以使用这个方向数组时间复杂度：O(mn)空间复杂度：O(mn)
leetcode54. 螺旋矩阵(详解)
qq_48508278的博客
03-28 513
一:题目 二:上码 class Solution { public: /** 思路: 1. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 2.我们模拟顺时针的顺序,那么得分为4步 上面得一行 (1,2,3) 左面得一行 (4,8,12)
leetcode54 题螺旋矩阵详解
m0_72877724的博客
07-10 469
这种方法通过维护四个边界来控制遍历的方向，并在每次遍历一行或一列后调整相应的边界，确保每个元素都被正确地访问。该算法的时间复杂度为 O(m×n)，其中 m 和 n 分别是矩阵的行数和列数。
【算法-LeetCode】54. 螺旋矩阵（二维数组）
赖念安的博客
08-18 1901
54. 螺旋矩阵 - 力扣（LeetCode） 发布：2021年8月18日17:09:11 问题描述及示例 给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。 示例 1： 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5] 示例 2： 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输出：[1,2,3,4,8,12
LeetCode 热题 100之矩阵
qq_43060884的博客
10-27 627
矩阵很有意思~
Leetcode详解JAVA版
qq_42364307的博客
02-15 3171
leetcode Java详解
LeetCode算法解决方案集锦：数组问题详解
12. 螺旋矩阵（Spiral Matrix） - 需要遍历矩阵的元素，按螺旋方式从外向内一圈圈进行。这需要较为复杂的边界处理。 13. 排序两个和（Sort Colors） - 类似于荷兰国旗问题，需要将数组中的0、1、2三种元素排序。...
【LeetCode】第54题——螺旋矩阵（难度：中等）
Se7en_Dayz的博客
05-14 317
【LeetCode】第54题——螺旋矩阵（难度：中等）题目描述解题思路代码详解注意点 题目描述 给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。 示例 1： 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 输出：[1,2,3,6,9,8,7,4,5] 示例 2： 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]] 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
Leetcode各种题型题目+思路+代码（共176道题）
热门推荐
JJJJJJames的博客
03-09 1万+
1、Leetcode-1047 题目描述： 题目思路： 使用stack的思路，先把字符串的第一个字母压栈，然后判断下一个待压栈的字母是否与stack[-1]的字母相同，如果相同，该字母不进入stack中，且stack.pop()将重复的字母剔除。如此遍历一遍字符串，最后返回stack中的元素即为消除重复字后的字符串。 举例：“abbaca” 建立栈 把a压栈 b与a不相同，压栈 第二个b和stack栈口元素相同，不要第二个b且把栈扣的b pop掉。 第四个元素：a，此时stack中还有一个元素a，相同，
【Leetcode 每日一题】3355. 零数组变换 I
冠位优化
05-20 524
Leetcode 每日一题 - 零数组变换 I
leetcode 92. Reverse Linked List II
weixin_41554427的博客
05-21 367
思路很简答，但一次性通过还是有点难度的。是第206题的进阶版。
每日leetcode
XiaoyaoCarter的博客
05-22 302
你可以假设除了整数 0 之外，这个整数不会以零开头。最高位数字存放在数组的首位， 数组中每个元素只存储。数组所表示的非负整数，在该数的基础上加一。加 1 得到了 9 + 1 = 10。因此，结果应该是 [1,0]。输入数组表示数字 4321。输入数组表示数字 123。输入数组表示数字 9。
力扣-最大连续一的个数
最新发布
2301_79446157的博客
05-23 364
left和right，让他们都。
力扣网-复写零
2301_79446157的博客
05-19 505
本文介绍了力扣（LeetCode）上第1089题“复写零”的解题方法。题目要求在原数组中复写所有的零，同时保持数组长度不变。解题思路采用双指针算法，首先通过嵌套双指针找到起始位置，处理特殊情况如数组倒数第二个元素为零时可能导致的越界问题。然后，从后往前遍历数组，根据当前元素是否为零进行相应的复写操作。通过巧妙地使用指针移动和赋值操作，确保在不覆盖原有数据的情况下完成复写任务。该方法有效避免了从前往后遍历时可能出现的覆盖问题，确保了算法的正确性和效率。
解决leetcode第3548题.等和矩阵分割II
2302_79682652的博客
05-22 463
本文介绍了一个关于矩阵分割的算法问题，要求判断是否可以通过水平或垂直分割线将矩阵分成两部分，使得两部分的元素和相等，或者最多移除一个单元格后使它们相等，并且保持连通性。文章详细描述了问题的背景、示例、分析思路以及实现方法。通过设计多个辅助函数，如检查连通性、计算矩阵和、按行或列分割矩阵等，最终实现了一个主函数来判断是否存在满足条件的分割方式。文章还提供了多个运行实例，验证了算法的正确性。
动态规划-LCR 090.打家劫舍II-力扣(LeetCode)
black_bear_white的博客
05-20 504
打家劫舍返回值为max(f[n-1],g[n-1])(n为nums的大小),打家劫舍II的返回值为max(nums[0]+rob1(nums,2,n-2),rob1(nums,1,n-1))f[0]=nums[0],g[0]=0,rob1函数初始化为f[left]=nums[left],g[left]=0，这里的rob1函数就是打家劫舍里的函数修改符合区间操作的。对于到达i位置时，此时金额最大，并且存在该位置是否偷窃的问题，所以f[i]表示：到达i位置时，偷房间时，此时的最大金额；从左往右，两个表一起填。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

全栈凯哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值