力扣刷题54. 螺旋矩阵(java)

最新推荐文章于 2025-01-16 21:24:54 发布

happytaohaha

最新推荐文章于 2025-01-16 21:24:54 发布

阅读量266

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/NumberOneStudent/article/details/100806332

力扣腾讯精选50道专栏收录该内容

62 篇文章

订阅专栏

本文介绍了一种矩阵螺旋遍历的算法实现，通过模拟前进走法和层级法两种策略，详细解析了如何按顺时针螺旋顺序遍历矩阵中的所有元素。提供了具体的代码示例，包括使用方向数组和边界条件来优化遍历过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]

示例 2:

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

解答

1.模拟前进的走法
假设当前位置为 (r,c) 初始化位置为(0,0) 初始化向右走到头后选择一个方向走
方向我们抽象为两个数组正好对应上下左右走

        int[] dr = {0, 1, 0, -1};  //向上 -1 下走 1 不走  0  行走
        int[] dc = {1, 0, -1, 0};    //左  -1 右走 1 不走  0    正好对应

然后又一个是否看过flag的数组作为标记，一旦遇到标记为true 就换到下一个方向

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List ans = new ArrayList();
        if (matrix.length == 0) return ans;
        int R = matrix.length, C = matrix[0].length;
        boolean[][] seen = new boolean[R][C];
        int[] dr = {0, 1, 0, -1};
        int[] dc = {1, 0, -1, 0};
        int r = 0, c = 0, di = 0;
        for (int i = 0; i < R * C; i++) {
            ans.add(matrix[r][c]);
            seen[r][c] = true;
            int cr = r + dr[di];
            int cc = c + dc[di];
            if (0 <= cr && cr < R && 0 <= cc && cc < C && !seen[cr][cc]){
                r = cr;
                c = cc;
            } else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
            }
        }
        return ans;
    }
}

不需要额外的空间只需要每次改变方向时将判断的条件更新

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List ans = new ArrayList();
        if (matrix.length == 0) return ans;
        int R = matrix.length, C = matrix[0].length;
        boolean[][] seen = new boolean[R][C];
        int[] dr = {0, 1, 0, -1};  // 行
        int[] dc = {1, 0, -1, 0}; // 列
        int r = 0, c = 0, di = 0;
        int r0 = 0,r1 = R, c0 = 0, c1 = C;
        for (int i = 0; i < R * C; i++) {
            ans.add(matrix[r][c]);
//            seen[r][c] = true;
            int cr = r + dr[di];
            int cc = c + dc[di];
            if (r0 <= cr && cr < r1 && c0 <= cc && cc < c1 ){
                r = cr;
                c = cc;
            } else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
                if(dr[di] ==1 ){
                    r0++;
                }
                if(dr[di] == -1){
                    r1--;
                }
                if(dc[di] == 1){
                    c0++;
                }
                if(dc[di] == -1){
                    c1--;
                }
            }
        }
        return ans;
    }
}

层级法一层一层的遍历每层的顺序为 → ↓ ←↑

class Solution {
    public List < Integer > spiralOrder(int[][] matrix) {
        List ans = new ArrayList();
        if (matrix.length == 0)
            return ans;
        int r1 = 0, r2 = matrix.length - 1;
        int c1 = 0, c2 = matrix[0].length - 1;
        while (r1 <= r2 && c1 <= c2) {
            for (int c = c1; c <= c2; c++) ans.add(matrix[r1][c]);
            for (int r = r1 + 1; r <= r2; r++) ans.add(matrix[r][c2]);
            if (r1 < r2 && c1 < c2) {
                for (int c = c2 - 1; c > c1; c--) ans.add(matrix[r2][c]);
                for (int r = r2; r > r1; r--) ans.add(matrix[r][c1]);
            }
            r1++;
            r2--;
            c1++;
            c2--;
        }
        return ans;
    }
}