刷题日记(10/60)

150 逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。

from operator import add,sub,mul
def div(x,y):
            return int(x/y) if x*y>0 else -(abs(x)//abs(y))
class Solution(object):
    op_map = {'+': add,'-': sub,'*': mul,'/': div}

    def evalRPN(self, tokens):
        """
        :type tokens: List[str]
        :rtype: int
        """
        stack = []
        for token in tokens:
            if token in self.op_map:
                op1 = stack.pop()
                op2 = stack.pop()
                operation = self.op_map[token]
                stack.append(operation(op2,op1))
            else:
                stack.append(int(token))
        return stack.pop()
                

总结：用到了dict,将四个符号对应操作，然后通过self.op_map[token]来对应操作

239 滑动窗口最大值

from collections import deque

class MyQueue: #定义一个从大到小的单调队列
    def __init__(self):
        self.queue= deque()
    def pop(self,value):#如果队列不为空，且value等于队列最大（最左边）出口的元素，则弹出最左边的
        while self.queue and value == self.queue[0]:
            self.queue.popleft()
    def push(self,value):#如果队列不为空，且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(object):
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        que = MyQueue()
        result = []
        for i in range(k):
            que.push(nums[i])
        result.append(que.front()) # 记前k个元素的最大值
        for i in range(k,len(nums)):
            que.pop(nums[i-k])  #滑动窗口移除前面的最大元素
            que.push(nums[i])  #华东长裤加入最后面的元素
            result.append(que.front()) #记录相应最大值
        return result

本题还没有弄的特别清楚，待续

347 前k个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

import heapq
class Solution(object):
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        map_ = {}#nums[i]对应出现的次数
        for i in range (len(nums)):
            map_[nums[i]] = map_.get(nums[i],0)+1

        #定义一个小顶堆，大小为k
        pri_que = []
        for key, freq in map_.items():
            heapq.heappush(pri_que, (freq, key))
            if len(pri_que) > k: #如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                heapq.heappop(pri_que)
        
        #找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        result = [0] * k
        for i in range(k-1, -1, -1):
            result[i] = heapq.heappop(pri_que)[1]
        return result

总结：本题用到了堆的知识，值得好好总结