单调栈类题目专题训练 -- LeetCode上5道与单调栈相关的题

最新推荐文章于 2023-05-19 19:50:09 发布

大家好我是Boger

最新推荐文章于 2023-05-19 19:50:09 发布

阅读量7.9k

点赞数

分类专栏： LeetCode刷题笔记 # 各种类型的专题训练文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/QQ1149646297/article/details/123179724

版权

LeetCode刷题笔记同时被 2 个专栏收录

59 篇文章 2 订阅

订阅专栏

各种类型的专题训练

11 篇文章 1 订阅

订阅专栏

这个专题中的题目是我跟随代码随想录的刷题计划，在LeetCode上做的与单调栈相关的题目，用于加深对单调栈的理解！

下面的内容将会有每一道题目的题意、在代码随想录中对应的参考文章、我的思路以及我所写的Java代码，希望对你有帮助！

1 - LeetCode 739 每日温度

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/daily-temperatures

题意：

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指在第 i 天之后，才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]

示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

提示：

1 <= temperatures.length <= 10⁵
30 <= temperatures[i] <= 100

参考文章

思路：

什么是单调栈？单调栈就是栈里的元素保持升序或者降序。

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。

使用一个栈，栈内元素都是单调的。当新插入的元素符合单调条件时就插入，不满的话依次将栈内元素弹出直至符合单调条件！

注意在这道题中，栈内存储的是数组元素的下标，而不是数组元素值！

本题Java代码：

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        Deque<Integer> queue = new LinkedList<>();
        int[] ans = new int[temperatures.length];
        for (int i = 0; i < temperatures.length; i++) {
            while (!queue.isEmpty() && temperatures[queue.peek()] < temperatures[i]) {
                ans[queue.peek()] = i - queue.poll();
            }
            queue.push(i);
        }
        return ans;
    }
}

2 - LeetCode 496 下一个更大元素 I

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-greater-element-i

题意：

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置右侧的第一个比 x 大的元素。

给你两个没有重复元素的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的下一个更大元素。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的下一个更大元素。

示例 1：

输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。
2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。

示例 2：

输入：nums1 = [2,4], nums2 = [1,2,3,4].
输出：[3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。
4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1 。

提示：

1 <= nums1.length <= nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 10⁴
nums1和nums2中所有整数互不相同
nums1 中的所有整数同样出现在 nums2 中

参考文章

思路：

这道题跟上道题是大同小异的，虽说是两个数组，但我们使用Map进行映射，其实值在第二个数组上面做文章即可，处理与上一道相同，都是寻找元素后边第一个比他大的值。

只不过区别在于，这道题数组中存储的是数组的值，而不是下标。

本题Java代码：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        HashMap<Integer, Integer> map = new HashMap<>();
        Deque<Integer> deque = new LinkedList<>();
        for (int i = 0; i < nums2.length; i++) {
            while (!deque.isEmpty() && deque.peek() < nums2[i]) {
                map.put(deque.poll(), nums2[i]);
            }
            deque.push(nums2[i]);
        }
        int[] ans = new int[nums1.length];
        for (int i = 0; i < nums1.length; i++) {
            ans[i] = map.getOrDefault(nums1[i], -1);
        }
        return ans;
    }
}

3 - LeetCode 503 下一个更大元素 II

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-greater-element-ii

题意：

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的下一个更大元素。

数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

提示:

1 <= nums.length <= 10⁴
-10⁹ <= nums[i] <= 10⁹

参考文章

思路：

说是循环数组，其实我们直接对数组进行两次的拼接就行了，这个应该可以很容易想到。

说是数组拼接，其实也不用真的进行拼接，使用取余操作即可了，这个我就没想到了。

其他操作与上面两题大同小异。

本题Java代码：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        Deque<Integer> deque = new LinkedList<>();
        int[] ans = new int[nums.length];
        for (int i = 0; i < nums.length * 2; i++) {
            while (!deque.isEmpty() && nums[deque.peek()] < nums[i % nums.length]) {
                ans[deque.poll()] = nums[i % nums.length];
            }
            deque.push(i % nums.length);
        }
        return ans;
    }
}

4 - LeetCode 42 接雨水

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/trapping-rain-water
题意：

给定 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 * 10⁴
0 <= height[i] <= 10⁵

参考文章

思路：

这道题是一道经典的面试题。我们用三种方法来做，分别是双指针法、动态规划法、单调栈法。

双指针法：

双指针法和动态规划法都是使用列来计算的：
在这里插入图片描述

从高度数组中每一个元素开始，在这个元素向左右遍历，分别找出在这个元素左右边最高的高度，然后在这两个高度中选取较小的一个，用这个较小的高度减去当前元素的高度，得到的就是当前元素上边能得到的雨水数量。

复杂度O(N²)

双指针法 Java代码：

class Solution {
    public int trap(int[] height) {
        int ans = 0;
        for (int i = 0; i < height.length; i++) {
            if (i == 0 || i == height.length - 1) continue;//头尾不参与接水
            int lhei = height[i], rhei = height[i];
            for (int j = i - 1; j >= 0; j--) lhei = Math.max(lhei, height[j]);
            for (int j = i + 1; j < height.length; j++) rhei = Math.max(rhei, height[j]);
            ans += Math.min(lhei, rhei) - height[i];
        }
        return ans;
    }
}

