目录

一.单调栈

二.每日温度

1.题目描述

2.问题分析

3.代码实现

三.下一个更大元素 I

1.题目描述

2.问题分析

3.代码实现

四.下一个更大元素 II

1.题目描述

2.问题分析

3.代码实现

一.单调栈

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

时间复杂度为O(n)。

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

四种单调栈的结构

 在不同的问题中,我们通常采用这四种结构的一种用来解决问题

二.每日温度

1.题目描述

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

力扣:力扣

2.问题分析

为一道典型的使用单调栈的题目.

因为题目描述是要求寻找比当前温度更高的气温,因此要求这是一个单调不递增的单调栈(从栈底到栈顶)来看,因为找到比当前温度高了的天数的时候弹出,并修改res数组,没有满足这个条件入栈,直到找到满足的天数出栈.

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

• 情况一:当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
• 情况二:当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
• 情况三:当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况

 举例分析temperatures= [73,74,75,71,69,71,76,73]单调栈的运转情况

①第一个,将i=0入栈

②temperatures[1]=74>temperatures[0]=73,因为我们要保持单调不递增的单调栈,所以将i=1进行出栈操作,同时更新res数组

③temperatures[2]=75>temperatures[1]=74,因为我们要保持单调不递增的单调栈,所以将i=2进行出栈操作,同时更新res数组

④temperatures[3]=71<temperatures[2]=75,符合单调不递增的单调栈,将i=3进行入栈操作

⑤temperatures[4]=69<temperatures[3]=71,符合单调不递增的单调栈,将i=4进行入栈操作

⑥temperatures[5]=69<temperatures[4]=71,因为我们要保持单调不递增的单调栈,所以将i=4进行出栈操作,同时更新res数组

⑦继续进行比较temperatures[5]==temperatures[3],符合单调不递增的单调栈,将i=5进行入栈操作

⑧temperatures[6]=76>temperatures[5]=71,因为我们要保持单调不递增的单调栈,所以将i=5进行出栈操作,同时更新res数组,temperatures[6]=76>temperatures[3]=71,i=3出栈,更新res数组      temperatures[6]=76>temperatures[2]=75,i=2出栈,更新res数组

同时i=6入栈

⑨temperatures[7]=76<temperatures[6]=73,符合单调不递增的单调栈,将i=7进行入栈操作

 至此,更新完毕,最后留在栈的元素无法找到比他们大的元素,所以res[i]=0

3.代码实现

  public static int[] dailyTemperatures(int[] temperatures) {
        int[] result = new int[temperatures.length];
        LinkedList<Integer> stack = new LinkedList<>();
        stack.push(0);//入栈第一天的温度
        for (int i = 1; i < temperatures.length; ++i) {
            //情况三:当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况
            while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
                int pop = stack.pop();
                result[pop] = i - pop;
            }

            //情况一:当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
            //情况二:当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
            //此时应该直接进行入栈操作
            //此时因为前边已经筛选出了不满足条件的情况,此时可以直接入栈操作
            stack.push(i);

        }

        return result;

    }

三.下一个更大元素 I

1.题目描述

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] 是如上所述的 下一个更大元素 。

力扣:力扣

2.问题分析

这一题比上一题有一定的难度,因为他不是一个数组,而是在两个数组,要求找到第一个数组中找到与第一个数组中值相同值的下一个的比他大的值的下标,如果我们采用暴力的方法进行解答,肯定是先找出nums2中与nums1此位置(i)相同值的的索引j,然后遍历j+1到len2范围内的值,比较比nums1[i]大的值的索引,然后更新res数组

用nums1 = [4,1,2], nums2 = [1,3,4,2]进行分析

但是我们是否可以考虑从nums2数组入手进行解决问题呢?首先是求下一个更大的元素,因此选用单调不递增的单调栈,对nums2进行上一题一样的入栈和出栈操作,当出栈的时候,例如nums[0]<nums[1]的时候,j=0出栈,我们只需要在nums1中寻找到nums1[i]=nums[0]=1的下标i=1,就可以进行res数组进行更新(res[i]=nums[j]),其实这就是暴力的方法求解的反过程

3.代码实现

    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] ans = new int[nums1.length];
        Arrays.fill(ans, -1);
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums1.length; ++i) {
            map.put(nums1[i], i);
        }
        LinkedList<Integer> stack = new LinkedList<>();
        stack.push(0);
        for (int i = 1; i < nums2.length; ++i) {
            //情况三
            while (!stack.isEmpty()&&nums2[i] > nums2[stack.peek()]) {
                //判断nums1中是否存在当前这个元素
                if (map.containsKey(nums2[stack.peek()])) {
                    //出栈的下标
                    int index = stack.peek();
                    //map.get(nums2[index])就是nums1数组中值
                    // 为出栈元素下标为index在nums2中的值
                    ans[map.get(nums2[index])] = nums2[i];
                }
                stack.pop();

            }
            //情况一,情况二
            stack.push(i);

        }
        return ans;
    }

四.下一个更大元素 II

1.题目描述

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

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

力扣: 力扣

2.问题分析

拿nums = [1,2,1]为例

其实这个问题直接转换为1,2,1,1,2相当于对这样一个数组进行单调栈的操作,这一题同样是选择单调不递增的单调栈

3.代码实现

    public int[] nextGreaterElements(int[] nums) {
         //边界判断
        if(nums == null || nums.length <= 1) {
            return new int[]{-1};
        }
        int size = nums.length;
        int[] result = new int[size];//存放结果
        Arrays.fill(result,-1);//默认全部初始化为-1
        Stack<Integer> st= new Stack<>();//栈中存放的是nums中的元素下标
        for(int i = 0; i < 2*size; i++) {
            while(!st.empty() && nums[i % size] > nums[st.peek()]) {
                result[st.peek()] = nums[i % size];//更新result
                st.pop();//弹出栈顶
            }
            st.push(i % size);
        }
        return result;
    }