Leetcode150, 239, 347

Leetcode 150

题目：逆波兰表达式

学习资料：代码随想录

初始思路

• 模拟计算过程，遇到数字放入栈中，当遇到运算符时，将栈顶前两个出栈并计算，然后将结果进栈

学习后

• 可以利用eval函数更简便的写法
• f' '可以将表达式赋值

实现过程

 思路一

        stack = []

        for i in tokens:
            if i == "+":
                a = stack.pop()
                b = stack.pop()
                c = b + a
                stack.append(c)
            elif i == "-":
                a = stack.pop()
                b = stack.pop()
                c = b - a
                stack.append(c)
            elif i == "*":
                a = stack.pop()
                b = stack.pop()
                c = b * a
                stack.append(c)
            elif i == "/":
                a = stack.pop()
                b = stack.pop()
                c = int(b / a)
                stack.append(c)
                
            else:

                stack.append(int(i))

        return stack.pop()

思路二

stack = []
        for item in tokens:
            if item not in {"+", "-", "*", "/"}:
                stack.append(item)
            else:
                first_num, second_num = stack.pop(), stack.pop()
                stack.append(
                    int(eval(f'{second_num} {item} {first_num}'))   # 第一个出来的在运算符后面
                )
        return int(stack.pop()) # 如果一开始只有一个数，那么会是字符串形式的

---

Leetcode 239

题目：滑动窗口最大值

学习资料：代码随想录

 初始思路

• 队列，取max，超时；
• 最大顶堆，移动窗口时无法移除元素

学习后

• 自定义的单调队列：实现push，pop，getMax，使得队列的出口元素为候选最大值
• push：为了满足单调，push的时候要和前面的元素，即队列尾部的元素比较，如果将要push的元素比队列中的尾部元素大，将尾部元素从右侧入口出移除。注意：这里实际是一个双向队列，这里移除时要从右侧尾部入口处移除
• pop：当滑动窗口移除的元素正好等于队列左侧最大的元素时，将队列左侧元素，从左侧移除；其余滑动窗口移除的元素在push的时候其实就已经移除了。
• 单调队列实际上是在维护可能成为最大值的元素，而不是滑动窗口中的元素

实现过程

class Myqueue:
    def __init__(self):
        self.queue = []
    def push(self, value):
        while self.queue and value > self.queue[-1]:
            #小于的都移除；从后比较；只有这样才能保证是单调的
            self.queue.pop()
        self.queue.append(value)
    
    def pop(self, value):
        #queue[0]是保存最大的，滑动窗口移动的时候，如果是最大的元素，那么就pop出去
        if self.queue and value == self.queue[0]:

            self.queue.pop(0)
    
    def getMax(self):
        return self.queue[0]


class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        q = Myqueue()
        re = []
        for i in range(k):
            q.push(nums[i])
        re.append(q.getMax())
        for i in range(k, len(nums)):

            q.pop(nums[i-k])

            q.push(nums[i])
            re.append(q.getMax())
        
        return re

---

Leetcode347

题目：前k个高频元素

学习资料：代码随想录

 初始思路

• 先利用dict统计频率；然后排序
• 时间复杂度高

学习后

• 排序的时候其实只维护前k就好，使用优先级队列数据结构；本质就是维护k个元素的堆
• 大顶堆还是小顶堆？
  • 如果使用大顶堆，每次添加元素后，都要pop元素，pop顶部元素为最大的，反而将大值给移除了，目的是维护前k个高频，使用大顶堆却变成了前k个低频
  • 使用小顶堆
• 时间复杂度，每次加入一个元素维护复杂度logk，所以为nlogk

实现过程

• 使用heapq；heapq就是最小堆
• 如果heappush的是元组，那么会以第一个元素为priority排序
• ps：最大堆的数据结构可以自己实现

import heapq
class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        dict_ = dict()
        for i in range(len(nums)):
            dict_[nums[i]] = dict_.get(nums[i],0) + 1
        
        pri_queue = []

        for key, value in dict_.items():
            #heapq默认将元组中第一个元素最为priority
            heapq.heappush(pri_queue, (value,key))

            if len(pri_queue) > k:
                heapq.heappop(pri_queue)

        re = []
        for i in range(k-1,-1,-1):
            re.append(pri_queue[i][1])
        return re