[剑指-Offer] 29. 顺时针打印矩阵(边界情况、代码优化、多方法)

本文链接：https://blog.csdn.net/yl_puyu/article/details/104584489

文章目录

1. 题目来源

链接：顺时针打印矩阵
来源：LeetCode——《剑指-Offer》专项

2. 题目说明

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 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]

限制：

0 <= matrix.length <= 100
0 <= matrix[i].length <= 100

3. 题目解析

方法一：边界情况+循环结束判断+常规解法

这个问题拿到手题意还是很明确的，就一圈圈的往里缩就行了，每次缩一圈，行列相当于都减少二，那么循环条件就出来了，row - 2 * start > 0 && col - 2 * start > 0 在此就需要考虑下等于 0 的情况会不会出现就行了，这个很好判断，一个简单的逆向思维：如果等于 0 了，那再进入循环内部打印什么呢？所以等号不成立。

最中间的环可以是一个数字，也可以是一行或者一列。

相应还有一个注意点就是：我们将矩阵打印一圈的过程分为四步，这个矩阵的打印开始时，第一步都是从左到右打印的，而第一步是必不可少的。但是，如果只有一行的话，那就不需要第二步的从上到下打印了。同理下面的第三步、第四步都有如下相关约束：

第二步前提：终止行号大于起始行号
第三步前提：该圈矩阵至少有两行两列，也就是说，除了终止行号大于起始行号还要求终止列号大于起始列号
第四步前提：至少有三行两列，即终止行号比起始行号至少大 2，这个理解不了的想想田字格就行了

这一块的主要边界判断就是这三块，还是很细节的。这样的问题出来最好的方式一定是画图举例，才能做到多种情况不重不漏，先有一个大致的解决方案，再去思考下有什么巧妙的解法，体会做题的快乐。

参见代码如下：

// 执行用时 :12 ms, 在所有 C++ 提交中击败了82.41%的用户
// 内存消耗 :12.5 MB, 在所有 C++ 提交中击败了100.00%的用户

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> vt;
        if (matrix.size() == 0 || matrix[0].size() == 0) return vt;
        int row = matrix.size(), col = matrix[0].size(), start = 0; 

        while (col > start * 2 && row > start * 2) {
            int endX = col - 1 - start;
            int endY = row - 1 - start;

            // 从左到右打印一行
            for (int i = start; i <= endX; ++i) 
                vt.push_back(matrix[start][i]);
            // 从上到下打印一列
            if (start < endY) {
                for (int i = start + 1; i <= endY; ++i)
                    vt.push_back(matrix[i][endX]);
            }
            // 从右到左打印一行
            if (start < endX && start < endY) {
                for (int i = endX - 1; i >= start; --i)
                    vt.push_back(matrix[endY][i]);
            }
            // 从下到上打印一行
            if (start < endX && start < endY - 1)
                for (int i = endY - 1; i >= start + 1; --i)
                    vt.push_back(matrix[i][start]);
            ++start;
        }
        return vt;
    }
};

方法二：下标转化法

环数的计算公式是 $\frac{min(m, n)}{2}$ ，知道了环数，只要找到坐标关系，就可以对每个环的边按顺序打印。

定义 p，q 为当前环的高度和宽度，当 p 或者 q 为 1 时，表示最后一个环只有一行或者一列，可以跳出循环。

该做法的难点在于下标的转换，如何正确的转换下标是解决的关键，可以对照 3x3 的例子来完成下标的填写。

参见代码如下：

// 执行用时 :8 ms, 在所有 C++ 提交中击败了97.04%的用户
// 内存消耗 :12.5 MB, 在所有 C++ 提交中击败了100.00%的用户

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int> > &matrix) {
        if (matrix.empty() || matrix[0].empty()) return {};
        int m = matrix.size(), n = matrix[0].size();
        vector<int> res;
        int c = m > n ? (n + 1) / 2 : (m + 1) / 2;
        int p = m, q = n;
        for (int i = 0; i < c; ++i, p -= 2, q -= 2) {
            for (int col = i; col < i + q; ++col) 
                res.push_back(matrix[i][col]);
            for (int row = i + 1; row < i + p; ++row)
                res.push_back(matrix[row][i + q - 1]);
            if (p == 1 || q == 1) break;
            for (int col = i + q - 2; col >= i; --col)
                res.push_back(matrix[i + p - 1][col]);
            for (int row = i + p - 2; row > i; --row) 
                res.push_back(matrix[row][i]);
        }
        return res;
    }
};

方法三：迷宫遍历法

使用类似迷宫遍历的方法，这里只要设定正确的遍历策略，还是可以按螺旋的方式走完整个矩阵的，起点就是（0，0） 位置，但是方向数组一定要注意，不能随便写，开始时是要往右走，到了边界或者访问过的位置后，就往下，然后往左，再往上，所以 dirs 数组的顺序是 右->下->左->上，由于原数组中不会有 -10000（在这只是草率的随意赋了一个值，不行的话就 bool 矩阵即可），所以就可以将访问过的位置标记为 -10000，这样再判断新位置的时候，只要其越界了，或者是遇到 -10000 了，就表明此时需要转弯了，到 dirs 数组中去取转向的 offset，得到新位置，注意这里的 dirs 数组中取是按循环数组的方式来操作，加 1 然后对 4 取余，按照这种类似迷宫遍历的方法也可以螺旋遍历矩阵。

很直观的写法，也没那么多的公式推导在里面，但对边界情况把握的又相当到位，很值得细品、学习。

参见代码如下：

// 执行用时 :16 ms, 在所有 C++ 提交中击败了47.43%的用户
// 内存消耗 :12.5 MB, 在所有 C++ 提交中击败了100.00%的用户

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty() || matrix[0].empty()) return {};
        int m = matrix.size(), n = matrix[0].size(), idx = 0, i = 0, j = 0;
        vector<int> res;
        vector<vector<int>> dirs{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        for (int k = 0; k < m * n; ++k) {
            res.push_back(matrix[i][j]);
            matrix[i][j] = -10000;
            int x = i + dirs[idx][0], y = j + dirs[idx][1];
            if (x < 0 || x >= m || y < 0 || y >= n || matrix[x][y] == -10000) {
                idx = (idx + 1) % 4;
                x = i + dirs[idx][0];
                y = j + dirs[idx][1];
            }
            i = x;
            j = y;
        }
        return res;
    }
};