【四十八】【算法分析与设计】单调栈，单调栈模板，单调栈求个元素值 最近小于（等于）或者大于（等于）下标，元素值平方 最近小于（等于）下标，元素值左边最近大于等于右边最近大于的下标

原创 已于 2024-04-14 16:44:58 修改 · 489 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构 #c++ #深度优先

于 2024-04-14 14:05:52 首次发布
本文介绍了如何利用单调栈数据结构解决求解数组中每个元素左右两边最近小于等于的元素下标的算法，涉及两个方法：getNearLessEqual和getNearLess。关键在于维护栈的单调性，确保栈顶元素满足特定条件。

求各个元素左边和右边的最近的小于（等于）的下标

最近的小于的计算过程:

实现的过程需要用到一个stack<==>st

黑盒:在st的元素都可以正确计算出最近小于的元素下标那么我们依次将arr中的元素入栈计即可

1.栈里面存储的是vector，vector存储的是元素的下标，同一个vector存储的这些下标对应的元素值是相同的

⒉栈从栈底到栈顶，vector对应的元素值是严格递增的，因为相同的值下标放到同一个vector里面了

3.当i下标想要入栈，必须保证i下标对应元素值大于等于栈顶vector对应的元素值或者栈空4.如果i下标对应元素值大于等于栈顶vector对应的元素值，直接入栈st.push({i))

5.如果i下标对应元素值小于栈顶vector对应的元素值，此时我们可以直到栈顶vector所有元素的左边最近小于元素下标和右边最近小于元素下标

6.左边最近小于元素下标是在栈顶下面压着的vector的最后一个元素7.右边最近小于元素下标是i

8.依次st.pop维护pop出来的vector里面所有元素最近最小下标，直到i下标对应元素值大于等于栈顶vector对应元素值，或者栈空



#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
        vector<pair<int, int>> getNearLessEqual(vector<int>& arr) {
                vector<pair<int, int>> ret(arr.size());

                stack<int> st;
                for (int i = 0; i < arr.size(); i++) {
                        while (!(st.empty() || arr[i] > arr[st.top()])) {
                                int top = st.top(); st.pop();
                                int leftlessindex = st.empty() ? -1 : st.top();
                                ret[top].first = leftlessindex;
                                ret[top].second = i;
                        }
                        st.push(i);
                }

                while (!st.empty()) {
                        int top = st.top(); st.pop();
                        int leftlessindex = st.empty() ? -1 : st.top();
                        ret[top].first = leftlessindex;
                        ret[top].second = -1;
                }



                return ret;
        }

        vector<pair<int, int>> getNearLess(vector<int>& arr) {
                vector<pair<int, int>> ret(arr.size());

                stack<vector<int>> st;
                for (int i = 0; i < arr.size(); i++) {
                        while (!(st.empty() || arr[i] >= arr[st.top()[0]])) {
                                vector<int> top = st.top(); st.pop();
                                int leftlessindex = st.empty() ? -1 : st.top().back();
                                for (auto x : top) {
                                        ret[x].first = leftlessindex;
                                        ret[x].second = i;
                                }
                        }
                        if (!st.empty() && arr[i] == arr[st.top()[0]]) {
                                st.top().push_back(i);
                        } else {
                                st.push({ i });
                        }
                }

                while (!st.empty()) {
                        vector<int> top = st.top(); st.pop();
                        int leftlessindex = st.empty() ? -1 : st.top().back();
                        for (auto x : top) {
                                ret[x].first = leftlessindex;
                                ret[x].second = -1;
                        }
                }



                return ret;
        }

vector<pair<int, int>> getNearLessEqual_1(vector<int>& arr) {
                vector<pair<int, int>> ret(arr.size());

                stack<vector<int>> st;
                for (int i = 0; i < arr.size(); i++) {
                        while (!(st.empty() || arr[i] > arr[st.top()[0]])) {
                                vector<int> top = st.top(); st.pop();
                                int leftlessindex = st.empty() ? -1 : st.top().back();
                                for (auto x : top) {
                                        ret[x].first = leftlessindex;
                                        ret[x].second = i;
                                }
                        }
                        if (!st.empty() && arr[i] == arr[st.top()[0]]) {
                                st.top().push_back(i);
                        } else {
                                st.push({ i });
                        }
                }

                while (!st.empty()) {
                        vector<int> top = st.top(); st.pop();
                        int leftlessindex = st.empty() ? -1 : st.top().back();
                        for (auto x : top) {
                                ret[x].first = leftlessindex;
                                ret[x].second = -1;
                        }
                }



                return ret;
        }


