leetcode题目及答案python_Leetcode之单调栈题目解答----基于python3

一、单调栈

顾名思义，单调栈就是栈里面存放的数据都是有序的，所以可以分为单调递增栈和单调递减栈两种。

单调递增栈就是从栈底到栈顶是从大到小。

单调递减栈就是从栈底到栈顶是从小到大。

基于它的特性，其十分适合处理列表中相邻元素比较大小相关的题目，这里以python3为例，给出LeetCode中的几个例子。代码均是博主自己写的，如有可提升效率之处请留言讨论。

题目主要有:

第42题—接雨水

第84题—柱状图中最大的矩形

第496题—下一个更大的元素I

第739题—每日温度

二、LeetCode例子

2.1 第42题—接雨水

2.1.1 题目描述

42.接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

输入: [0,1,0,2,1,0,1,3,2,1,2,1]

输出: 6

2.1.2 思路和解答

首先，显然，至少List的长度为3，否则雨水为0。

其次，显然，需要初始栈，若List中列表头部的元素递增，则存不住雨水，舍去，直到可以初始。

最后，定义从栈底到栈顶单调减的单调栈，相当于每次迭代对三个元素进行计算雨水，分别是高1，低，高2，则可以囤积的雨水为(min(高2，高1)-低)*宽。

class Solution:

def trap(self, height):

# 使用从栈底到栈顶单调减的单调栈

if len(height) < 3 : return 0

for i in range(len(height)-1):

if height[i] <= height[i+1]:

continue

else:

stack = [i, i + 1]

break

if i == len(height)-1: return 0

rain_v = 0

for index in range(i+2, len(height)):

h = height[index]

while len(stack) > 1 and h > height[stack[-1]]:

current_index = stack[-1]

stack.pop(-1)

H = min(h, height[stack[-1]]) - height[current_index]

W = index - stack[-1] - 1

rain_v += H * W

if height[stack[-1]] < h: stack.pop(-1)

stack.append(index)

return rain_v

2.2 第84题—柱状图中最大的矩形

2.2.1 题目描述

84. 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3].

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

输入: [2,1,5,6,2,3]

输出: 10

2.2.2 思路和解答

使用单调栈，从栈低到栈顶单调增，如果不符合，则弹出，并计算面积。

单调栈中保存的是当前元素的索引index。

单调栈中先入栈-1,以保存当前索引的"左边界"，即不大于当前值的最大索引

面积的宽度为 当前index -左边界 + 1.

class Solution:

def largestRectangleArea(self, heights):

stack = [-1] #单调栈，从栈底到栈顶单调增

heights.append(-1) #List末尾增加-1,保证所有元素都可以出栈

maxarea = 0

for index,h in enumerate(heights):

i = 0

while len(stack) > 0 and h < heights[stack[-1]]:

height = heights[stack[-1]]

width = index - stack[-2] - 1

stack.pop(-1) #弹出栈顶

current_area = width * height

if maxarea < current_area:

maxarea = current_area

stack.append(index)

return maxarea

2.3 第496题—下一个更大的元素I

2.3.1 题目描述

496. 下一个更大元素 I

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

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

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].

输出: [-1,3,-1]

解释:

对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。

对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。

对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。

2.3.2 思路和解答

典型的单调栈可解决问题，构造单调增的单调栈即可。

class Solution:

def nextGreaterElement(self, nums1, nums2):

# 构造单调增的单调栈

results = [-1] * len(nums1)

stack = []

for index, num2 in enumerate(nums2):

while stack != [] and num2 > stack[-1]:

peak = stack[-1]

stack.pop(-1)

if peak in nums1:

results[nums1.index(peak)] = num2

stack.append(num2)

return results

2.4 第739题—每日温度

2.4.1 题目描述

739. 每日温度

请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

2.4.2 思路和解答

定义从栈底到栈顶单调减的单调栈.

栈内保存温度数据的索引index.

若不满足，则出栈，出栈时，意味着其需要等待当前index-出栈index天.

class Solution:

def dailyTemperatures(self, T: List[int]) -> List[int]:

# 使用从栈底到栈顶单调减的单调栈

stack = []

result = [0] * len(T)

for index, t in enumerate(T):

while stack!=[] and T[stack[-1]] < t:

i = stack[-1]

stack.pop(-1)

result[i] = index - i

stack.append(index)

return result