双栈系列(计算表达式)

在这里插入图片描述

全部都在套用下面的模板

在这里插入图片描述

class Solution:
    op_priority = {'+': 0, '-': 0, '*': 1, '/': 1, '%': 1, '^': 2}

    def calculate(self, s: str) -> int:
        s = "(" + s.replace(" ", "").replace("(-", "(0-") + ")"
        n = len(s)
        # operators & numbers
        op_stack, num_stack = [], []

        i = 0
        while i < n:
            c = s[i]
            i += 1

            if c.isdigit():  # a number
                num = int(c)
                while i < n and s[i].isdigit():
                    num = num * 10 + int(s[i])
                    i += 1
                num_stack.append(num)
            elif c == '(':  # (
                op_stack.append(c)
            elif c == ')':  # calculate until see '('
                while op_stack and op_stack[-1] != '(':
                    self.calc(num_stack, op_stack)
                op_stack.pop()
            else:
                while op_stack and op_stack[-1] != '(':
                    prev_op = op_stack[-1]
                    if self.op_priority[prev_op] < self.op_priority[c]:
                        break
                    self.calc(num_stack, op_stack)
                op_stack.append(c)

        return num_stack[0]

    def calc(self, num_stack: list, op_stack: list) -> None:
        op, y, x = op_stack.pop(), num_stack.pop(), num_stack.pop() if num_stack else 0
        ans = 0
        if op == '+':
            ans = x + y
        elif op == '-':
            ans = x - y
        elif op == '*':
            ans = x * y
        elif op == '/':
            ans = x / y
        elif op == '%':
            ans = x % y
        elif op == '^':
            ans = pow(x, y)
        num_stack.append(int(ans))

在这里插入图片描述

class Solution:
    op_priority = {'+': 0, '-': 0, '*': 1, '/': 1, '%': 1, '^': 2}

    def calculate(self, s: str) -> int:
        s = "(" + s.replace(" ", "").replace("(-", "(0-").replace("(+", "(0+") + ")"
        n = len(s)
        # operators & numbers
        op_stack, num_stack = [], []

        i = 0
        while i < n:
            c = s[i]
            i += 1
            if c.isdigit():  # a number
                num = int(c)
                while i < n and s[i].isdigit():
                    num = num * 10 + int(s[i])
                    i += 1
                num_stack.append(num)
            elif c == '(':  # (
                op_stack.append(c)
            elif c == ')':  # calculate until see '('
                while op_stack and op_stack[-1] != '(':
                    self.calc(num_stack, op_stack)
                op_stack.pop()
            else:
                while op_stack and op_stack[-1] != '(':
                    prev_op = op_stack[-1]
                    if self.op_priority[prev_op] < self.op_priority[c]:
                        break
                    self.calc(num_stack, op_stack)
                op_stack.append(c)

        return num_stack[0]

    def calc(self, num_stack: list, op_stack: list) -> None:
        op, y, x = op_stack.pop(), num_stack.pop(), num_stack.pop() if num_stack else 0
        ans = 0
        if op == '+':
            ans = x + y
        elif op == '-':
            ans = x - y
        elif op == '*':
            ans = x * y
        elif op == '/':
            ans = int(x / y)
        elif op == '%':
            ans = x % y
        elif op == '^':
            ans = pow(x, y)
        num_stack.append(int(ans))

在这里插入图片描述
在这里插入图片描述

