【Java 单调栈 下一个更大元素 I II】

单调栈性质

1. 单调栈里的元素具有单调性，栈中元素只能是单调递增或单调递减；
2. 元素入栈前，会在栈顶端把破坏单调性的元素去除掉；
3. 使用单调栈可以找到元素向左遍历第一个比它小的元素，也可以找到元素向左遍历第一个比它大的元素。

题目1：经典面试题

给一个数组，返回一个大小相同的数组。返回的数组的第i个位置的值应当是，对于原数组中的第i个元素，至少往右走多少步，才能遇到一个比自己大的元素（如果之后没有比自己大的元素，或者已经是最后一个元素，则在返回数组的对应位置放上-1）。

示例：

输入: 5,3,1,2,4

输出: -1 3 1 1 -1

解释: 对于第0个数字5，之后没有比它更大的数字，因此是-1，对于第1个数字3，需要走3步才能达到4（第一个比3大的元素），对于第2和第3个数字，都只需要走1步，就可以遇到比自己大的元素。对于最后一个数字4，因为之后没有更多的元素，所以是-1。

暴力解法：

pubilc int[] nextExceed(int[] input) {
	int[] res = new int[input.length];
	Arrays.fill(res, -1);
	for (int i = 0; i < input.length; i++) {
		int cur = input[i];
		for (int j = i + 1; j < input.length; j++) {
			if (input[j] > cur) {
				res[i] = j - i;	
			}	
		}
	}
	return res;
}

暴力做的结果就是O(n^2)的时间复杂度，例如对于一个单调递减的数组，每次都要走到数组的末尾。那么用单调栈怎么做呢？

思路解析：

• 维护一个单调递减的stack，stack内部存的是原数组的每个index。
• 每当我们遇到一个比当前栈顶所对应的数（就是input[monoStack.top()]）大的数的时候，我们就遇到了一个“大数“，至少比当前栈顶所对应的数大。
• 弹出栈内所有对应数比这个数小的栈内元素，并更新它们在返回数组中对应位置的值。
• 因为这个栈本身的单调性，当我们栈顶元素所对应的数比这个元素大的时候，我们可以保证，栈内所有元素都比这个元素大。
• 对于每一个元素，当它出栈的时候，说明它遇到了自己的next greater element，我们也就要更新return数组中的对应位置的值。
• 如果一个元素一直不曾出栈，那么说明不存在next greater element，我们也就不用更新return数组了。

单调栈-代码实现

pubilc int[] nextExceed(int[] input) {
	int[] res = new int[input.length];
	Arrays.fill(res, -1);
	Deque<Integer> stack = new ArrayDeque<>(input.length);
	for (int i = 0; i < input.length; i++) {
		while (!stack.isEmpty() && input[i] > input[stack.peek()]) {
			int top = stack.pop();
			res[top] = i - top;
		}
		stack.push(i);
	}
	return res;
}

复杂度分析：
对于每个元素都只有一次入栈和出栈的操作，所以时间复杂度只有O(n)。

题目2：力扣-下一个更大元素II https://leetcode.cn/problems/next-greater-element-ii/description/

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

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

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

提示:

1 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9

解题思路：

• 要求出所有元素的下一个更大元素，只需要在数组元素后在重复一遍数组元素即可；
• 栈中记录还没算出「下一个更大元素」的那些数的下标；
• 只要遍历到比栈顶元素值更大的数，就意味着栈顶元素找到了答案，记录答案，然后弹出栈顶。

代码实现：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int len = nums.length;
        int[] res = new int[len];
        Arrays.fill(res, -1);
        Deque<Integer> stack = new ArrayDeque<>();
        for (int i = 0; i < 2 * len; i++) {
            int cur = nums[i % len];
            while (!stack.isEmpty() && cur > nums[stack.peek()]) {
            	// cur 是 nums[stack.peek()] 的下一个更大元素
                // 既然 nums[stack.peek()] 已经算出答案，则从栈顶弹出
                res[stack.pop()] = cur;
            }
            //栈中只添加到数组大小，以此求每个元素的下一个更大元素
            if (i < len) {
                stack.push(i);
            }
        }
        return res;
    }
}