代码随想录算法训练营第十一天｜150. 逆波兰表达式求值、239. 滑动窗口最大值、347. 前K个高频元素

主要学了一些怎么自定义堆存放数据结构的定义和自定义比较方法

150. 逆波兰表达式求值

leetcode 150. 逆波兰表达式求值
代码随想录

这道题的进阶应该是我们普通计算器，要自己去判断符号的优先级，逆波兰表达式已经给处理好了。

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        # 遇到数字入栈，遇到符号出栈两次，做运算
        stack = []
        op = ["+", "-", "*", "/"]
        def calculate(num1,num2,op):
            # print(num1,num2,op)
            if op == "+":
                return num1 + num2
            elif op == "-":
                return num1 - num2
            elif op == "*":
                return num1 * num2
            elif op == "/":
                return int(num1/num2)
        
        for item in tokens:
            if item in op:
                num2 = stack.pop()
                num1 = stack.pop()
                # print(num1,num2)
                stack.append(calculate(num1, num2, item))
            else:
                stack.append(int(item))
            # print(stack)
        return stack.pop()

239. 滑动窗口最大值

leetcode 239. 滑动窗口最大值
代码随想录

和代码随想录的单调栈的方法不太一样，修改了大顶堆的比较方法，能够实现该被删除的元素统统出堆。

import heapq
class Task:
    def __init__(self, priority, order):
        self.priority = priority
        self.order = order

    def __lt__(self, other):
        # 实现大顶堆：优先级高的在前，优先级相同时，顺序小的在前
        if self.priority == other.priority:
            return self.order < other.order  # order小的优先
        return self.priority > other.priority  # 大顶堆，优先级大的优先

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        priority_queue = []
        res = []
        for i in range(k):
            heapq.heappush(priority_queue,Task(nums[i],i))
        res.append(priority_queue[0].priority)
        for i in range(k, len(nums)):
            heapq.heappush(priority_queue,Task(nums[i],i))
            while (priority_queue[0].order < (i - k + 1)):
                heapq.heappop(priority_queue)
            res.append(priority_queue[0].priority)
        return res

347. 前K个高频元素

leetcode 347. 前 K 个高频元素
代码随想录

其实python的collections有一个Counterhhh

import heapq
class Task:
    def __init__(self, freq, number):
        self.freq = freq
        self.number = number

    def __lt__(self, other):
        return self.freq < other.freq  # 小顶堆

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        # 小顶堆，保持堆里面只有k个元素
        priorityQue = []
        # 统计词频
        freqDict = dict()
        for item in nums:
            if item not in freqDict:
                freqDict[item] = 1
            else:
                freqDict[item] += 1
        # print(freqDict)
        for number, freq in freqDict.items():
            # 这里可以优化，可以直接入堆，但是当元素大于k个之后就一定要删除一个元素
            # if len(priorityQue) < k:
            #     heapq.heappush(priorityQue,Task(freq, number))
            # else:
            #     if priorityQue[0].freq < freq:
            #         heapq.heappop(priorityQue)
            #         heapq.heappush(priorityQue,Task(freq, number))
            heapq.heappush(priorityQue, Task(freq,number))
            if len(priorityQue) > k:
                heapq.heappop(priorityQue)
        res = []
        while len(priorityQue) != 0:
            res.append(heappop(priorityQue).number)
        return res[::-1]