leetcode 496/503 下一个更大的元素1,2（单调栈解法）

【leetcode 496 题目】

给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
    对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
    对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。
示例 2:

输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
    对于num1中的数字2，第二个数组中的下一个较大数字是3。
    对于num1中的数字4，第二个数组中没有下一个更大的数字，因此输出 -1。
注意:

nums1和nums2中所有元素是唯一的。
nums1和nums2 的数组大小都不超过1000。

【leetcode 503 题目】

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

示例 1:

输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
注意: 输入数组的长度不会超过 10000。

【分析】

从题目中我们可以看出，496题和503题都是寻找每一个元素的下一个更大的元素，不同的是：在496题中，只需要遍历数组一遍，而且数组中的元素是不可重复的，而503题中数组是循环数组，意味着可以循环遍历，而且题目中没有指出数组元素不可重复。

我在分析这两个题目的时候都使用了单调栈的方法，下面是具体的分析过程。

【496题】

总体思想：忽略数组 nums1，先对将 nums2 中的每一个元素，求出其下一个更大的元素。随后对于将这些答案放入哈希映射（HashMap）中，再遍历数组 nums1，并直接找出答案。对于 nums2，我们可以使用单调栈来解决这个问题。

1. 把第一个元素 nums2[1] 放入栈，
2. 对于第二个元素 nums2[2]，如果 nums2[2] > nums2[1]，那么我们就找到了 nums2[1] 的下一个更大元素 nums2[2]，此时就可以把 nums2[1] 出栈并把 nums2[2] 入栈；如果 nums2[2] <= nums2[1]，我们就仅把 nums2[2] 入栈。
3. 对于第三个元素 nums2[3]，此时栈中有若干个元素，那么所有比 nums2[3] 小的元素都找到了下一个更大元素（即 nums2[3]），因此可以出栈，在这之后，我们将 nums2[3] 入栈，以此类推。

可以发现，我们维护了一个单调栈，栈中的元素从栈顶到栈底是单调不降的。当我们遇到一个新的元素 nums2[i] 时，我们判断栈顶元素是否小于 nums2[i]，如果是，那么栈顶元素的下一个更大元素即为 nums2[i]，我们将栈顶元素出栈。重复这一操作，直到栈为空或者栈顶元素大于 nums2[i]。此时我们将 nums2[i] 入栈，保持栈的单调性，并对接下来的 nums2[i + 1], nums2[i + 2] ... 执行同样的操作。那么，由于数组中的元素不重复，则不同元素对应的下一个更大元素都可以在hash表中寻找到。

【503题】

总体思想：和496题相似，维护一个单调栈（单调递增栈），同时创建一个hash表，但是在hash表中存放的是索引值，这样就可以避免重复元素导致的结果错误。

重要一点：需要将两个相同的数组拼接成一个数组，相当于循环数组了。

【Python代码：496】

class Solution:
    #暴力解法 256m
    def nextGreaterElement1(self, nums1: list, nums2: list) -> list:
        nums1_length = len(nums1)
        nums2_length = len(nums2)
        result = []
        for i in range(nums1_length):
            for j in range(nums2_length):
                if nums2[j] == nums1[i]:
                    k = j + 1
                    flag = 0
                    while k < nums2_length:
                        if nums2[k] > nums1[i]:
                            flag = 1
                            result.append(nums2[k])
                            break
                        else:
                            k += 1
                    if flag == 0:
                        result.append(-1)
                    break
        return result
    #单调栈解法 56m
    def nextGreaterElement(self, nums1: list, nums2: list) -> list:
        hash_nums2 = {}
        stack_nums2 = []
        result = []
        stack_nums2.append(nums2[0])
        if len(nums1) == 0 or len(nums2) == 0:
            return result
        for i in range(1,len(nums2)): #维护一个单调递增栈，当前元素大于栈顶元素时将键值对存入hash表中，将栈顶元素出栈，并将当前元素入栈，如果当前元素小于栈顶元素则将当前元素入栈
            if nums2[i] <= stack_nums2[-1]:
                stack_nums2.append(nums2[i])
            else:
                while len(stack_nums2) != 0 and nums2[i] > stack_nums2[-1]:
                    hash_nums2[stack_nums2[-1]]=nums2[i]
                    stack_nums2.pop()
                stack_nums2.append(nums2[i])
        if len(stack_nums2) != 0:
            for i in stack_nums2:
                hash_nums2[i] = -1
        for i in nums1:
            result.append(hash_nums2[i])
        return result

s = Solution()
nums1 = [4,1,2]

nums2 = [1,3,4,2]
print(s.nextGreaterElement(nums1,nums2))

 

【Python代码 503】

class Solution:
    def nextGreaterElements(self, nums: list) -> list:
        nums_new = []
        i = 0
        while i < 2:
            for j in nums:
                nums_new.append(j)
            i += 1
        hash_nums = {}
        stack_nums = []
        index_nums = []
        result = []
        stack_nums.append(nums[0])
        index_nums.append(0)
        for i in range(1,len(nums_new)):
            if nums_new[i] <= stack_nums[-1]:
                stack_nums.append(nums_new[i])
                index_nums.append(i)
            else:
                while len(stack_nums) != 0 and nums_new[i] > stack_nums[-1]:
                    hash_nums[index_nums[-1]] = nums_new[i]
                    stack_nums.pop()
                    index_nums.pop()
                stack_nums.append(nums_new[i])
                index_nums.append(i)
        if len(index_nums) != 0:
            for i in index_nums:
                hash_nums[i] = -1
        for i in range(len(nums)):
             result.append(hash_nums[i])
        return result


s = Solution()
nums = [100,1,11,1,120,111,123,1,-1,-100]
print(s.nextGreaterElements(nums))