单调栈学习与应用

最新推荐文章于 2024-10-25 18:33:38 发布
最新推荐文章于 2024-10-25 18:33:38 发布
阅读量441 收藏
点赞数
分类专栏： LeetCode 数据结构与算法 文章标签： 学习 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GoddamnCode/article/details/127188271
版权

单调栈学习与应用

栈的应用，单调栈就是保持栈内元素有序，需要我们自己维持顺序，从栈顶到栈底是从小到大和从大到小两种情况。

  • 若要找第一个小于的，则应该从大到小
  • 若要找第一个大于的，应该从小到大

【LeetCode】84. 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

示例 1:

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

示例 2：

输入： heights = [2,4]
输出： 4

提示：

  • 1 <= heights.length <=105
  • 0 <= heights[i] <= 104

思路

对于每一个柱子，想要合并成更大的矩形，只有两侧的柱子的高度大于等于当前这个柱子才能够合并，对于暴力解法来说，只要找到每一个柱子左侧第一个小于它高度的柱子，右侧第一个小于它高度的柱子，就能求出每一个柱子的合并最大矩形，遍历每个柱子就可以得到最大值！

若使用单调栈：

  1. 当前柱子高度大于栈顶柱子的高度

    • 入栈

  2. 当前柱子高度等于栈顶柱子的高度

    ​ 1和2代表两种不同的思路：

    1. 弹出栈顶柱子，入栈当前柱子（代表对于相同高度的柱子不重复计算）
    2. 直接入栈（代表遍历每一个柱子的合并面积，取最大值）

  3. 当前柱子高度小于栈顶柱子的高度 矩形面积为 height * width

    1. 弹出栈顶柱子，以当前栈顶柱子高度进行合并 下标为left
    2. 不弹出新栈顶柱子，以新栈顶柱子为左侧第一个小于要合并的高度的柱子 下标为cur
    3. 以当前遍历的柱子为右侧第一个小于要合并的高度的柱子 下标为right
    4. width = right - left - 1
    5. 计算面积并选取面积最大值，如果当前遍历柱子高度仍小于新栈顶柱子高度，则继续重复1-5步骤
    6. 将当前遍历的柱子入栈

因为单调栈是有序的，当找到第一个小于栈顶的，则栈顶的下一个柱子一定是小于栈顶的（如果是相等的也看作是小于的），所以就可以用栈顶柱子，栈顶下一个柱子，当前遍历柱子计算出合并面积！

例子

heights = [2,1,5,6,2,3]
添加哨兵后heights = [0,2,1,5,6,2,3,0]
heights[0]=0，入栈s=[0]
heights[1]=2，入栈s=[0,1]
heights[2]=1 < 2，pop出栈顶元素1，s=[0]，可以确定heights[1]=2所能勾勒出的最大矩形面积，左边界为新栈顶元素0，右边界就是当前下标i=2，宽为2-0-1=1，高度为heights[1]=2，ans=max(0,2)=2。1>heights[0]=0，所以不继续pop，入栈s=[0,2]
heights[3]=5，入栈s=[0,2,3]
heights[4]=6，入栈s=[0,2,3,4] 
heights[5]=2 < heights[4]=6，pop出栈顶元素4，s=[0,2,3]，可以确定heights[4]=6所能勾勒出的最大矩形面积，左边界为新栈顶元素3，右边界就是当前下标i=5，宽为5-3-1=1，高度为heights[4]=6，ans=max(2,6)=6
             < heights[3]=5，pop出栈顶元素3，s=[0,2]，可以确定heights[3]=5所能勾勒出的最大矩形面积，左边界为新栈顶元素2，右边界就是当前下标i=5，宽为5-2-1=2，高度为heights[3]=5，ans=max(6,10)=10。2>heights[2]=1，所以不继续pop，入栈s=[0,2,5]
