一、栈

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems

1、115.最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

class MinStack:
    
    def __init__(self):
        self.nums = []

    def push(self, x: int):
        self.nums.append(x)

    def pop(self):
        return self.nums.pop()

    def top(self):
        return self.nums[-1]

    def getMin(self):
        nums_copy = self.nums.copy()
        nums_copy.sort()
        return nums_copy[0]

2、225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

class MyStack:
    
    def __init__(self):
        self.nums = []

    def push(self, x: int):
        self.nums.append(x)

    def pop(self):
        return self.nums.pop()

    def top(self):
        return self.nums[-1]

    def empty(self):
        try:
            self.nums[-1]
            return False
        except IndexError: 
            return True

3、496. 下一个更大元素 I

给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

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

扫描二维码关注公众号，回复： 12889062 查看本文章

自己的暴力解法哈哈哈哈

class Stack():
    def __init__(self):
        self.nums = []

    def pop(self):
        return self.nums.pop(0)

    def top(self):
        return self.nums[0]

    def push(self, x: int):
        self.nums.append(x)

    def init(self, list1):
        for i in list1:
            self.nums.append(i)
    
    def empty(self):
        try:
            self.nums[-1]
            return False
        except IndexError: 
            return True

class Solution:
    def compare(self, num, nums):
        s = Stack()
        s.init(nums)

        # 删除不相同元素，如果删除完则返回-1
        while num != s.top(): 
            try:
                s.pop()
            except IndexError:
                return -1

        # 检测大小，不小于则继续删除
        try:
            while not num < s.top():
                s.pop()
        except IndexError:
            return -1

        # 已找到返回元素
        return s.pop()

    def nextGreaterElement(self, nums1, nums2):
        nums = []
        for i in nums1:
            nums.append(self.compare(i, nums2))
        return nums

解法二：单调栈（不是太理解）

class Solution:
    def nextGreaterElement(self, nums2):
        stack = []
        idx_list = [-1] * len(nums2)

        # 倒序遍历
        for i in range(len(nums2)-1, -1, -1):
            # 栈不为空且列表2对应的数大于或等于栈出口数：栈弹出
            while stack and nums2[i] >= stack[-1]:
                stack.pop()

            # 若栈为空，idx_list[i] = -1； 否则idx_list[i] = stack[-1]
            idx_list[i] = -1 if not stack else stack[-1]
            
            # 栈压入nums2[i]
            stack.append(nums2[i])

        res = []
        for i in nums1:
            res.append(idx_list[nums2.index(i)])
        return res

什么是单调栈？

从名字上就听的出来，单调栈中存放的数据应该是有序的，所以单调栈也分为单调递增栈和单调递减栈

模拟单调栈的数据push和pop

现在有一组数10，3，7，4，12。从左到右依次入栈，则如果栈为空或入栈元素值小于栈顶元素值，则入栈；否则，如果入栈则会破坏栈的单调性，则需要把比入栈元素小的元素全部出栈。单调递减的栈反之。