📝 题目描述

题目链接：螺旋矩阵

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

示例：

示例 1：

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

示例 2：

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]

提示：

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

💡 解题思路

方法一：模拟

最容易想到的方法就是模拟螺旋矩阵的路径。

初始位置是矩阵的左上角，初始方向是向右。

需要注意一下改变方向的边界条件，当路径超出界限或者进入之前访问过的位置时，顺时针旋转，进入下一个方向。

判断路径是否进入之前访问过的位置需要使用一个与输入矩阵大小相同的辅助矩阵 visited，其中的每个元素表示该位置是否被访问过。当一个元素被访问时，将 visited 中的对应位置的元素设为已访问。

如何判断路径是否结束？由于矩阵中的每个元素都被访问一次，因此路径的长度即为矩阵中的元素数量，当路径的长度达到矩阵中的元素数量时即为完整路径，将该路径返回。

方法二：分层✅️

我们可以将矩阵想象成洋葱，规定好当前的上界层、下界层、左界层、右界层。访问一层后，就将对应的界层加一/减一。

同样要注意一下边界条件，当上界>下界或者左界>右界时，就可以退出循环。

🔧 代码实现

1、模拟

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty()) return {};
        int m = matrix.size(), n = matrix[0].size();
        int total = m * n;
        // 记录是否被访问过
        vector<vector<bool>> visited(m, vector<bool>(n));
        // 设置四个方向
        vector<vector<int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        // 答案数组
        vector<int> answers;
        int row = 0, col = 0, nextrow = 0, nextcol = 0, direct_index = 0;
        for (int i = 0; i < total; i++) {
            answers.push_back(matrix[row][col]);
            visited[row][col] = true;
            nextrow = row + directions[direct_index][0], nextcol = col + directions[direct_index][1];
            // 如果越界/已访问过
            if (nextrow < 0 || nextrow >= m || nextcol < 0 || nextcol >= n || visited[nextrow][nextcol]) {
                direct_index = (direct_index + 1) % 4;
            }
            row = row + directions[direct_index][0], col = col + directions[direct_index][1];
        }

        return answers;
    }
};

2、分层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty()) return {};
        int m = matrix.size(), n = matrix[0].size();
        vector<int> ans;
        // 规定好上下左右界
        int up = 0, down = m - 1, left = 0, right = n - 1;
        // 开始剥层
        while (true) {
            for (int i = left; i <= right; i++) ans.push_back(matrix[up][i]);
            up++;
            if (up > down) break;
            for (int i = up; i <= down; i++) ans.push_back(matrix[i][right]);
            right--;
            if (left > right) break;
            for (int i = right; i >= left; i--) ans.push_back(matrix[down][i]);
            down--;
            if (up > down) break;
            for (int i = down; i >= up; i--) ans.push_back(matrix[i][left]);
            left++;
            if (left > right) break;
        }
        return ans;
    }
};

📊 复杂度分析

1、模拟

  • 时间复杂度：O(mn)O(mn)，其中 m 和 n 分别是输入矩阵的行数和列数。矩阵中的每个元素都要被访问一次。
  • 空间复杂度：O(mn)O(mn)。需要创建一个大小为 m×n 的矩阵 visited 记录每个位置是否被访问过。

2、分层

  • 时间复杂度：O(mn)O(mn)，其中 m 和 n 分别是输入矩阵的行数和列数。矩阵中的每个元素都要被访问一次。
  • 空间复杂度：O(1)O(1)。除了输出数组以外，空间复杂度是常数。

🎯 总结

  • 核心思想：记住分层解法。