class Solution:
    op_priority = {'+': 0, '-': 0, '*': 1, '/': 1, '%': 1, '^': 2}
    def clumsy(self, N: int) -> int:
        ops = ["*", "/", "+", "-"]
        s = ""
        j = 0
        for i in range(N,0,-1):
            s = s + str(i)
            if i != 1:
                s = s + ops[j%4]
                j = j + 1
        return self.calculate(s)

    def calculate(self, s: str) -> int:
        s = "(" + s.replace(" ", "").replace("(-", "(0-").replace("(+", "(0+") + ")"
        n = len(s)
        # operators & numbers
        op_stack, num_stack = [], []

        i = 0
        while i < n:
            c = s[i]
            i += 1
            if c.isdigit():  # a number
                num = int(c)
                while i < n and s[i].isdigit():
                    num = num * 10 + int(s[i])
                    i += 1
                num_stack.append(num)
            elif c == '(':  # (
                op_stack.append(c)
            elif c == ')':  # calculate until see '('
                while op_stack and op_stack[-1] != '(':
                    self.calc(num_stack, op_stack)
                op_stack.pop()
            else:
                while op_stack and op_stack[-1] != '(':
                    prev_op = op_stack[-1]
                    if self.op_priority[prev_op] < self.op_priority[c]:
                        break
                    self.calc(num_stack, op_stack)
                op_stack.append(c)

        return num_stack[0]

    def calc(self, num_stack: list, op_stack: list) -> None:
        op, y, x = op_stack.pop(), num_stack.pop(), num_stack.pop() if num_stack else 0
        ans = 0
        if op == '+':
            ans = x + y
        elif op == '-':
            ans = x - y
        elif op == '*':
            ans = x * y
        elif op == '/':
            ans = int(x / y)
        elif op == '%':
            ans = x % y
        elif op == '^':
            ans = pow(x, y)
        num_stack.append(int(ans))

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用 C++ 语言实现的双栈表达式求值代码: ```cpp #include <iostream> #include <stack> #include <string> using namespace std; int calculate(string expression) { stack<char> operator_stack; stack<int> operand_stack; unordered_map<char, int> precedence = {{'+', 1}, {'-', 1}, {'*', 2}, {'/', 2}}; auto evaluate = [&]() { char op = operator_stack.top(); operator_stack.pop(); int operand2 = operand_stack.top(); operand_stack.pop(); int operand1 = operand_stack.top(); operand_stack.pop(); int result; switch (op) { case '+': result = operand1 + operand2; break; case '-': result = operand1 - operand2; break; case '*': result = operand1 * operand2; break; case '/': result = operand1 / operand2; break; } operand_stack.push(result); }; for (char token : expression) { if (isdigit(token)) { operand_stack.push(token - '0'); } else if (token == '+' || token == '-' || token == '*' || token == '/') { while (!operator_stack.empty() && operator_stack.top() != '(' && precedence[token] <= precedence[operator_stack.top()]) { evaluate(); } operator_stack.push(token); } else if (token == '(') { operator_stack.push(token); } else if (token == ')') { while (operator_stack.top() != '(') { evaluate(); } operator_stack.pop(); } } while (!operator_stack.empty()) { evaluate(); } return operand_stack.top(); } int main() { string expression = "3*(4+5)-2/(7-3)"; int result = calculate(expression); cout << "The result of " << expression << " is " << result << endl; return 0; } ``` 这个程序使用了 STL 中的 stack 容器来实现操作符栈和操作数栈。我们还使用了一个无序映射 unordered_map 来存储不同操作符的优先级。在程序的主函数中,我们调用 calculate 函数来计算表达式的值。在 calculate 函数内部,我们定义了一个 lambda 表达式 evaluate,用于弹出操作符栈顶的操作符并弹出操作数栈顶的两个操作数,计算结果并将结果压入操作数栈。然后我们循环扫描表达式的每个字符,如果是数字,就将其压入操作数栈;如果是操作符,就比较其与操作符栈顶的运算符优先级,如果该运算符优先级低于栈顶运算符,则将栈顶运算符弹出并弹出操作数栈顶的两个操作数,计算结果并将结果压入操作数栈,直到该运算符优先级大于栈顶运算符或者栈为空时,将该运算符压入栈中;如果是左括号,就将其压入操作符栈;如果是右括号,就依次弹出操作符栈顶的操作符并弹出操作数栈顶的两个操作数,计算结果并将结果压入操作数栈,直到遇到左括号。最后,我们处理剩余的操作符,直到操作符栈为空,最终操作数栈中仅有一个数,即为表达式的值。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值