算法学习|单调栈

学习材料声明

所有知识点都来自互联网,进行总结和梳理,侵权必删。
引用来源:基本参考代码随想录的刷题顺序和讲解。

理论基础

单调栈是什么?

应用场景:通常是一维数组,要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置,此时我们就要想到可以用单调栈了。时间复杂度为O(n)。

本质:单调栈的本质是空间换时间,因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素,优点是整个数组只需要遍历一次。

要确定的东西:存放什么?栈内元素递增or递减?三种情况如何操作?(截图来自代码随想录)

来自代码随想录
来自代码随心录

整个代码模型

设置栈,确定入栈的三种情况。

习题

1|739. 每日温度

非常直观可暴力。但是不够优美呀。
单调栈做法:

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        // 递增栈
        stack<int> st;
        vector<int> result(temperatures.size(), 0);
        for(int i=0; i<temperatures.size(); i++){
            if(st.empty()){
                st.push(i);
                continue;
            }
            while(!st.empty()&&temperatures[i]>temperatures[st.top()]){
                result[st.top()] = i-st.top();
                st.pop();
            }
            st.push(i);
        }
        return result;       
    }
};

2|496.下一个更大元素 I

相比于上一题,多一个查找的过程。

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        // 递增栈
        stack<int> st;
        vector<int> result(nums2.size(), -1);
        for(int i=0; i<nums2.size(); i++){
            if(st.empty()){
                st.push(i);
                continue;
            }
            while(!st.empty()&&nums2[i]>nums2[st.top()]){
                result[st.top()] = nums2[i];
                st.pop();
            }
            st.push(i);
        }
        for(int j=0; j<nums2.size(); j++){
            cout<<result[j]<<" ";
        }
        vector<int> result2(nums1.size(), -1);
        for(int i=0; i<nums1.size(); i++){
            for(int j=0; j<nums2.size(); j++){
                if(nums1[i]==nums2[j]){
                    result2[i] = result[j];
                }
            }
        }
        return result2;  
    }
};

代码随想录:用到了map的映射。

// 版本二
class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> st;
        vector<int> result(nums1.size(), -1);
        if (nums1.size() == 0) return result;

        unordered_map<int, int> umap; // key:下标元素,value:下标
        for (int i = 0; i < nums1.size(); i++) {
            umap[nums1[i]] = i;
        }
        st.push(0);
        for (int i = 1; i < nums2.size(); i++) {
            while (!st.empty() && nums2[i] > nums2[st.top()]) {
                if (umap.count(nums2[st.top()]) > 0) { // 看map里是否存在这个元素
                    int index = umap[nums2[st.top()]]; // 根据map找到nums2[st.top()] 在 nums1中的下标
                    result[index] = nums2[i];
                }
                st.pop();
            }
            st.push(i);
        }
        return result;
    }
};

----------------------------------------------------------------------------2023年11月02日----------------------------------------------------------

3| 503.下一个更大元素II

还是挺难的,做了45min,怎么结束循环啊。我是直接让他循环三次。

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        stack<int> stk;
        vector<int> ans(nums.size(), -1);
        vector<int> flag(nums.size(), 0);
        if(nums.size()==1){
            return ans;
        }
        stk.push(0);
        for(int i=1, j=1; j<3*nums.size() ;j++,i=j%nums.size()){
            while(!stk.empty()&&(nums[i]>nums[stk.top()])){
               if(flag[stk.top()]==1){
                   ans[stk.top()] = nums[i];
               }else{
                   flag[stk.top()]=1;
               }
               stk.pop();               
            }
            stk.push(i);
        }
        return ans;    
    }
};

4|42. 接雨水

脑子有点转换不过来了。
代码随想录解法1(每一列计算),超时了:
来自代码随想录

class Solution {
public:
    int trap(vector<int>& height) {
        int ans=0, tmp=0;
        for(int i=0; i<height.size(); i++){
            if(i==0||i==height.size()-1){
                continue;
            }
            int lheight = height[i];
            for(int n=i-1; n>=0; n--){
                if(height[n]>lheight){
                    lheight = height[n];
                }
            }
            int rheight = height[i];
            for(int m=i+1; m<height.size(); m++){
                if(height[m]>rheight){
                    rheight = height[m];
                }
            }          
            tmp = min(lheight, rheight)-height[i];
            if(tmp>0){
                ans+=tmp;
            }

        }
        return ans;
    }
};

