代码随想录算法训练营day58 | 单调栈：739. 每日温度 ，496.下一个更大元素 I

739. 每日温度

暴力解法：O(N^2) 超时

class Solution(object):
    def dailyTemperatures(self, temperatures):
        """
        :type temperatures: List[int]
        :rtype: List[int]
        """
        for i in range(len(temperatures)):
            temp = i
            while temp < len(temperatures) and temperatures[i] >= temperatures[temp]:
                temp += 1
            if temp == len(temperatures):
                temperatures[i] = 0
                continue
            temperatures[i] = temp - i
        return temperatures

单调栈Trick：

• 通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)
• 单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是只需要遍历一次。

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        ans = [0]*len(temperatures)
        stack = [0]

        for i in range(len(temperatures)):
            #三种情况：
            if temperatures[i] <= temperatures[stack[-1]]:
                stack.append(i)
            else:
                while len(stack) > 0 and temperatures[i] > temperatures[stack[-1]]:
                    ans[stack[-1]] = i - stack[-1]
                    stack.pop()
                stack.append(i)
        
        return ans

496.下一个更大元素 I 

暴力解法：O(N^2)

class Solution(object):
    def nextGreaterElement(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        ans = [-1]*len(nums1)

        for i in range(len(nums1)):
            print('current number with index i is', nums1[i])
            for j in range(nums2.index(nums1[i])+1, len(nums2)):
                print('number with index j is', nums2[j])
                if nums2[j] > nums1[i]:
                    ans[i] = nums2[j]
                    print('yes')
                    break
                    
        return ans

单调栈解法：

• 递增栈 --> 找到右边第一个比自己大的元素
• 递减栈 --> 找到右边第一个比自己小的元素

• 三种情况：
  • 情况一：当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况：
    • 此时满足递增栈（栈头到栈底的顺序），所以直接入栈。
  • 情况二：当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况：
    • 如果相等的话，依然直接入栈，因为我们要求的是右边第一个比自己大的元素，而不是大于等于！
  • 情况三：当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况：
    • 如果入栈就不满足递增栈了，这也是找到右边第一个比自己大的元素的时候。
• 判断栈顶元素是否在nums1里出现过，（注意栈里的元素是nums2的元素），如果出现过，开始记录结果。

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        ans = [-1]*len(nums1)
        stack = [0] # 存放的是nums1元素对应在nums2里的index

        for i in range(len(nums2)):
            #递增栈
            if nums2[i] <= nums2[stack[-1]]:
                stack.append(i)
            else:
                while len(stack) > 0 and nums2[i] > nums2[stack[-1]]:
                    if nums2[stack[-1]] in nums1: #这里才是体现为什么上面stack存放的是nums1元素对应在nums2里的index
                        idx = nums1.index(nums2[stack[-1]])
                        ans[idx] = nums2[i]
                    stack.pop()    
                stack.append(i)
        
        return ans