Leetcode 54. 螺旋矩阵

JehanRio

已于 2023-09-08 10:09:36 修改

阅读量88

点赞数

分类专栏： Leetcode专栏文章标签： leetcode 矩阵算法

于 2023-07-03 13:50:55 首次发布

本文链接：https://blog.csdn.net/weixin_51322383/article/details/131514060

版权

Leetcode专栏专栏收录该内容

278 篇文章 0 订阅

订阅专栏

文章目录

题目
代码（首刷部分看解析）
代码（8.31 二刷自解）
代码（9.8 三刷自解）

题目

在这里插入图片描述
Leetcode 54. 螺旋矩阵

代码（首刷部分看解析）

注意每次for循环都需要判断下边界问题，否则在一次while循环中就已经超出界限了

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> res;
        int m = matrix.size(), n = matrix[0].size();
        int left = 0, right = n - 1, up = 0, down = m - 1;
        while(res.size() < m*n) {
            if(up <= down) {
                for(int i = left; i <= right; i++) {
                res.push_back(matrix[up][i]);
                }
                up++;
            }
            if(left <= right) {
                for(int i = up; i <= down; i++) {
                res.push_back(matrix[i][right]);
                }
                right--;
            }
            if(up <= down) {
                for(int i = right; i >= left; i--) {
                res.push_back(matrix[down][i]);
                }
                down--;
            }
            if(left <= right) {
                 for(int i = down; i >= up; i--) {
                res.push_back(matrix[i][left]);
                }
                left++;
            }
        }
        return res;
    }
};

代码（8.31 二刷自解）

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int> >& matrix) {
        if(matrix.size() == 0)
            return {};
        int m = matrix.size(), n = matrix[0].size();
        int left_bound = 0, right_bound = n - 1;
        int up_bound = 0, down_bound = m - 1;
        vector<int> res;
        while(left_bound <= right_bound && up_bound <= down_bound) {
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = left_bound; i <= right_bound; i++) {
                    res.emplace_back(matrix[up_bound][i]);
                }
                up_bound++;
            }
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = up_bound; i <= down_bound; i++) {
                    res.emplace_back(matrix[i][right_bound]);
                }
                right_bound--;
            }
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = right_bound; i >= left_bound; i--) {
                    res.emplace_back(matrix[down_bound][i]);
                }
                down_bound--;
            }
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = down_bound; i >= up_bound; i--) {
                    res.emplace_back(matrix[i][left_bound]);
                }
                left_bound++;
            }
        }
        return res;
    }
};

代码（9.8 三刷自解）

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        int left_bound = 0, right_bound = n-1, up_bound = 0, down_bound = m-1;
        vector<int> res;
        while(left_bound <= right_bound && up_bound <= down_bound) {
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = left_bound; i <= right_bound; i++) {
                    res.push_back(matrix[up_bound][i]);
                }
                up_bound++;
            }
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = up_bound; i <= down_bound; i++) {
                    res.push_back(matrix[i][right_bound]);
                }
                right_bound--;
            }
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = right_bound; i >= left_bound; i--) {
                    res.push_back(matrix[down_bound][i]);
                }
                down_bound--;
            }
            if(left_bound <= right_bound && up_bound <= down_bound) {
                for(int i = down_bound; i >= up_bound; i--) {
                    res.push_back(matrix[i][left_bound]);
                }
                left_bound++;
            }
        }
        return res;
    }
};