解法二:双指针策略,用空间换取每次左右遍历的时间。

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0;
        vector<int> maxLeft(height.size(), 0);
        vector<int> maxRight(height.size(), 0);
        int size = maxRight.size();

        // 记录每个柱子左边柱子最大高度
        maxLeft[0] = height[0];
        for (int i = 1; i < size; i++) {
            maxLeft[i] = max(height[i], maxLeft[i - 1]);
        }
        // 记录每个柱子右边柱子最大高度
        maxRight[size - 1] = height[size - 1];
        for (int i = size - 2; i >= 0; i--) {
            maxRight[i] = max(height[i], maxRight[i + 1]);
        }
        // 求和
        int sum = 0;
        for (int i = 0; i < size; i++) {
            int count = min(maxLeft[i], maxRight[i]) - height[i];
            if (count > 0) sum += count;
        }
        return sum;
    }
};

解法三:单调栈解法。代码来自代码随想录:

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0; // 可以不加
        stack<int> st; // 存着下标,计算的时候用下标对应的柱子高度
        st.push(0);
        int sum = 0;
        for (int i = 1; i < height.size(); i++) {
            if (height[i] < height[st.top()]) {     // 情况一
                st.push(i);
            } if (height[i] == height[st.top()]) {  // 情况二
                st.pop(); // 其实这一句可以不加,效果是一样的,但处理相同的情况的思路却变了。
                st.push(i);
            } else {                                // 情况三
                while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while
                    int mid = st.top();
                    st.pop();
                    if (!st.empty()) {
                        int h = min(height[st.top()], height[i]) - height[mid];
                        int w = i - st.top() - 1; // 注意减一,只求中间宽度
                        sum += h * w;
                    }
                }
                st.push(i);
            }
        }
        return sum;
    }
};

----------------------------------------------------------------------------2023年11月03日----------------------------------------------------------

4|84. 柱状图中最大的矩形

维持一个单调递增的栈,然后小于的情况进行计算。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
    	int maxArea = 0, left, right, fixHeight, tempArea, tempIdx;
    	stack<int> stk;
    	for(int i = 0; i < heights.size(); i++){
    		if(stk.empty()){
    			stk.push(i);
			}
			else if( !stk.empty() && heights[i] >= heights[stk.top()]){
				stk.push(i);
			}else if(!stk.empty() && heights[i] < heights[stk.top()]){
				right = i;
				while( !stk.empty() && heights[i] < heights[stk.top()])
				{
					tempIdx = stk.top();
					stk.pop();
					if(!stk.empty()){
						left = stk.top();
					}				
					else{
						left = -1;	
					}
					tempArea = heights[tempIdx] * (right - left-1);
					if(maxArea < tempArea){
						maxArea = tempArea;
					}
					//cout<<right<<' '<<left<<' '<<"tempArea="<<tempArea<<'\n';
				}
				stk.push(i);			
			}				
		}
		right = stk.top();
		while(!stk.empty()){
			tempIdx = stk.top();
			stk.pop();
			if(!stk.empty()){
				left = stk.top();
			}				
			else{
				left = -1;	
			}
			tempArea = heights[tempIdx] * (right - left);
			if(maxArea < tempArea){
				maxArea = tempArea;
			}
		}
		return maxArea;            
    }
};

----------------------------------------------------------------------------2023年11月04日----------------------------------------------------------