heights[6]=3，入栈s=[0,2,5,6]
heights[7]=0 < heights[6]=3，pop出栈顶元素6，s=[0,2,5]，可以确定heights[6]=3所能勾勒出的最大矩形面积，左边界为新栈顶元素5，右边界就是当前下标i=7，宽为7-5-1=1，高度为heights[6]=3，ans=max(10,3)=10
             < heights[5]=2，pop出栈顶元素5，s=[0,2]，可以确定heights[5]=2所能勾勒出的最大矩形面积，左边界为新栈顶元素2，右边界就是当前下标i=7，宽为7-2-1=4，高度为heights[5]=2，ans=max(10,8)=10
             < heights[2]=1，pop出栈顶元素2，s=[0]，可以确定heights[2]=1所能勾勒出的最大矩形面积，左边界为新栈顶元素0，右边界就是当前下标i=7，宽为7-0-1=6，高度为heights[2]=1，ans=max(10,6)=10。不继续pop，入栈s=[0,7]
遍历结束，ans=10

tips

若所有柱子全部都是单调递增的，则找不到左右侧第一个小于的，则无法计算合并面积，怎么办？

例如：5 5 6

在开头和末尾加一个高度为0的哨兵即可，这样保证了栈一定不为空，同时，能保证一定能计算所有柱子的合并面积！

前后加0后：0 5 5 6 0，保证每个柱子都找得到比它小的

代码

弹出栈顶柱子，入栈当前柱子（代表对于相同高度的柱子不重复计算）

class Solution {
    public int largestRectangleArea(int[] heights) {
        int[] newHeights = new int[heights.length + 2];
        for(int i = 0; i < heights.length; i++) {
            newHeights[i + 1] = heights[i];
        }
        heights = newHeights;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        int res = 0;
        for(int i = 1; i < heights.length; i++) {
            if(heights[i] > heights[stack.peek()]) {
                stack.push(i);
            }else if(heights[i] == heights[stack.peek()]){
                stack.pop();
                stack.push(i);
            }else {
                while(heights[i] < heights[stack.peek()]) {
                    int cur = stack.pop();
                    int left = stack.peek();
                    int right = i;
                    int height = heights[cur];
                    int width = right -left - 1;
                    res = Math.max(res, height * width);
                }
                stack.push(i);
            }
        }
        return res;
    }
}

直接入栈（代表遍历每一个柱子的合并面积，取最大值）

class Solution {
    public int largestRectangleArea(int[] heights) {
        int[] newHeights = new int[heights.length + 2];
        for(int i = 0; i < heights.length; i++) {
            newHeights[i + 1] = heights[i];
        }
        heights = newHeights;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        int res = 0;
        for(int i = 1; i < heights.length; i++) {
            if(heights[i] > heights[stack.peek()]) {
                stack.push(i);
            }else if(heights[i] == heights[stack.peek()]){
                stack.push(i);
            }else {
                while(heights[i] < heights[stack.peek()]) {
                    int cur = stack.pop();
                    int left = stack.peek();
                    int right = i;
                    int height = heights[cur];
                    int width = right -left - 1;
                    res = Math.max(res, height * width);
                }
                stack.push(i);
            }
        }
        return res;
    }
}

化简：

class Solution {
    public int largestRectangleArea(int[] heights) {
        int[] newHeights = new int[heights.length + 2];
        for(int i = 0; i < heights.length; i++) {
            newHeights[i + 1] = heights[i];
        }
        heights = newHeights;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        int res = 0;
        for(int i = 1; i < heights.length; i++) {
            while(heights[i] < heights[stack.peek()]) {
                int cur = stack.pop();
                int left = stack.peek();
                int right = i;
                int height = heights[cur];
                int width = right -left - 1;
                res = Math.max(res, height * width);
            }
            stack.push(i);
        }
        return res;
    }
}

【LeetCode】42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

提示：

  • n == height.length
  • 1 <= n <= 2 * 104
  • 0 <= height[i] <= 105

思路

使用单调栈，就是出现有坑的时候就能存储水，怎样判断出现坑？当出现第一个大于栈顶柱子高度的柱子时，出现坑。那么单调栈的顺序从栈顶到栈底就应该是从小到大。单调栈的方法是以行计算雨水量。

