54. 螺旋矩阵

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]

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/spiral-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

辅助数组

此题需要按照螺旋顺序来遍历一遍二维数组，有两个问题，第一个是遍历时什么时候该转向，第二个是转向时该向哪个方向转。

对于第一个问题，设置一个flag数组，用来判断每个位置是否被遍历过。当访问下个点之前，先查看下个点是否越界或者该点是否已经被访问过，如果有的话，则应该进行转向。

对于第二个问题，设置一个数组用来存储四个方向各自的 i 和 j 的增量即可。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        vector<vector<bool>> flag(m, vector<bool>(n, false)); // 判断该点是否被访问过
        vector<int> res(m*n);

        vector<pair<int,int>> order(4); //方向的数组
        order[0] = {0,1}; //右
        order[1] = {1,0}; //下
        order[2] = {0,-1};//左
        order[3] = {-1,0};//上

        int p = 0, a=0, b=0; //初始方向是右，初始点是(0,0)
        for(int i=0;i<m*n;i++)
        {
            flag[a][b] = true;
            res[i] = matrix[a][b];
            int x = order[p].first, y = order[p].second;
            if(a+x>=0 && a+x<m && b+y>=0 && b+y <n && flag[a+x][b+y] == false) //到边界或到false即转向
            {
                p = p; //do nothing
            }
            else{
                p = (p+1)%4;
            }
            a = a+order[p].first;
            b = b+order[p].second;
        }
        return res;
    }
};

时间复杂度为$O(mn)$，空间复杂度为$O(mn)$。

记录边界

另一种思路是用四个整形来记录上下左右四个边界，当遍历一行或一列时，某一个边界则移动一位，用以代表那行出界。

我们只需要按照上、右、下、左的顺序来遍历，同时边界改变并判断上边界大于下边界或左边界大于右边界（如果是则break）。

就像剥洋葱一样，转着圈一层一层的剥。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> res;

        // 定义上下左右边界
        int up = 0;
        int down = matrix.size()-1;
        int left = 0;
        int right = matrix[0].size()-1;

        int i=0, j=0;
        while(true)
        {
            // 从左向右
            for(j=left; j<=right; j++)
            {
                res.push_back(matrix[up][j]);
            }
            up += 1;
            if(up>down)
            {
                break;
            }
            // 从上到下
            for(i=up; i<=down; i++)
            {
                res.push_back(matrix[i][right]);
            }
            right -=1;
            if(left>right)
            {
                break;
            }
            // 从右到左
            for(j=right;j>=left;j--)
            {
                res.push_back(matrix[down][j]);
            }
            down -=1;
            if(up>down)
            {
                break;
            }
            //从下到上
            for(i=down; i>=up; i--)
            {
                res.push_back(matrix[i][left]);
            }
            left += 1;
            if(left>right)
            {
                break;
            }
        }
        return res;
    }
};

时间复杂度为$O(mn)$，空间复杂度为$O(1)$。