题目列表
解题过程
1、739.每日温度
给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。
思路： 可以用暴力解法（两层for循环），也可以使用单调栈的解法。
通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)。
单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。
更直白来说，就是用一个栈来记录我们遍历过的元素，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。
注意：
- 单调栈里存放的元素是什么？
- 只存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取
- 单调栈里的元素是递增的
- 从栈头（栈顶）到栈底，递增顺序，只有递增的时候，栈里要加入一个元素i的时候，才知道栈顶元素在数组中右边第一个比栈顶元素大的元素是i
- 如果求一个元素右边第一个更大元素，单调栈就是递增的
- 如果求一个元素右边第一个更小元素，单调栈就是递减的
- 使用单调栈有三个判断条件（这里把推理过程看懂！）
- 当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
- 当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
- 当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
int len = temperatures.length;
int[] res = new int[len];
Deque<Integer> stack = new LinkedList<>();
stack.push(0);
for (int i = 1; i < len; i++) {
if (temperatures[i] <= temperatures[stack.peek()]) {
stack.push(i);
} else {
while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
res[stack.peek()] = i - stack.peek();
stack.pop();
}
// 找到i该放的位置
stack.push(i);
}
}
return res;
}
}
// 版本 2
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
int lens = temperatures.length;
int []res = new int[lens];
Deque<Integer> stack = new LinkedList<>();
for(int i = 0; i < lens; i++){
while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){
res[stack.peek()] = i - stack.peek();
stack.pop();
}
stack.push(i);
}
return res;
}
}
2、496.下一个更大元素I
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] **是如上所述的 下一个更大元素 。
思路： 这里需要判断nums2[i]是否在nums1中出现过。要清楚，此时栈顶元素在nums2数组中右面第一个大的元素是nums2[i]（即当前遍历元素）。
class Solution {
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
int len = nums1.length;
Stack<Integer> temp = new Stack<>();
int[] res = new int[len];
// 初始化
Arrays.fill(res, -1);
HashMap<Integer, Integer> hashMap = new HashMap<>();
for (int i = 0; i < len; i++) {
hashMap.put(nums1[i], i);
}
// 单调栈 入栈
temp.add(0);
for (int i = 1; i < nums2.length; i++) {
if (nums2[i] <= nums2[temp.peek()]) {
temp.add(i);
} else {
while(!temp.isEmpty() && nums2[temp.peek()] < nums2[i]) {
if (hashMap.containsKey(nums2[temp.peek()])) {
Integer index = hashMap.get(nums2[temp.peek()]);
res[index] = nums2[i];
}
temp.pop();
}
temp.add(i);
}
}
return res;
}
}
// 版本2
class Solution {
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums1.length; i++) {
map.put(nums1[i], i);
}
int[] res = new int[nums1.length];
Stack<Integer> stack = new Stack<>();
Arrays.fill(res, -1);
for (int i = 0; i < nums2.length; i++) {
while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]) {
int pre = nums2[stack.pop()];
if (map.containsKey(pre)) {
res[map.get(pre)] = nums2[i];
}
}
stack.push(i);
}
return res;
}
}
总结
今天开始单调栈类型的题目。