在这里插入图片描述

  1. 当前柱子高度小于栈顶柱子的高度

    • 入栈

  2. 当前柱子高度等于栈顶柱子的高度

    ​ 1和2代表两种不同的思路：

    1. 直接入栈（代表对于相同高度的柱子分别成坑计算，比如有两个相同高度的柱子相邻和下图的情况）

      在这里插入图片描述

      1.当①和②中间的高度为0的柱子被弹出后②作为栈顶，①为左侧大于②的柱子（也就是栈顶下一个柱子），②右侧的柱子为右侧大于②的柱子（也就是当前遍历的柱子），形成了坑，其接的雨水为1个宽度

      2.当②弹出后，①作为栈顶，①左侧柱子作为左侧大于①的柱子（也就是栈顶下一个柱子）,②右侧的柱子为右侧大于①的柱子（也就是当前遍历的柱子），形成了坑，其接的雨水是两个宽度

    2. 弹出栈顶柱子，入栈当前柱子（直接计算有相同高度柱子的承接雨水最大值，相当于一步到位）

  3. 当前柱子高度大于栈顶柱子的高度 雨水面积为 h * width

    1. 弹出栈顶柱子，以当前栈顶柱子高度进行合并 下标为left
    2. 不弹出新栈顶柱子，以新栈顶柱子为左侧第一个小于要合并的高度的柱子 下标为cur
    3. 以当前遍历的柱子为右侧第一个小于要合并的高度的柱子 下标为right
    4. width = right - left - 1
    5. h = Math.min(height[stack.peek()], height[right]) - height[cur];
    6. 计算雨水并累加，如果当前遍历柱子高度仍大于新栈顶柱子高度，则继续重复1-5步骤
    7. 将当前遍历的柱子入栈

代码

直接入栈

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        int sum = 0;
        for(int i = 1; i < len; i++) {
            if(height[i] < height[stack.peek()]) {
                stack.push(i);
            }else if(height[i] == height[stack.peek()]) {
                stack.push(i);
            }else {
                while(!stack.isEmpty() && height[i] > height[stack.peek()]) {
                    int cur = stack.pop();
                    if(!stack.isEmpty()) {
                        int right = i;
                        int left = stack.peek();
                        int h = Math.min(height[left], height[right]) - height[cur];
                        int width = right - left - 1;
                        sum += h * width;
                    }
                }
                stack.push(i);
            }
        }
        return sum;
    }
}

简化：

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        int sum = 0;
        for(int i = 1; i < len; i++) {
            while(!stack.isEmpty() && height[i] > height[stack.peek()]) {
                int cur = stack.pop();
                if(!stack.isEmpty()) {
                    int right = i;
                    int left = stack.peek();
                    int h = Math.min(height[left], height[right]) - height[cur];
                    int width = right - left - 1;
                    sum += h * width;
                }
            }
            stack.push(i);
        }
        return sum;
    }
}