<think>嗯,用户让我介绍一下单调栈算法题,我需要先理解他们可能的需求。可能他们是在准备面试,或者在学习数据结构和算法时遇到了困难。首先,我得明确单调栈的定义和基本概念,然后解释它的应用场景,再给出一些经典例题,这样用户能更好地理解。 首先,单调栈是什么?它是一种特殊的栈结构,里面的元素按照某种顺序排列,比如递增或递减。这种结构通常用来解决需要寻找下一个更大或更小元素的问题。比如,LeetCode上的“每日温度”或者“柱状图中最大的矩形”这类题目。 接下来,我需要讲清楚单调栈的工作原理。比如,当遍历数组时,如何维护栈内元素的单调性。比如,当寻找下一个更大元素时,栈应该是单调递减的。遇到比栈顶大的元素时,就弹出栈顶,并记录结果。这个过程需要详细说明,可能还要举个具体的例子,比如用数组[73,74,75,71,69,72,76,73]来说明每日温度的问题。 然后,应用场景部分需要列举几个常见的问题类型,比如找下一个更大元素、上一个更小元素、或者处理矩形面积等。每个场景最好对应一个例题,并简要说明解决思路。例如,柱状图中最大的矩形,这题需要用单调栈来找到每个柱子左右两边第一个比它矮的柱子,从而计算面积。 可能用户还会想知道实现时的注意事项,比如栈中存储的是元素的值还是索引?通常是索引,因为需要计算位置差或者处理元素的位置关系。另外,处理循环数组的情况,可能需要将数组长度翻倍,或者使用取模的方法来模拟循环。 还有时间复杂度的分析,单调栈通常是O(n),因为每个元素最多入栈和出栈一次。这点需要强调,因为它比暴力解法高效很多。 在编写过程中,要确保例子清晰,步骤详细。比如,用具体的数字一步步推演栈的变化和结果的计算过程。这样用户能够直观地看到每一步发生了什么,理解为什么单调栈有效。 此外,可能需要提醒用户常见的错误,比如在比较元素大小时忘记处理栈为空的情况,或者在处理边界条件时出错。例如,当所有元素都没有下一个更大元素时,应该如何处理返回值。 最后,总结一下单调栈的核心思想,以及解决问题的步骤:确定单调方向、遍历元素、维护栈结构、计算结果。并鼓励用户通过练习题目来巩固理解,推荐一些经典的题目供他们练习。 现在,我需要把这些思考组织成一个结构清晰的回答,分点说明,使用例子来辅助解释,确保用户能够逐步理解单调栈的原理和应用。</think>### 单调栈算法详解 #### 一、基本概念 **单调栈**是一种特殊的栈结构,其内部元素始终保持单调递增或递减的顺序。常用于解决需要寻找元素**下一个更大(或更小)元素**的问题。 #### 二、核心原理 1. **单调性维护** - 递增栈:栈底到栈顶元素递增,用于寻找下一个更小元素。 - 递减栈:栈底到栈顶元素递减,用于寻找下一个更大元素。 2. **操作流程** 遍历数组时,比较当前元素与栈顶元素: - 若符合单调性,压入栈。 - 若破坏单调性,弹出栈顶并记录结果,直到满足单调性。 #### 三、典型应用场景 1. **下一个更大元素** - 例题:[LeetCode 739. 每日温度](https://leetcode.com/problems/daily-temperatures/) - 示例:数组 `[73,74,75,71,69,72,76,73]`,求每个元素下一次更高温度的天数差。 - 过程: ```text 索引 元素 栈操作 结果 0 73 入栈 [ ] 1 74 弹出73,入74 res[0]=1-0=1 2 75 弹出74,入75 res[1]=2-1=1 3 71 入栈 [75,71] 4 69 入栈 [75,71,69] 5 72 弹出69、71,入72 res[4]=5-4=1, res[3]=5-3=2 6 76 弹出72、75,入76 res[5]=6-5=1, res[2]=6-2=4 7 73 入栈 [76,73] ``` - 结果:`[1,1,4,2,1,1,0,0]` 2. **最大矩形面积** - 例题:[LeetCode 84. 柱状图中最大的矩形](https://leetcode.com/problems/largest-rectangle-in-histogram/) - 核心思路:对每个柱子,找到左右第一个比它矮的柱子,确定宽度边界。 3. **循环数组问题** - 处理方式:将数组长度翻倍遍历,或索引取模模拟循环。 #### 四、代码模板(以递减栈为例) ```python def monotonic_stack(nums): stack = [] res = [0] * len(nums) for i in range(len(nums)): while stack and nums[i] > nums[stack[-1]]: top = stack.pop() res[top] = i - top stack.append(i) return res ``` #### 五、复杂度分析 - **时间复杂度**:$O(n)$,每个元素最多入栈和出栈一次。 - **空间复杂度**:$O(n)$,栈空间最坏情况存储全部元素。 #### 六、注意事项 1. 栈中通常存储**索引**而非值,便于计算位置差。 2. 遍历结束后,栈中剩余元素需单独处理(如无后续更大元素时设为0)。 #### 七、经典习题推荐 1. [下一个更大元素 I](https://leetcode.com/problems/next-greater-element-i/) 2. [接雨水](https://leetcode.com/problems/trapping-rain-water/) 3. [子数组的最小值之和](https://leetcode.com/problems/sum-of-subarray-minimums/) 通过练习上述题目,可以深入掌握单调栈的变种应用和边界处理技巧。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值