LeetCode题解单调栈篇（TS版）

单调栈说明

单调栈是一种专门用来解决一类问题的数据结构，主要是用于求解数组中元素左侧或右侧最近的比它大或者小的元素的问题。

单调栈可以是单调递增的，也可以是单调递减的。单调递增栈即栈底元素最小，栈顶元素最大；单调递减栈即栈底元素最大，栈顶元素最小。

单调栈的工作原理基本上是这样的：当有一个新元素要进栈时，如果这个新元素比栈顶元素大（对于单调递增栈）或者小（对于单调递减栈），就将栈顶元素弹出，直到栈顶元素比新元素小（或大）或者栈已经为空，然后再将新元素入栈。这样，栈内的元素始终是有序的。

单调栈在解决一些数组或列表相关的问题上非常有效，例如：

1. 下一个更大元素问题：给定一个数组，要求找出数组中每个元素右边第一个比它大的元素。
2. 柱状图中最大的矩形：给定n个非负整数表示柱状图的高度，每个柱子的宽度都是1，找出图中能够画出的最大矩形面积。
3. 接雨水问题：给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

739. 每日温度

给定一个整数数组 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 <= 105
• 30 <= temperatures[i] <= 100

暴力破解

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$

function dailyTemperatures(temperatures: number[]): number[] {
    const res: number[] = [];
    for (let i = 0; i < temperatures.length - 1; i++) {
        res[i] = 0;
        for (let j = i + 1; j < temperatures.length; j++) {
            if (temperatures[i] < temperatures[j]) {
                res[i] = j - i;
                break;
            }
        }
    }
    res[temperatures.length - 1] = 0;
    return res;
};

单调栈

使用单调递减栈。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

function dailyTemperatures(temperatures: number[]): number[] {
    const st: number[] = [];
    const res: number[] = new Array(temperatures.length).fill(0);
    for (let i = 0; i < temperatures.length; i++) {
        while (st.length && temperatures[st[st.length - 1]] < temperatures[i]) {
            const cur = st.pop();
            res[cur] = i - cur;
        }
        st.push(i);
    }
    return res;
};

496.下一个更大元素Ⅰ

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] <= 104
• nums1和nums2中所有整数 互不相同
• nums1 中的所有整数同样出现在 nums2 中

**进阶：**你可以设计一个时间复杂度为 O(nums1.length + nums2.length) 的解决方案吗？

暴力破解

• 时间复杂度：$O(n\ast m)$
• 空间复杂度：$O(1)$

function nextGreaterElement(nums1: number[], nums2: number[]): number[] {
    const res: number[] = new Array(nums1.length).fill(-1);
    for (let i = 0; i < nums1.length; i++) {
        const index = nums2.indexOf(nums1[i]);
        for (let j = index + 1; j < nums2.length; j++) {
            if (nums2[index] < nums2[j]) {
                res[i] = nums2[j];
                break;
            }
        }
    }
    return res;
};

单调栈

解题思路：将 nums2 中的数字，使用单调递减栈，将对应的下一个更大的数字已经找出来，然后放到哈希表中，遍历 nums1，初始化长度为 num1 值为 -1，如果值存在哈希表，则取出覆盖。

• 时间复杂度：$O(n+m)$
• 空间复杂度：$O(m)$

function nextGreaterElement(nums1: number[], nums2: number[]): number[] {
    const st: number[] = [];
    const res: number[] = new Array(nums1.length).fill(-1);
    const map: Map<number, number> = new Map();
    for (let j = 0; j < nums2.length; j++) {
        while (st.length && nums2[st[st.length - 1]] < nums2[j]) {
            const index = st.pop()
            map.set(nums2[index], nums2[j]);
        }
        st.push(j);
    }
    for (let i = 0; i < nums1.length; i++) {
        if (map.has(nums1[i])) {
            res[i] = map.get(nums1[i]);
        }
    }
    return res;
};

503.下一个更大元素Ⅱ

给定一个循环数组 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 <= 104
• -109 <= nums[i] <= 109

单调栈

解题思路：

实现循环数组有两种方式：

• 把数组复制2份，虽然不算严格的循环数组，但对于本题足够。
• 取模运算。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

function nextGreaterElements(nums: number[]): number[] {
    const st: number[] = [];
    const arr = nums.concat(nums)
    const res: number[] = new Array(arr.length).fill(-1);
    for (let i = 0; i < arr.length; i++) {
        while (st.length && arr[st[st.length - 1]] < arr[i]) {
            const index = st.pop();
            res[index] = arr[i];
        }
        st.push(i);
    }
    return res.slice(0, nums.length);
};

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\ast 10^4$
• $0<=height[i]<=10^5$

动态规划

解题思路：

1. 定义DP数组

