算法解题：单调栈

单调栈的原理就是构造一个栈

单调递减栈就是当遍历的数组的元素 > 栈顶的元素时，
出栈然后计算相应的索引
一般进栈的都是索引值

Leetcode 42 接雨水

package 剑指offer.栈.单调栈;

import java.util.Stack;

/**
 * [一句话描述该类的功能]
 *
 * @author : [61692]
 * @version : [v1.0]
 * @createTime : [2022/9/1 9:32]
 */
public class leetcode42接雨水 {
    class Solution {
        public int trap(int[] walls) {
            if (walls == null || walls.length <= 2) {
                return 0;
            }

            // 思路：
            // 单调不增栈，walls元素作为右墙依次入栈
            // 出现入栈元素（右墙）比栈顶大时，说明在右墙左侧形成了低洼处，低洼处出栈并结算该低洼处能接的雨水

            int water = 0;
            Stack<Integer> stack = new Stack<>();
            for (int right=0; right<walls.length; right++) {
                // 栈不为空，且当前元素（右墙）比栈顶（右墙的左侧）大：说明形成低洼处了
                while (!stack.isEmpty() && walls[right]>walls[stack.peek()]) {
                    // 低洼处弹出，尝试结算此低洼处能积攒的雨水
                    int bottom = stack.pop();
                    // 看看栈里还有没有东西（左墙是否存在）
                    // 有右墙+有低洼+没有左墙=白搭
                    if (stack.isEmpty()) {
                        break;
                    }

                    // 左墙位置以及左墙、右墙、低洼处的高度
                    int left = stack.peek();
                    int leftHeight = walls[left];
                    int rightHeight = walls[right];
                    int bottomHeight = walls[bottom];

                    // 能积攒的水=(右墙位置-左墙位置-1) * (min(右墙高度, 左墙高度)-低洼处高度)
                    water += (right-left-1) * (Math.min(leftHeight, rightHeight)-bottomHeight);
                }

                // 上面的pop循环结束后再push，保证stack是单调不增
                stack.push(right);
            }
            return water;
        }
    }
}

Leetcode 739每日温度

package 剑指offer.栈.单调栈;

import java.util.Stack;

/**
 * [一句话描述该类的功能]
 *
 * @author : [61692]
 * @version : [v1.0]
 * @createTime : [2022/9/1 9:16]
 *
 * 当遇到该数组的值与栈顶数字小，栈顶则出栈，并计算索引差
 * 否则就入栈
 */
public class leetcode739每日温度 {
    class Solution {
        public int[] dailyTemperatures(int[] temperatures) {
            Stack<Integer> stack = new Stack<>();
            int[] result = new int[temperatures.length];
            for(int i  = 0; i < temperatures.length;i++){
                //只要发现数组的数大于栈顶的数字，就把栈中的数弹出
                //最后也要把该数 压入栈内 
                while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){
                    int preIndex = stack.pop();
                    result[preIndex] = i - preIndex;
                }
                stack.push(i);
            }
            return result;
        }
    }
}

还有今天的每日一题 leetcode1475也可以使用该方法去做
这是 使用 单调递增栈
当遍历的该元素小于或者等于 栈顶元素的时候，弹出
以此来保证 栈内是单调递增的

class Solution {
    public int[] finalPrices(int[] prices) {
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < prices.length;i++){
            while(!stack.isEmpty() && prices[i] <= prices[stack.peek()]){
                int preIndex = stack.pop();
                prices[preIndex] -= prices[i];
            }
            stack.push(i);
        }
        return prices;
    }
}