单调栈结构

单调栈

1.什么是单调栈
单调栈，顾名思义就是栈内元素单调按照递增(递减)顺序排列的栈。
单调递增栈：

①在一个队列中针对每一个元素从它右边寻找第一个比它小的元素

②在一个队列中针对每一个元素从它左边寻找第一个比它小的元素

单调递减栈：

①在一个队列中针对每一个元素从它右边寻找第一个比它大的元素

②在一个队列中针对每一个元素从它左边寻找第一个比它大的元素

单调栈何时用：为任意一个元素找左边和右边第一个比自己大/小的位置用单调栈，时间复杂度为O(n)

2.流程介绍
2.1 流程说明
此处假设单调栈是一个从栈顶到栈底单调递减的栈

向单调栈内插入元素时，可能需要弹出元素以保证栈内的单调性。
情况1：
栈底无元素：直接加入栈
情况2：
栈底有元素：
如果要插入的元素x是大于栈顶元素的，说明x大于栈内任何一个元素，因此无需其他操作，直接插入即可。
如果要插入的元素x是小于栈顶元素的，说明需要弹出部分元素，以确保插入该元素x后栈的单调性。

从栈中弹出元素时
情况1：
弹出元素后，栈底无元素，当前元素前没有比该元素小的元素
情况2：
弹出元素后，栈顶有元素，栈顶元素比当前元素小
情况3：
最后一个元素加入栈后，数组已经遍历完，弹出栈顶元素，该元素后，没有比该元素小的元素
情况4：
最后一个元素弹出，该元素是最小的元素，前后已经没有比它小的元素了
2.1流程图



2.3代码介绍
当数组中没有重复的元素时

	public static int[][] getNearLessNoRepeat(int[] arr) {
		int[][] res = new int[arr.length][2];
		// 只存位置！
		Stack<Integer> stack = new Stack<>();
		for (int i = 0; i < arr.length; i++) { // 当遍历到i位置的数，arr[i]
			while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
				int j = stack.pop();
				int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
				res[j][0] = leftLessIndex;
				res[j][1] = i;
			}
			stack.push(i);
		}
		while (!stack.isEmpty()) {
			int j = stack.pop();
			int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
			res[j][0] = leftLessIndex;
			res[j][1] = -1;
		}
		return res;
	}

当数据中有重复的元素

	public static int[][] getNearLess(int[] arr) {
		int[][] res = new int[arr.length][2];
		Stack<List<Integer>> stack = new Stack<>();
		for (int i = 0; i < arr.length; i++) { // i -> arr[i] 进栈
			while (!stack.isEmpty() && arr[stack.peek().get(0)] > arr[i]) {
				List<Integer> popIs = stack.pop();
				int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
				for (Integer popi : popIs) {
					res[popi][0] = leftLessIndex;
					res[popi][1] = i;
				}
			}
			if (!stack.isEmpty() && arr[stack.peek().get(0)] == arr[i]) {
				stack.peek().add(Integer.valueOf(i));
			} else {
				ArrayList<Integer> list = new ArrayList<>();
				list.add(i);
				stack.push(list);
			}
		}
		while (!stack.isEmpty()) {
			List<Integer> popIs = stack.pop();
			int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
			for (Integer popi : popIs) {
				res[popi][0] = leftLessIndex;
				res[popi][1] = -1;
			}
		}
		return res;
	}

2.4.例题
https://leetcode.cn/problems/largest-rectangle-in-histogram/

、	public static int largestRectangleArea1(int[] height) {
		if (height == null || height.length == 0) {
			return 0;
		}
		int maxArea = 0;
		Stack<Integer> stack = new Stack<Integer>();
		for (int i = 0; i < height.length; i++) {
			while (!stack.isEmpty() && height[i] <= height[stack.peek()]) {
				int j = stack.pop();
				int k = stack.isEmpty() ? -1 : stack.peek();
				int curArea = (i - k - 1) * height[j];
				maxArea = Math.max(maxArea, curArea);
			}
			stack.push(i);
		}
		while (!stack.isEmpty()) {
			int j = stack.pop();
			int k = stack.isEmpty() ? -1 : stack.peek();
			int curArea = (height.length - k - 1) * height[j];
			maxArea = Math.max(maxArea, curArea);
		}
		return maxArea;
	}

用数组模拟栈减少常数时间

	public static int largestRectangleArea2(int[] height) {
		if (height == null || height.length == 0) {
			return 0;
		}
		int N = height.length;
		int[] stack = new int[N];
		int si = -1;
		int maxArea = 0;
		for (int i = 0; i < height.length; i++) {
			while (si != -1 && height[i] <= height[stack[si]]) {
				int j = stack[si--];
				int k = si == -1 ? -1 : stack[si];
				int curArea = (i - k - 1) * height[j];
				maxArea = Math.max(maxArea, curArea);
			}
			stack[++si] = i;
		}
		while (si != -1) {
			int j = stack[si--];
			int k = si == -1 ? -1 : stack[si];
			int curArea = (height.length - k - 1) * height[j];
			maxArea = Math.max(maxArea, curArea);
		}
		return maxArea;
	}