vector<pair<int, int>> getNearf1(vector<int>& arr) {
                vector<pair<int, int>> ret(arr.size());

                stack<vector<int>> st;
                for (int i = 0; i < arr.size(); i++) {
                        while (!(st.empty() || arr[i]*arr[i] > arr[st.top()[0]]* arr[st.top()[0]])) {
                                vector<int> top = st.top(); st.pop();
                                int leftlessindex = st.empty() ? -1 : st.top().back();
                                for (auto x : top) {
                                        ret[x].first = leftlessindex;
                                        ret[x].second = i;
                                }
                        }
                        if (!st.empty() && arr[i] == arr[st.top()[0]]) {
                                st.top().push_back(i);
                        } else {
                                st.push({ i });
                        }
                }

                while (!st.empty()) {
                        vector<int> top = st.top(); st.pop();
                        int leftlessindex = st.empty() ? -1 : st.top().back();
                        for (auto x : top) {
                                ret[x].first = leftlessindex;
                                ret[x].second = -1;
                        }
                }



                return ret;
        }
};

int main() {
        vector<int> arr = { 3,2,4,3,3,4,1,3,4,5, };
        //                  0 1 2 3 4 5 6 7 8 9
        vector<pair<int, int>> ret = Solution().getNearf1(arr);
        for (int i = 0; i < arr.size(); i++) {
                cout << i << ":" << "[" << ret[i].first << "," << ret[i].second << "]" << endl;
        }
}

求各个元素左边和右边的最近的大于（等于）的下标

只需要保证栈从栈底到栈顶是严格递减即可，其他逻辑是一样的。

单调栈的扩展

单调栈不止求最近值的大小，还可以是其他的性质，只需要满足栈底到栈顶维持这个性质的单调性即可，当加入的元素不能满足这个单调性，此时就可以依次最近的某个性质。

求各个元素左边和右边最近 平方数 小于（等于）的下标



vector<pair<int, int>> getNearf1(vector<int>& arr) {
                vector<pair<int, int>> ret(arr.size());

                stack<vector<int>> st;
                for (int i = 0; i < arr.size(); i++) {
                        while (!(st.empty() || arr[i]*arr[i] > arr[st.top()[0]]* arr[st.top()[0]])) {
                                vector<int> top = st.top(); st.pop();
                                int leftlessindex = st.empty() ? -1 : st.top().back();
                                for (auto x : top) {
                                        ret[x].first = leftlessindex;
                                        ret[x].second = i;
                                }
                        }
                        if (!st.empty() && arr[i] == arr[st.top()[0]]) {
                                st.top().push_back(i);
                        } else {
                                st.push({ i });
                        }
                }

                while (!st.empty()) {
                        vector<int> top = st.top(); st.pop();
                        int leftlessindex = st.empty() ? -1 : st.top().back();
                        for (auto x : top) {
                                ret[x].first = leftlessindex;
                                ret[x].second = -1;
                        }
                }



                return ret;
        }

求各个求各个元素左边最近大于等于右边最近大于的下标




class Solution {
public:
    int getNeat_LeftHightEqual_RightHight(vector<int>& h) {
        int n = h.size();
        vector<pair<int, int>> map(n);
        stack<vector<int>> st;

        for (int i = 0; i < n; i++) {
            while (!(st.empty() || h[i] < h[st.top()[0]])) {
                vector<int> top = st.top();
                st.pop();
                int leftminindex = st.empty() ? -1 : st.top().back();
                for (auto x : top) {
                    map[x].first = leftminindex;
                    map[x].second = i;
                }
            }
            st.push({i});
        }
        while (!st.empty()) {
            vector<int> top = st.top();
            st.pop();
            int leftminindex = st.empty() ? -1 : st.top().back();
            for (auto x : top) {
                map[x].first = leftminindex;
                map[x].second = -1;
            }
        }

        return ret;
    }
};

结尾

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

谢谢您的支持，期待与您在下一篇文章中再次相遇！

