代码随想录算法训练营第62天｜单调栈part01｜739. 每日温度、 496.下一个更大元素 I

代码随想录算法训练营第62天｜单调栈part01｜739. 每日温度、 496.下一个更大元素 I

739. 每日温度

739. 每日温度

思路：

那有同学就问了，我怎么能想到用单调栈呢？ 什么时候用单调栈呢？

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

例如本题其实就是找找到一个元素右边第一个比自己大的元素，此时就应该想到用单调栈了。

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

更直白来说，就是用一个栈来记录我们遍历过的元素，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。

在使用单调栈的时候首先要明确如下几点：

1. 单调栈里存放的元素是什么？

单调栈里存放元素的下标i

2. 单调栈里元素是递增呢？ 还是递减呢？

注意以下讲解中，顺序的描述为 从栈头到栈底的顺序，因为单纯的说从左到右或者从前到后，不说栈头朝哪个方向的话，大家一定比较懵。

这里我们要使用递增循序（再强调一下是指从栈头到栈底的顺序），因为只有递增的时候，栈里要加入一个元素i的时候，才知道栈顶元素在数组中右面第一个比栈顶元素大的元素是i。

即：如果求一个元素右边第一个更大元素，单调栈就是递增的，如果求一个元素右边第一个更小元素，单调栈就是递减的。

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

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

当前遍历的元素 大于 时 就说明找到了第一个大于栈顶元素的值，result[栈顶元素index] = 当前元素index - 栈顶元素index 并把栈顶元素出栈，比较新的栈顶元素

当前遍历的元素 小于等于 时，就入栈，成为新的栈顶元素

遍历完成后，result就是最终结果（初始化时都为0）

代码：

python 自己做

class Solution(object):
    def dailyTemperatures(self, temperatures):
        """
        :type temperatures: List[int]
        :rtype: List[int]
        """
        answer = [0] * len(temperatures)

        stack = [0]
        
        for i in range(1, len(temperatures)):
            top_index = stack[-1]
            if temperatures[i] > temperatures[top_index]:
                while temperatures[i] > temperatures[top_index]:
                    answer[top_index] = i-top_index
                    stack.pop()
                    if len(stack) != 0:
                        top_index = stack[-1]
                    else:
                        break
                    
                stack.append(i)
            else:
                stack.append(i)

        return answer

496.下一个更大元素 I

496.下一个更大元素 I

思路：

自己做：

需要在 739. 每日温度 的基础上做一些处理，原本的result中存储的后面第一个更大元素的距离，本题是后面第一个更大的元素的值，需要经过一下转换；

还有就是nums1和nums2元素注意一一对应。

代码：

python

class Solution(object):
    def nextGreaterElement(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        answer1 = self.helper(nums2)

        answer = [-1] * len(nums1)
        print(answer)
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                if nums1[i] == nums2[j]:
                    if answer1[j] == -1:
                        answer[i] = -1
                    else:
                        index = j + answer1[j]
                        answer[i] = nums2[index]
                    break

        return answer       
    

    def helper(self, temperatures):
        answer = [-1] * len(temperatures)

        stack = [0]
        
        for i in range(1, len(temperatures)):
            top_index = stack[-1]
            if temperatures[i] > temperatures[top_index]:
                while temperatures[i] > temperatures[top_index]:
                    answer[top_index] = i-top_index
                    stack.pop()
                    if len(stack) != 0:
                        top_index = stack[-1]
                    else:
                        break
                    
                stack.append(i)
            else:
                stack.append(i)

        return answer

代码随想录

思路：

它是将num1转换为一集合，然后遍历nums2时，如果集合中存在这个值，就说明要更新result结果，为什么要用无序集合，因为底层是hash表，性能更高。