【leecode刷题】中级算法-其他_operator operand operand算法题-CSDN博客

本文深入探讨了逆波兰表达式的求值算法，解析了如何使用栈来处理算术表达式，并实现了一个任务调度器算法，旨在解决在有限冷却时间内任务的最优执行顺序问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、逆波兰表达式求值

在这里插入图片描述

class Solution(object):
    def evalRPN(self, tokens):
        """
        :type tokens: List[str]
        :rtype: int
        """
        class Stack:
            def __init__(self):
                self.items = []

            def isEmpty(self):
                return self.items == []

            def push(self, item):
                self.items.append(item)

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

            def peek(self):
                return self.items[len(self.items)-1]

            def size(self):
                return len(self.items)

        def postfixEval(tokens):
            operatorList = ["+","-","*","/"]
            operandStack = Stack()
            for token in tokens:
                if token not in operatorList:
                    operandStack.push(int(token))
                else:
                    operand2 = operandStack.pop()
                    operand1 = operandStack.pop()
                    result = doMath(token,operand1,operand2)
                    operandStack.push(result)
            result = int(operandStack.pop())
            return result

        def doMath(op, op1, op2):
            if op == "*":
                return op1 * op2
            elif op == "/":
                return op1 / op2
            elif op == "+":
                return op1 + op2
            else:
                return op1 - op2

        return postfixEval(tokens)

2、多数元素

在这里插入图片描述

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        length = len(nums)
        th = length/2
        count = {}
        num = 0
        for i in nums:
            if i not in count:
                count[i] = 1
            else:
                count[i] = count[i]+1
            num = num+1
            if num > th:
                for j,k in count.items():
                    if k>th:
                        return j

3、任务调度器

在这里插入图片描述

class Solution(object):
    def leastInterval(self, tasks, n):
        """
        :type tasks: List[str]
        :type n: int
        :rtype: int
        """
        length = len(tasks)
        if length <= 1:
            return length

        # 用于记录每个任务出现的次数
        task_map = dict()
        for task in tasks:
            task_map[task] = task_map.get(task, 0) + 1
        # 按任务出现的次数从大到小排序
        task_sort = sorted(task_map.items(), key=lambda x: x[1], reverse=True)

        # 出现最多次任务的次数
        max_task_count = task_sort[0][1]
        # 至少需要的最短时间
        res = (max_task_count - 1) * (n + 1)

        for sort in task_sort:
            if sort[1] == max_task_count:
                res += 1

        # 如果结果比任务数量少，则返回总任务数
        return res if res >= length else length