数据结构与算法面试：单调栈与单调队列
AI天才研究院
05-06 911
本文旨在帮助准备技术面试的开发者深入理解单调栈（Monotonic Stack）和单调队列（Monotonic Queue）的原理、适用场景及实现方式。通过对比两者的特性、典型算法和实战案例，提炼面试高频问题的解题思路，提升应对“有序性元素关系”问题的能力。核心概念：定义、特性、与普通栈/队列的区别算法原理：单调栈的“Next Greater Element”算法，单调队列的“滑动窗口最大值”算法数学分析：时间复杂度证明、空间复杂度分析实战案例：LeetCode经典题目解析（含完整代码）
从零开始学习单调栈：图文并茂的算法教程
AI 算法实战派
06-02 797
在算法问题中，我们常遇到需要快速找到“某个元素左侧/右侧第一个更大/更小元素”的场景（例如计算柱状图最大矩形面积、接雨水问题）。传统暴力解法需要O(n²)时间复杂度，而单调栈能将这类问题优化到O(n)。本文将系统讲解单调栈的核心原理，覆盖从概念理解到实战应用的全流程，帮助读者掌握这一高效算法工具。本文从生活故事引入单调栈概念→拆解核心操作规则→用Python实现基础模板→通过2个经典问题实战→总结应用场景与未来扩展。全文穿插图示、代码注释和复杂度分析，确保“零基础可懂，实战能上手”。栈（Stack）
一文理解单调栈以可能扩展情况
m0_55356312的博客
05-10 474
一文理解单调栈以可能扩展情况
单调栈的应用总结（附典型例题讲解）
Keep eating codes!
03-23 1085
概念引入 单调栈是栈内元素自栈顶到栈底满足单调性的栈，元素在入栈时遵循单调原则，可以在线性时间内求出一个序列中的任一个元素向左（右）所能扩展到的最大长度，也即寻找其左边（右）第一个比它大（小）的数。 作用 单调栈可以求得以当前元素为最值的最大区间 单调递增栈可以找到往左/右第一个比当前元素大的元素 单调递减栈可以找到往左/右第一个比当前元素小的元素 接下来以几个典型题目为例，逐层深入地讲解一下...
单调栈的使用及扩展（下一个较大数、等待升温的天数、柱状图中的最大矩形）
一抹阳光的博客
07-08 220
栈（stack）是一种简单的数据结构，数据先进后出。单调栈实际上就是栈，利用一些巧妙的逻辑，使得每次新元素入栈后，栈内的元素都保持有序（单调递增或单调递减）首先考虑一个问题：给定一个数组，返回一个等长的数组，对应索引位置存储着比当前元素下一个更大元素，如果不存在这样的数，就存-1。根据每日气温列表，重新生成一个列表。对应位置的输出为：到下一次升温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
Python数据结构与算法篇（九）--单调栈与单调队列
CarpeDiem
04-18 2238
本篇主要以LeetCode上题目为例，合适的数据结构可以有效地降低算法的复杂度，本文分析单调栈和单调队列的使用技巧，以及如何在题目中灵活应用。
【单调栈】-----【原理+模版】
2401_82676816的博客
06-19 2177
单调栈的本质问题目标遍历方向栈中保持比较方向栈顶含义（结果）① 找右边第一个更大元素从右向左值递减栈（大压小）往右找大栈顶是右侧第一个更大元素的下标② 找左边第一个更大元素从左向右值递减栈（大压小）往左找大栈顶是左侧第一个更大元素的下标③ 找右边第一个更小元素从右向左值递增栈（小压大）往右找小栈顶是右侧第一个更小元素的下标④ 找左边第一个更小元素从左向右值递增栈（小压大）往左找小栈顶是左侧第一个更小元素的下标。
单调栈 —— 1.基本概念与核心算法
Smileyan's blog
04-12 6206
单调栈的基本概念与核心算法
单调栈应用介绍
10-28 1319
栈(Stack)是另一种操作受限的线性表，只允许元素从栈的顶端进顶端出，具有后进先出(LIFO)的特性。但单调栈(Monotonic Stack)是一种特殊的栈，在满足栈特性的基础上，栈内元素从栈底到栈顶具有单调性。如果栈底到栈顶元素是单调递减，则称为单调递减栈；如果栈底到栈顶元素是单调递增，则称为单调递增栈。新元素加入栈顶时，需要进行单调性维护，弹出不满足单调性的栈顶元素当前解计算是在出栈的时候进行的。
单调栈模板
xihongshi547的博客
05-24 671
本文介绍了单调栈的原理、模板代码及其常见应用场景。文章首先给出了单调栈的基本模板（支持递增/递减两种模式），然后重点分析了两种典型应用：1）寻找下一个更大/小元素问题，通过洛谷P2866例题详解解题思路；2）柱状图相关问题，包括最大矩形面积（LeetCode 84题）和接雨水问题（LeetCode 42题），均配有详细代码和思路图解。单调栈的核心在于维护元素的单调性，通过弹出不符合条件的元素来高效解决问题，时间复杂度通常为O(n)。文中案例展示了如何利用单调栈处理数组元素间的大小关系问题。
算法学习笔记——特殊数据结构：单调栈
Insomnia_X的博客
03-20 848
单调栈 单调栈本质上就是栈，但在使用栈的过程中，程序逻辑保证栈内的元素是单调的（单调递增或单调递减） 这听起来有点像堆heap，但实际上单调栈用途不广泛，多用于处理典型的问题：下一个更大元素(Next Greater Element)问题 单调栈模板 下一个更大元素：给出一个数组，返回一个等长数组，其中各索引出存储着原数组的该处元素的下一个更大元素(不存在则为-1)，例如，输入[2,1,2,4,3]，返回[4,2,4,-1,-1] 如何用O(n)复杂度解决问题？（相当于只线性扫描一遍数组） 思路：把
数据结构与算法：单调栈
2402_89326161的博客
03-09 809
单调栈
【栈】单调栈经典例题
SY奇星的OI博客
05-30 605
现在有一个长度为n的序列，在形成的任意子区间中，查找最小的值和此区间和的乘积的最大值。660例如在区间1-6中，最小值为1，区间和为21，积为21；在区间3-5中，最小值为4，区间和为15，积为60；再由遍历其他区间，得出值60为最大，最后您输出了60。
算法学习 18
t2786024916的博客
10-30 359
给你一个 32 位的有符号整数x，返回将x中的数字部分反转后的结果。如果反转后整数超过 32 位的有符号整数的范围，就返回 0。
八大排序算法
emtai486的博客
10-30 1089
比较排序，选择排序，交换排序，归并排序，非比较排序，五类八个排序算法的思想讲解，代码讲解，复杂度分析
3289. 数字小镇中的捣蛋鬼
最新发布
weixin_45256307的博客
11-02 335
3289. 数字小镇中的捣蛋鬼
RLHF 大模型对齐算法“填坑”史：从 PPO 的痛，到 DAPO
qq_63894862的博客
10-30 675
PPO是请了 4 个私教（模型）全方位辅导，效果好但学费极其昂贵。DPO是直接刷《五年高考三年模拟》，只看标准答案，效率高但缺乏举一反三的能力。GRPO是搞“学习小组”，大家互相批改作业，比平均分好的受表扬，既省了老师又保持了竞争。DAPO则是升级版的“精英学习小组”，只攻坚难题，并且鼓励尖子生“抢跑”。
leetcode375.猜数字大小II
weixin_74175349的博客
10-29 250
【代码】leetcode375.猜数字大小II。
最小调整顺序次数
y245166349的专栏
10-31 382
小A依次执行2n个指令往队列中添加数据和移出数据。其中n个指令是添加数据（可能从头部添加、也可能从尾部添加），依次添加1到n；n个指令是移出数据。有一个特异性的双端队列，该队列可以从头部或尾部添加数据，但是只能从头部移出数据。另外 n 行为移出数据指令，指令为："remove" 的形式，表示移出1个数据；请问 小A 最少需要调整几次才能够满足移除数据的顺序正好是1到n；为了满足最后输出的要求，小A可以在任何时候调整队列中数据的顺序。现在要求移除数据的顺序为1到n。一行一个数据n，表示数据的范围。
C语言栈与队列：表达式求值实战教程
"本资源详细讲解了如何在C语言中利用栈和队列数据结构实现表达式求值的实例。首先，我们需要理解栈和队列的基本概念，栈是一种后进先出（LIFO）的数据结构，而队列则是先进先出（FIFO）。在表达式求值中，栈通常用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

妖精七七_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值