【LeetCode热题100】【矩阵】螺旋矩阵

MaolinYe（叶茂林）

已于 2024-07-07 20:10:22 修改

阅读量343

点赞数 4

分类专栏： # LeetCode热题 100 文章标签：算法 leetcode

于 2024-04-15 21:18:30 首次发布

叶茂林

本文链接：https://blog.csdn.net/weixin_62264287/article/details/137795667

版权

LeetCode热题 100 专栏收录该内容

100 篇文章 3 订阅

订阅专栏

文章介绍了如何使用递归和迭代方法在LeetCode题目54中解决螺旋矩阵的遍历问题，重点在于理解先走外部圆圈再到内部的逻辑，并处理边界条件以避免重复。

摘要由CSDN通过智能技术生成

题目链接：54. 螺旋矩阵 - 力扣（LeetCode）

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

因为这个螺旋矩阵可能不是方的，所以在走完右上角这两条边后之后看看是不是已经填满了

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int left = 0, top = 0, right = matrix[0].size() - 1,
            bottom = matrix.size() - 1;
        std::vector<int> ans;
        size_t count = matrix.size() * matrix[0].size();
        ans.reserve(count);
        while (ans.size() < count) {
            for (int i = left; i <= right; ++i) {
                ans.push_back(matrix[top][i]);
            }
            ++top;
            for (int i = top; i <= bottom; ++i) {
                ans.push_back(matrix[i][right]);
            }
            --right;
            if (ans.size() == count)
                break;
            for (int i = right; i >= left; --i) {
                ans.push_back(matrix[bottom][i]);
            }
            --bottom;
            for (int i = bottom; i >= top; --i) {
                ans.push_back(matrix[i][left]);
            }
            ++left;
        }
        return ans;
    }
};

先走外面的圈再走里面的圈，可以用递归来解决，对于要走的一个圈，由四个角决定，其实是三个数，（0，0），（0，n），（m，0），（m，n），每次先从左上角走到右上角，再走到右下角，再走到左下角，再走回来

对于后面两个的往回走要在m和n不等于起点的情况下，否则会重复最后

class Solution {
public:
    vector<int> ans;
    vector<vector<int> > matrix;

    void go(int start, int row, int column) {
        if (start > row || start > column)
            return;
        for (int i = start; i <= column; ++i)
            ans.push_back(matrix[start][i]);
        for (int i = start + 1; i <= row; ++i)
            ans.push_back(matrix[i][column]);
        if (row != start)
            for (int i = column - 1; i >= start; --i)
                ans.push_back(matrix[row][i]);
        if (column != start)
            for (int i = row - 1; i > start; --i)
                ans.push_back(matrix[i][start]);
        go(start + 1, row - 1, column - 1);
    }

    vector<int> spiralOrder(vector<vector<int> > &matrix) {
        this->matrix = move(matrix);
        go(0, this->matrix.size() - 1, this->matrix[0].size() - 1);
        return ans;
    }
};

不用递归也可以，改成迭代

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int> > &matrix) {
        vector<int> ans;
        int start = 0, row = matrix.size() - 1, column = matrix[0].size() - 1;
        while (true) {
            if (start > row || start > column)
                break;
            for (int i = start; i <= column; ++i)
                ans.push_back(matrix[start][i]);
            for (int i = start + 1; i <= row; ++i)
                ans.push_back(matrix[i][column]);
            if (row != start)
                for (int i = column - 1; i >= start; --i)
                    ans.push_back(matrix[row][i]);
            if (column != start)
                for (int i = row - 1; i > start; --i)
                    ans.push_back(matrix[i][start]);
            ++start;
            --row;
            --column;
        }
        return ans;
    }
};