【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，我们可以使用单调栈来解决这个问题。
- 把第一个元素 nums2[1] 放入栈，
- 对于第二个元素 nums2[2]，如果 nums2[2] > nums2[1]，那么我们就找到了 nums2[1] 的下一个更大元素 nums2[2]，此时就可以把 nums2[1] 出栈并把 nums2[2] 入栈；如果 nums2[2] <= nums2[1]，我们就仅把 nums2[2] 入栈。
- 对于第三个元素 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))