动态规划法：

上面我们可以发现，每次在一个元素都要向左右遍历到头尾，效率是不高的。我们可以改为直接在开头就进行一次遍历，用两个数组分别存储在每个位置上他左右边分别最高的高度。

复杂度O(N)

动态规划法 Java代码：

class Solution {
    public int trap(int[] height) {
        int[] lhei = new int[height.length];
        int[] rhei = new int[height.length];
        lhei[0] = height[0];
        rhei[height.length - 1] = height[height.length - 1];
        for (int i = 1; i < height.length; i++) lhei[i] = Math.max(lhei[i - 1], height[i]);
        for (int i = height.length - 2; i >= 0; i--) rhei[i] = Math.max(rhei[i + 1], height[i]);
        int ans = 0;
        for (int i = 1; i < height.length - 1; i++) {
            int tmp = Math.min(lhei[i], rhei[i]) - height[i];
            if (tmp > 0) ans += tmp;
        }
        return ans;
    }
}

单调栈法：

单调栈法是使用行计算的：
在这里插入图片描述
其实按这个图就能大概理解思路吧。

建立一个单调栈，栈内的元素从栈顶到栈底高度是依次递减的，同时栈内元素存储的是下标，因为下标是要用来计算的。

当当前要插入的元素高度高于栈顶元素时，我们取出栈顶元素的下标，通过下标获取它的高度，然后将它弹出栈，然后得到下一个栈顶元素的高度。
接着在当前高度以及下一个栈顶元素的高度中取高度较小的一个，减去先去取出的栈顶元素的高度，得到的就是当前行能收取到的雨水高度，该雨水高度乘以宽度即能得到当前雨水量。那么宽度怎么取呢？用当前元素的下标减去当前栈顶元素的下标再减1，就是宽度。

这样说还有点难理解，建议看看参考文章中关于单调栈法部分的内容，结合图片进行理解。

单调栈法 Java代码：

class Solution {
    public int trap(int[] height) {
        Deque<Integer> deque = new LinkedList<>();
        int ans = 0;
        for (int i = 0; i < height.length; i++) {
            while (!deque.isEmpty() && height[i] > height[deque.peek()]) {
                int mid = deque.poll();
                if (!deque.isEmpty()) {
                    int h = Math.min(height[i], height[deque.peek()]) - height[mid];
                    int w = i - deque.peek() - 1;
                    ans += h * w;
                }
            }
            deque.push(i);
        }
        return ans;
    }
}

5 - LeetCode 84 柱状图中最大的矩形

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/largest-rectangle-in-histogram

题意：

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

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

示例 1:
在这里插入图片描述
输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

示例 2：
在这里插入图片描述

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

提示：

1 <= heights.length <=10⁵
0 <= heights[i] <= 10⁴

参考文章

思路：

好怀念的题目，我还记得以前在集训队时候是在家乡的图书馆里边做的这道题，当时是在学习栈与队列。

这道题跟上面那一道题是非常类似的，而且也都是热门的面试题。

差别就在于，这道题的单调栈从栈顶到栈底是从大到小的。

而且还有一个非常关键的点啊！**得在原数组的头和尾各加上一个值为0的元素。**上一道题不用加是因为头尾不接水，这道题头尾是要参与计算的！

栈内存储的一样是下标。当当前元素的高度低于当前栈顶元素的高度时，就得开始进行计算了。先得到当前栈顶元素的高度，然后弹出，得到下一个栈顶元素的下标，然后再与当前下标计算得出宽度（一样要减1），然后就用高度与宽度相乘得到答案。

本题Java代码：

class Solution {
    public int largestRectangleArea(int[] heights) {
        int[] heights1 = new int[heights.length + 2];
        for (int i = 1; i <= heights.length; i++) heights1[i] = heights[i - 1];
        Deque<Integer> deque = new LinkedList<>();
        deque.push(0);
        int ans = heights[0];
        for (int i = 1; i < heights1.length; i++) {
            while (!deque.isEmpty() && heights1[i] < heights1[deque.peek()]) {
                int h = heights1[deque.poll()];
                int w = i - deque.peek() - 1;
                ans = Math.max(ans, h * w);
            }
            deque.push(i);
        }
        return ans;
    }
}

大家好我是Boger

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
单调栈类题目专题训练 -- LeetCode上5道与单调栈相关的题

这个专题中的题目是我跟随代码随想录的刷题计划，在LeetCode上做的与单调栈相关的题目，用于加深对单调栈的理解！下面的内容将会有每一道题目的题意、在代码随想录中对应的参考文章、我的思路以及我所写的Java代码，希望对你有帮助！目录1 - LeetCode 739 每日温度2 - LeetCode 496 下一个更大元素 I3 - LeetCode 503 下一个更大元素 II4 - LeetCode 42 接雨水5 - LeetCode 84 柱状图中最大的矩形  1 -
复制链接

扫一扫

专栏目录