力扣hot100:739. 每日温度/54. 螺旋矩阵

文章目录

一、 739. 每日温度

LeetCode:739. 每日温度

经典单调栈问题,求下一个更大的数。

  • 使用单调递减栈,一个元素A出栈,当且仅当它第一次出现比它更大的数B,由于栈是单调递减的,因此该数B入栈时,会弹出这个栈中比它小的数A,A也同时找到了它的下一个更大的数。
  • 时间复杂度: O ( n ) O(n) O(n),每个元素最多入栈一次,出栈一次
  • 空间复杂度: O ( n ) O(n) O(n)
cpp 复制代码
class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        stack<int> sta;
        int n = temperatures.size();
        vector<int> result(n, 0);
        for(int i = 0; i < n; ++ i){
            while(!sta.empty() && temperatures[sta.top()] < temperatures[i]){//维护单调递减的单调栈
                result[sta.top()] = i - sta.top();
                sta.pop();
            }
            sta.push(i);
        }
        return result;
    }
};

二、54. 螺旋矩阵

LeetCode:54. 螺旋矩阵

1、模拟螺旋矩阵的路径

由于没有说需要不改变矩阵中的值,我们可以直接按螺旋顺序遍历螺旋矩阵,然后在原矩阵中直接标记被遍历的位置。

注意事项:

  • matrix[x][y],在图形上,这里的x是行号,y是列好,这和数学里面的有所不同,需要区分。
  • 在矩阵遍历过程中一定要注意的两个边界值:
    • 超过数组最大边界,即pos >= size
    • 小于数组最小边界,即pos < 0

时间复杂度: O ( m n ) O(mn) O(mn),mn是矩阵大小

空间复杂度: O ( 1 ) O(1) O(1),不包括返回的答案vector

以下是保存(x,y)的方式遍历的方法:

cpp 复制代码
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ans;
        int m = matrix.size();
        int n = matrix[0].size();
        int total_size = m * n;
        int x = 0, y = 0;
        while(ans.size() < total_size)
            //遍历四个方向
            for(int j = 0; j < 4; ++ j){
                int temp_x = x;//(x,y)维护下一次要遍历的起始点,(temp_x,temp_y)表示当前要遍历的点
                int temp_y = y;
                //单方向一直走
                while(temp_x < m && temp_y < n && temp_x >= 0 && temp_y >= 0 && matrix[temp_x][temp_y] != INT_MAX){
                    //维护x,y的下次起点值
                    x = temp_x + dx[(j + 1) % 4];
                    y = temp_y + dy[(j + 1) % 4];
                    //保存当前值
                    ans.emplace_back(matrix[temp_x][temp_y]);
                    //标记当前位置
                    //cout << ans.back() << endl;
                    matrix[temp_x][temp_y] = INT_MAX;
                    //更新下一个遍历的位置
                    temp_x = temp_x + dx[j];
                    temp_y = temp_y + dy[j];
                }
            }
        return ans;
    }
private:
    int dx[4] = {0, 1, 0, -1};
    int dy[4] = {1, 0, -1, 0};//右,下,左,上的顺序 
};

以下是直接遍历的方法:

  • 由于下一次遍历的位置,只跟当前方向有关,因此为了满足每一次方向都是正确的,都能够找到一个正确位置,我们只需要每一次更新下一次遍历位置之前,都判断方向是否需要更改就行!
  • 这个方法更简单,更容易思考,而且上面那个方法,每走一次要判断是否该方向能走,和下面这个方法每走一次判断是否需要更改方向是同样的操作,但下面却利用这一操作更改成正确的方向更简洁。
cpp 复制代码
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ans;
        int m = matrix.size();
        int n = matrix[0].size();
        int total_size = m * n;
        int x = 0, y = 0;
        int direction = 0;
        while(ans.size() < total_size){
            //保存遍历结点
            ans.emplace_back(matrix[x][y]);
            matrix[x][y] = INT_MAX;
            //判断原始的下一次方向
            int new_x = x + dx[direction];
            int new_y = y + dy[direction];
            //判断下一次是否需要更改方向
            if(new_x < 0 || new_x >=m || new_y < 0 || new_y >=n || matrix[new_x][new_y] == INT_MAX){
                direction = (direction + 1) % 4;
            }
            //更新到下一次遍历位置
            x = x + dx[direction];
            y = y + dy[direction];
        }
        return ans;
    }
private:
    int dx[4] = {0, 1, 0, -1};
    int dy[4] = {1, 0, -1, 0};//右,下,左,上的顺序 
};

如果需要原地进行,空间复杂度且需要是 O ( 1 ) O(1) O(1),则需要进行层序遍历。

2、按层模拟

矩阵,从外到内分层,则有每次都是转一圈。

如果我们记住四个顶点,则我们就有足够信息可以使得我们无差错的转一圈。并且转完这一圈,四个顶点更新为内层的四个顶点是非常简单的。

时间复杂度: O ( m n ) O(mn) O(mn),mn是矩阵大小

空间复杂度: O ( 1 ) O(1) O(1)

cpp 复制代码
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0) {
            return {};
        }

        int rows = matrix.size(), columns = matrix[0].size();
        vector<int> order;
        int left = 0, right = columns - 1, top = 0, bottom = rows - 1;
        while (left <= right && top <= bottom) {
            for (int column = left; column <= right; column++) {
                order.push_back(matrix[top][column]);
            }
            for (int row = top + 1; row <= bottom; row++) {
                order.push_back(matrix[row][right]);
            }
            if (left < right && top < bottom) {
                for (int column = right - 1; column > left; column--) {
                    order.push_back(matrix[bottom][column]);
                }
                for (int row = bottom; row > top; row--) {
                    order.push_back(matrix[row][left]);
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return order;
    }
};
相关推荐
小刘|13 分钟前
《Java 实现希尔排序:原理剖析与代码详解》
java·算法·排序算法
jjyangyou18 分钟前
物联网核心安全系列——物联网安全需求
物联网·算法·安全·嵌入式·产品经理·硬件·产品设计
van叶~34 分钟前
算法妙妙屋-------1.递归的深邃回响:二叉树的奇妙剪枝
c++·算法
简简单单做算法35 分钟前
基于Retinex算法的图像去雾matlab仿真
算法·matlab·图像去雾·retinex
云卓SKYDROID1 小时前
除草机器人算法以及技术详解!
算法·机器人·科普·高科技·云卓科技·算法技术
半盏茶香1 小时前
【C语言】分支和循环详解(下)猜数字游戏
c语言·开发语言·c++·算法·游戏
徐子童1 小时前
双指针算法习题解答
算法
想要打 Acm 的小周同学呀1 小时前
LRU缓存算法
java·算法·缓存
劲夫学编程2 小时前
leetcode:杨辉三角
算法·leetcode·职场和发展
毕竟秋山澪2 小时前
孤岛的总面积(Dfs C#
算法·深度优先