我们可以定义两个DP数组 leftMax 和 rightMax。leftMax[i] 表示第i个位置左边的最大高度，rightMax[i] 表示第i个位置右边的最大高度。

2. 状态转移公式

对于 leftMax 和 rightMax 数组，可以通过以下方式进行更新：

• leftMax[i] = max(leftMax[i - 1], height[i - 1])，表示第i个位置左边的最大高度是第i-1个位置左边的最大高度和第i-1个位置的高度中较大的那个。
• rightMax[i] = max(rightMax[i + 1], height[i + 1])，表示第i个位置右边的最大高度是第i+1个位置右边的最大高度和第i+1个位置的高度中较大的那个。

3. 初始化

我们需要初始化 leftMax 和 rightMax 数组：

• leftMax[0] 由于没有左边元素，所以可以设为0。
• rightMax[n-1] 由于没有右边元素，所以可以设为 height[height - 1]。
• n 是给定数组的长度。

4. 迭代

我们可以分别从左到右和从右到左进行两次迭代：

• 第一次迭代从左到右计算 leftMax 数组。
• 第二次迭代从右到左计算 rightMax 数组。

然后，我们可以迭代遍历每个位置，并计算该位置上方可以积累的水量。每个位置的积水量为 min(leftMax[i], rightMax[i]) - height[i] 的和。

假设 height = [4,2,0,3,2,5]：

i	leftMax[i]	rightMax[i]	height[i]	water[i]
0	0	5	4	0
1	4	5	2	2
2	4	5	0	4
3	4	5	3	1
4	4	5	2	2
5	4	0	5	0

总积水量 = 0 + 2 + 4 + 1 + 2 + 0 = 9。

• 时间复杂度：因为我们迭代遍历了三次数组，所以时间复杂度为$O(n)$。
• 空间复杂度：我们使用了两个额外的DP数组，所以空间复杂度为$O(n)$。

function trap(height: number[]): number {
    const leftMax: number[] = [];
    leftMax[0] = height[0];
    for (let i = 1; i < height.length; i++) {
        leftMax[i] = Math.max(leftMax[i - 1], height[i]);
    }
    const rightMax: number[] = [];
    rightMax[height.length - 1] = height[height.length - 1];
    for (let j = height.length - 2; j >= 0; j--) {
        rightMax[j] = Math.max(rightMax[j + 1], height[j]);
    }
    let ans = 0;
    for (let i = 0; i < height.length; i++) {
        ans += Math.min(leftMax[i], rightMax[i]) - height[i];
    }
    return ans;
};

双指针

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

function trap(height: number[]): number {
    let left = 0, right = height.length - 1;
    let leftMax = height[left], rightMax = height[right];
    let ans = 0;
    while (left < right) {
        leftMax = Math.max(leftMax, height[left]);
        rightMax = Math.max(rightMax, height[right]);
        if (height[left] < height[right]) {
            ans += leftMax - height[left];
            left++;
        } else {
            ans += rightMax - height[right];
            right--;
        }
    }
    return ans;
};

单调栈

解题思路：

1. 初始化栈：我们可以使用一个单调递减栈来存储墙壁的下标。
2. 遍历墙壁：迭代遍历墙壁数组 height。
   • 墙壁高度增加：如果当前墙壁的高度大于栈顶下标对应的墙壁高度，说明找到了一个凹槽，可以接到雨水。
     • 弹出栈顶元素，作为凹槽的底部墙壁。
     • 计算当前墙壁和栈顶下一个元素之间的宽度。
     • 计算栈顶下一个元素和当前墙壁之间的高度差，作为凹槽的深度。
     • 宽度和深度的乘积就是凹槽中的雨水量。
   • 墙壁高度减少或不变：将当前墙壁的下标推入栈。
3. 计算总积水量：将所有凹槽中的雨水量相加，得到总积水量。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

function trap(height: number[]): number {
    const st: number[] = [];
    let ans = 0;
    for (let i = 0; i < height.length; i++) {
        while (st.length && height[st[st.length - 1]] < height[i]) {
            const cur = st.pop();
            if (!st.length) break;
            const r = i;
            const l = st[st.length - 1];
            const h = Math.min(height[r], height[l]) - height[cur];
            ans += (r - l - 1) * h;
        }
        st.push(i);
    }
    return ans;
};

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

单调栈

解题思路：

使用单调递增栈，前后补0是为了更方便处理边界情况。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

function largestRectangleArea(heights: number[]): number {
    const st: number[] = [];
    heights = [0, ...heights, 0];
    let ans = 0;
    for (let i = 0; i < heights.length; i++) {
        while (st.length && heights[st[st.length - 1]] > heights[i]) {
            const cur = st.pop();
            ans = Math.max(ans, heights[cur] * (i - st[st.length - 1] - 1))
        }
        st.push(i);
    }
    return ans;
};