单调栈题目总结

什么时候用单调栈？-- 结合每日温度那道题分析

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

单调栈本质：就是用一个栈来记录我们遍历过的元素

在使用单调栈的时候要明确如下几点：

• 单调栈里存放的元素是什么？

• 单调栈里的元素是递增呢？还是递减的？

递增顺序，因为只有递增的时候，栈里要加入一个元素 i的时候，才知道栈顶元素在数组中右面第一个比栈顶大的元素是 i.

使用单调栈主要有三个判断条件：

• 当前遍历的元素T[i]小于栈顶元素T[st.peek()]的情况

• 当前遍历的元素T[i]等于栈顶元素T[st.peek()]的情况

• 当前遍历的元素T[i]大于栈顶元素T[st.peek()]的情况

力扣496. 下一个更大元素I

题目大致意思：给两个数组 nums1 和 nums2，数组 nums1是数组nums2 的子数组，两个数组中的元素各不相同。nums1 中下一个更大的元素：首先需要在nums2 中找到这个元素，在nums2中往右遍历找比这个元素还大的第一个元素，找不到，本次查询为-1；找到的话，本次查询结果为下一个更大元素的值。

分析：1、找一个元素是否在某个集合中，肯定要用哈希法呀。将nums1中的元素放入到Map集合中。

2、接下来遍历nums2，使用单调栈进行做，与每日温度那道题在收集结果的时候有一些不同。

分析单调栈的三种情况：接下来就要分析如下三种情况，一定要分析清楚。

• 情况一：当前遍历的元素nums2[i]小于栈顶元素 nums2[st.peek()] 的情况

此时满足递增栈（栈头到栈底的顺序），所以直接入栈。

• 情况二：当前遍历的元素 nums2[i] 等于栈顶元素nums2[st.peek()]的情况

如果相等的话，依然直接入栈，因为我们要求的是右边第一个比自己大的元素，而不是大于等于！

• 情况三：当前遍历的元素nums2[i]大于栈顶元素nums2[st.peek()]的情况

此时如果入栈就不满足递增栈了，这也是找到右边第一个比自己大的元素的时候。

判断栈顶元素是否在nums1里出现过，（注意栈里的元素是nums2的元素），如果出现过，开始记录结果。

3、注意：由于没有找到，本次查询的结果为-1，所以在定义结果数组的时候，初始化元素的值应该为-1

代码：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        
        int[] ans= new int[nums1.length];
        Arrays.fill(ans,-1);

       Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i < nums1.length;i++){
            map.put(nums1[i],i); //key是元素的值，value是数组下标
        }
        //在num2的数组中应用单调栈的逻辑 -- 单调栈中放的是数组的下标
        Stack<Integer> st = new Stack();
        st.push(0); //首先，将数组中的第一个元素下标入栈
        for(int i = 1;i < nums2.length;i++){
            if(nums2[i] < nums2[st.peek()]){ //入栈仍满足栈单调 第一种情况
                st.push(i);
            }else if(nums2[i] < nums2[st.peek()]){ //第二种情况
                st.push(i);
            }else{ //第三种情况
                while(!st.empty() && nums2[i] > nums2[st.peek()]){
                    //在收集结果前，判断当前栈顶元素是否在 num1中存在过,存在了收集结果
                    if(map.containsKey(nums2[st.peek()])){
                        Integer index = map.get(nums2[st.peek()]);
                        ans[index] = nums2[i];

                    }
                    //删除栈顶元素
                    st.pop();
                }
                st.push(i);
            }
        }
        return ans;
    }

}

503. 下一个更大元素 II

代码：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        //单调栈 -- 递增单调栈（从栈头到栈底的顺序）
        //循环搜索怎么做？？？--- 可以把两个nums数组拼接起来,但是比较麻烦。
        //其实也可以直接在也可以不扩充nums，而是在遍历的过程中模拟走了两遍nums。
        Stack<Integer> st = new Stack();
        int len = nums.length;
        int[] res = new int[len];
        Arrays.fill(res,-1); //没有找到的话，查询结果为-1，所以结果数组需要初始化为-1
        st.push(0);
        for(int i=1;i < len*2; i++){
            if(nums[i%len] <= nums[st.peek()]){
                st.push(i%len);
            }else{
                while(!st.empty() && nums[i%len] > nums[st.peek()]){
                    //收集结果
                    res[st.peek()] = nums[i%len];
                    st.pop();
                }
                st.push(i%len);
            }
        }
        return res;
        
    }   
}