LeetCode 54. 螺旋矩阵 Java实现

Lentr0py

于 2025-01-01 14:17:09 发布

阅读量801

点赞数 22

分类专栏： LeetCode 算法题文章标签： leetcode 矩阵 java

本文链接：https://blog.youkuaiyun.com/Lentr0py/article/details/144867243

版权

LeetCode 算法题专栏收录该内容

53 篇文章

订阅专栏

54. 螺旋矩阵

54. 螺旋矩阵

54. 螺旋矩阵

题目来源

54. 螺旋矩阵

题目分析

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

题目难度

难度：中等

题目标签

标签：数组、矩阵

题目限制

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

解题思路

思路：模拟螺旋过程

问题定义：
- 需要按照顺时针螺旋顺序遍历矩阵并返回所有元素。
核心算法：
- 使用四个变量分别表示矩阵的左、右、上、下边界。
- 通过循环逐步缩小边界，模拟螺旋遍历的过程。
关键步骤：
- 遍历矩阵的上边界，并向右移动。
- 遍历矩阵的右边界，并向下移动。
- 如果还有剩余行和列，遍历矩阵的下边界，并向左移动。
- 如果还有剩余行和列，遍历矩阵的左边界，并向上移动。
- 收缩边界，重复上述过程，直到遍历完所有元素。

核心算法步骤

初始化边界：
- left、right、top、bottom 分别表示矩阵的左、右、上、下边界。
遍历并收缩边界：
- While循环，条件为 left <= right && top <= bottom。
- 遍历上边界，从左到右。
- 遍历右边界，从上到下。
- 如果内层还有空间，遍历下边界，从右到左。
- 如果内层还有空间，遍历左边界，从下到上。
- 收缩边界：left++、right--、top++、bottom--。
返回结果：
- 将遍历到的元素添加到结果列表中，最后返回该列表。

代码实现

以下是 Java 代码实现：

/**
 * 54. 螺旋矩阵
 * @param matrix 矩阵
 * @return List<Integer> 顺时针螺旋顺序
 */
public List<Integer> spiralOrder(int[][] matrix) {
    List<Integer> ans = new ArrayList<>();
    int m = matrix.length;
    int n = matrix[0].length;
    int left = 0, right = n - 1, top = 0, bottom = m - 1;
    while (left <= right && top <= bottom) {
        for (int i = left; i <= right; i++) {
            ans.add(matrix[top][i]);
        }
        for (int i = top + 1; i <= bottom; i++) {
            ans.add(matrix[i][right]);
        }
        if (left < right && top < bottom) {
            for (int i = right - 1; i > left; i--) {
                ans.add(matrix[bottom][i]);
            }
            for (int i = bottom; i > top; i--) {
                ans.add(matrix[i][left]);
            }
        }
        left++;
        right--;
        top++;
        bottom--;
    }
    return ans;
}

代码解读

边界初始化：设置初始的左、右、上、下边界。
遍历过程：通过四个for循环分别遍历矩阵的四个边界，并在每次遍历后收缩边界。
边界条件：在内层遍历前检查是否还有剩余的行和列，以避免重复遍历。

性能分析

时间复杂度：O(m*n)，其中m和n分别是矩阵的行数和列数。每个元素都被访问一次。
空间复杂度：O(1)，除了用于存储结果的列表外，使用的额外空间是常数级别的。

测试用例

你可以使用以下测试用例来验证代码的正确性：

// 测试用例1
int[][] matrix1 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
System.out.println(spiralOrder(matrix1)); // 输出: [1, 2, 3, 6, 9, 8, 7, 4, 5]
// 测试用例2
int[][] matrix2 = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};
System.out.println(spiralOrder(matrix2)); // 输出: [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]
// 测试用例3
int[][] matrix3 = {
    {1}
};
System.out.println(spiralOrder(matrix3)); // 输出: [1]
// 测试用例4
int[][] matrix4 = {
    {1, 2},
    {3, 4}
};
System.out.println(spiralOrder(matrix4)); // 输出: [1, 2, 4, 3]
// 测试用例5
int[][] matrix5 = {
    {1, 2, 3},
    {4, 5, 6}
};
System.out.println(spiralOrder(matrix5)); // 输出: [1, 2, 3, 6, 5, 4]