【LeetCode刷题】栈与队列

LC20: 括号配对

核心思路：匹配相同的相邻元素，做消除

• 利用栈后进先出的特点，遍历整个字符串，动态匹配相同的相邻元素

class Solution:
    def isValid(self, s: str) -> bool:
        par_dict = {"}":"{", "]": "[", ")": "("}
        in_stack = []

        # 后进先出，LIFO
        # 匹配消除
        for i in s:
            if i in par_dict.keys() and in_stack:
                if in_stack[-1] == par_dict[i]:
                    in_stack.pop()
                    continue
            in_stack.append(i)
        
        if not in_stack:
            return True
        else:
            return False

LC1047

误区：认为需要反复遍历字符串

• 实际上利用栈的性质，只要保持动态消除，就能够消除所有可能相邻的相同元素

class Solution:
    def removeDuplicates(self, s: str) -> str:
        in_stack = []
        for i in s:
            if in_stack and i == in_stack[-1]:
                in_stack.pop()
                continue
            in_stack.append(i)
        tmp = ''.join(in_stack)
        
        return tmp

LC150

根据列表中的元素，按照数学计算的规则与顺序，生成正确的计算表达式（利用括号）

• Reverse Polish Notation (RPN)：逆波兰表示法，运算符位于数字之后
• 此类表示本身能够实现从左至右线性计算
• 这道题的目的就是顺利解析这种表达式

• 若为数字，则直接存入栈中
• 每检索到一个运算符号元素
  • 就将存储的栈中的倒数两个元素进行相应运算
  • 将运算的两个元素从栈中去除
  • 重新存入运算结果到栈中

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        standard = ["+", "-", "*", "/"]
        in_stack = []
        for i in tokens:
            if i.isdigit():
                in_stack.append(int(i))
            elif len(i) >= 2 and i[0] == "-" and i[1:].isdigit():
                in_stack.append(-int(i[1:]))
            elif  i in standard and len(in_stack) >= 2:
                if i == "+":
                    tmp = in_stack[-1] + in_stack[-2]
                elif i == "-":
                    tmp = in_stack[-2] - in_stack[-1]
                elif i == "*":
                    tmp = in_stack[-2] * in_stack[-1]
                else:
                    tmp = int(in_stack[-2] / in_stack[-1])
                in_stack.pop()
                in_stack.pop()
                in_stack.append(tmp)
        return in_stack[0]

LC239：最大滑动窗口

一个由 nums 组成的整数数组，有一个大小为 k 的滑动窗口从数组的最左边移动到最右边。只能看到窗口中的 k 个数字。每次滑动窗口向右移动一个位置。
返回最大滑动窗口。

遍历

• 直接遍历整个数组，得到最大滑动窗口：超时
• 时间复杂度：$O(n\times k)$

核心思路：单调队列

• 需要一个队列结构，存放窗口内的k个数字，随着窗口的移动，队列也保持动态调整（每次窗口移动时，先移除部分元素的数值，再添加元素的数值）
• 这个队列中的元素保持从大到小的排序（单调递减队列），通过始终返回队列的第一个数值，得到最大的滑动窗口值
  • 无需维护窗口内的所有元素，只需要维护所有可能成为最大值的元素
  • pop：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不进行任何操作【窗口的更新】
  • push：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素为止

from collections import deque

class MyQueue:
    def __init__(self):
        # 直接使用List会超时
        self.queue = deque()

    # 比较当前需要弹出的数值是否为出口元素的数值
    # 即跟随着窗口的滑动调整队列
    def pop(self, value):
        if self.queue and value == self.queue[0]:
            self.queue.popleft()
    
    def push(self, value):
        # push的数值大于队列入口的元素，则将队列后端的数值弹出
        # 等于的情况可以保留，允许重复（因为不是同一个位置的值）
        while self.queue and value > self.queue[-1]:
            self.queue.pop()
        self.queue.append(value)

    def front(self):
        return self.queue[0]

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        que = MyQueue()
        result = []
        for i in range(k):
            que.push(nums[i])
        # 每k个数，存一个最大值
        result.append(que.front())
        for i in range(k, len(nums)):
            que.pop(nums[i-k])
            que.push(nums[i])
            result.append(que.front())
        return result

LC347

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

核心思路：优先级队列 or 小顶堆

• 堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。
  • 要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

难点/思考

• 之前的思路就是字典结构获取每个元素出现的次数，然后进行排序
• 但对于排序的复杂度认识不足，其实排序才是最具计算复杂度的部分

Python 堆：heapq

• heappush：按照堆的方式加入元素
• heapop：弹出堆中最小的值

import heapq

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        # 统计元素出现的频次
        tmp_dict = {}
        for i in nums:
            if i not in tmp_dict:
                tmp_dict[i] = 1
            else:
                tmp_dict[i] += 1
        
        # 构建小顶堆
        pri_que = []

        for key, freq in tmp_dict.items():
            heapq.heappush(pri_que, (freq, key))
            if len(pri_que) > k:
                # 删除具有最小值的元素
                heapq.heappop(pri_que)
        
        result = [0] * k
        for i in range(k-1, -1, -1):
            result[i] = heapq.heappop(pri_que)[1]

        return result