弹出栈顶柱子，入栈当前柱子

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        int sum = 0;
        for(int i = 1; i < len; i++) {
            if(height[i] < height[stack.peek()]) {
                stack.push(i);
            }else if(height[i] == height[stack.peek()]) {
                stack.pop();
                stack.push(i);
            }else {
                while(!stack.isEmpty() && height[i] > height[stack.peek()]) {
                    int cur = stack.pop();
                    if(!stack.isEmpty()) {
                        int right = i;
                        int left = stack.peek();
                        int h = Math.min(height[left], height[right]) - height[cur];
                        int width = right - left - 1;
                        sum += h * width;
                    }
                }
                stack.push(i);
            }
        }
        return sum;
    }
}
Sancean
关注
专栏目录
单调栈的应用
weixin_46273997的博客
11-21 1241
滑动窗口最大值 此题是滑动窗口中的数字个数是固定的,如果窗口中的数字个数在动态变化,比如R右边界增加,L不变… 那有没有一种数据结构结构,可以让我们以O(1)的复杂度得到此时滑动窗口中的最大值或者最小值呢??? 有,那就是单调栈!!!单调栈可以使用双端队列来实现!! 该单调栈中保证从头部到尾部保证数据的严格递增或递减; 当R往右移动一个位置时,如果此时R位置的数,满足单调中的严格递增或递减顺序,则放入到队列尾部 如果不满足,则依次取出队列中的值,直到放入的数满足严格递增或递减的顺序 当L往右动时,如果L.
单调栈以及单调栈的应用
精致的灰的博客
06-21 1275
单调栈的实现以及应用场景
数据结构 | 栈之单调栈
lovetaozibaby的博客
03-04 839
文章目录简介定义算法1. 单调递增栈步骤作用python程序2. 单调递减栈作用python程序 简介 单调栈，可以用来优化时间复杂度，是个利器。 定义 单调栈，顾名思义，是一个单调的栈。栈内元素一般都是无序的，如何保持栈内元素是有序的呢？接下来，我们进行分析。 单调栈分为单调递增栈和单调递减栈，通过使用单调栈我们可以访问到下一个比他大（小）的元素。 什么时候使用单调栈？ 通常是一维数组，要寻找任一元素右边（左边）第一个比自己大（小）的元素，且要求 O(n) 的时间复杂度 算法 单调递增栈：从 栈底 到 栈
单调栈学习
star_platinum2的博客
11-26 187
单调栈
算法总结——单调栈
阿标de杂货铺
01-16 3583
单调栈不是一种新的数据结构，它在结构上仍然是一个普通栈，只是在使用方法上有所区别。单调栈内的元素是单调递增或递减的，因此有单调递增栈和单调递减栈。单调递增栈： 栈中元素从栈底到栈顶是递增的。单调递减栈： 栈中元素从栈底到栈顶是递减的。我们在使用单调栈的时候，要时刻保证栈的单调性，例如，单调递增栈：栈中元素从栈底到栈顶是递增的。当一个元素入栈时，与栈顶比较，若比栈顶大，则入栈；若比栈项小,则弹出栈顶，直到这个数能入栈为止。注意：每个元素都一定入栈。
数据结构：单调栈和单调队列
m0_63997099的博客
03-29 2050
单调队列和单调栈，有LeetCode典型例题哦~
单调栈的学习
weixin_52055811的博客
05-06 626
栈（stack）是很简单的一种数据结构，先进后出的逻辑顺序，符合某些问题的特点，比如说函数调用栈。单调栈实际上就是栈，只是利用了一些巧妙的逻辑使得每次新元素入栈后，栈内的元素都保持有序（单调递增或者单调递减）听起来有点像堆（heap）但是不是堆，单调栈用途不太广泛，只处理一类典型的问题下一个更大元素上一个更小元素在这里说的单调栈的模板都是计算每个元素的下一个更大元素，但如果题目让你计算上一个更大的元素或者计算上一个更大或相等的元素又要如何修改对应的模板呢？
【C++学习第八天】（4）单调栈
qq_52726763的博客
04-18 237
单调栈（Monotonic Stack）是一种数据结构，用于解决一类与单调性相关的问题。它的主要特点是栈中的元素保持单调（递增或递减）的顺序排列。单调栈通常基于栈这种数据结构实现，但在入栈和出栈操作时会有一些特定的规则。对于单调递增栈，栈内的元素从栈底到栈顶按照递增顺序排列，而单调递减栈则相反，栈内的元素从栈底到栈顶按照递减顺序排列。
单调栈初步学习
HangHug_L的博客
01-27 179
1.定义 从栈底元素到栈顶元素呈单调递增或单调递减，栈内序列满足单调性的栈； 2.原理 (1)当新元素在单调性上优于栈顶时（单增栈新元素比栈顶大（升序）单减栈新元素比栈顶小 (降序) ），压栈，栈深+1； (2)当新元素在单调性与栈顶相同（新元素于栈顶相同）或劣于栈顶时（单增栈新元素比栈顶小，单减栈新元素比栈顶大），弹栈，栈深-1； 模拟实现一个在原输入数据的顺序基础上递减的单调栈： 现在有一组数10，3，7，4，12。从左到右依次入栈，则如果栈为空或入栈元素值小于栈顶元素值，则入栈；否则，如果入栈则会
代码随想录单调栈算法详解及其应用
09-17
内容概要：本文档深入解析了《代码随想录》中提到的单调栈算法，涵盖多种应用场景和题目解析。包括了每日温度预测、下一更大元素等问题的解决方法以及接雨水这类经典的算法挑战题。文中提供了详细的问题分析过程，...
神奇的单调栈
10-27
如果你不知道单调栈的应用,那么你就out了!赶快学习一下吧,保证你看的懂!
线性结构- 单调栈与单调队列.rar
09-16
单调栈的应用实例： 1. 求解一个数组中的最长上升子序列（LIS）：通过单调栈可以快速地找到每个位置上的最小上界，从而有效地计算出LIS的长度。 2. 找到二维数组中的最近峰值：在二维数组中，单调栈可以用来追踪当前...
学会 学习
阿然的专栏
10-23 244
当你开始做某件新事物时，最重要的是知道应该学什么。 学会学习是一种极高杠杆的能力。
了解python tutor-一个学习（教学)辅助工具
weixin_40539956的博客
10-24 800
Python Tutor是一个强大的编程学习和调试工具，它通过可视化的方式帮助用户理解代码执行的每一个细节。无论是对于初学者学习编程概念，还是经验丰富的开发者进行代码调试，Python Tutor都是一个极其有价值的工具。它的多语言支持和代码分享功能使其在教育和协作开发中发挥重要作用。通过使用Python Tutor，用户可以更深入地理解程序的内部工作原理，提高编程技能和调试效率。
小程序云开发CMS新版数据模型讲解，可视化网页管理后台，内容管理对数据库进行增删改查操作，新闻小程序实战学习
编程小石头
10-24 1062
一直跟着石头哥学习小程序开发的同学比较清楚cms是什么，cms就是可以进行可视化的管理云开发数据库的网页后台。有了cms我们可以很方便的管理云开发数据库。但是云开发官方一直改版，所以现在cms功能被整合到了云开发的数据模型里，也就是现在想继续使用cms就要先去学习数据模型，数据模型其实对应着数据库和cms，可以理解为新版的数据模型是云开发数据库和cms的综合体。所以接下来我们就来学习数据模型，通过数据模型来使用cms对数据库进行可视化的增删改查操作。
【学习笔记】RFID
Eddie_hyh的博客
10-24 964
RFID学习
sheng的学习笔记-AI基础-正确率/召回率/F1指标/ROC曲线
coldstarry的专栏
10-24 639
例如，假设你训练一个分类器来检测儿童可以放心观看的视频，那么你可能更青睐那种拦截了很多好视频（低召回率）​，但是保留下来的视频都是安全（高精度）的分类器，而不是召回率虽高，但是在产品中可能会出现一些非常糟糕的视频的分类器（这种情况下，你甚至可能会添加一个人工流水线来检查分类器选出来的视频）​。但显然这样的机器学习系统是失败的，因为对于极度偏斜(Skewed Data)的数据，只使用分类准确度是远远不够的。这不一定能一直符合你的期望：在某些情况下，你更关心的是精度，而另一些情况下，你可能真正关心的是召回率。
Python 精品学习资料收藏下载，Python 字符串处理备忘单
最新发布
信息科技云课堂
10-25 371
（请移步图中作者处，获取高清大图下载链接）Python 中的字符串（String）是一种用于表示文本的数据类型。字符串是不可变的，这意味着一旦创建，你不能改变字符串中的字符，但你可以创建新的字符串。字符串在 Python 中使用单引号（'）、双引号（"）或三引号（''' 或 """）来表示。
Unity3D学习FPS游戏（2）简单场景、玩家移动控制
qq_40306845的博客
10-23 1081
简单地板场景布置和玩家移动控制实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值