利用栈求表达式的值 能够完成加减乘除以及带括号的四则混合运算

可以使用栈来求解表达式的值，包括加减乘除以及带括号的四则混合运算。以下是具体的实现步骤：

1. 创建两个栈，一个用于存储操作数，一个用于存储操作符。
2. 从左到右遍历表达式中的每个字符。
3. 如果当前字符是数字，则将其转换为操作数并压入操作数栈中。
4. 如果当前字符是操作符，则将其压入操作符栈中。
5. 如果当前字符是右括号，则从操作数栈和操作符栈中依次弹出操作数和操作符，直到遇到左括号为止，然后将计算结果压入操作数栈中。
6. 遍历完表达式后，将操作符栈中剩余的操作符依次弹出，并从操作数栈中弹出两个操作数进行计算，并将计算结果压入操作数栈中。
7. 最后，操作数栈中剩下的唯一元素就是表达式的计算结果。

以下是使用栈来求解表达式的值的示例代码：

def eval_expr(s):
    num_stack = []
    op_stack = []
    i = 0
    while i < len(s):
        if s[i].isdigit():
            j = i
            while j < len(s) and s[j].isdigit():
                j += 1
            num_stack.append(int(s[i:j]))
            i = j
        elif s[i] in '+-*/':
            while op_stack and precedence(op_stack[-1]) >= precedence(s[i]):
                op = op_stack.pop()
                b = num_stack.pop()
                a = num_stack.pop()
                num_stack.append(apply_op(a, b, op))
            op_stack.append(s[i])
            i += 1
        elif s[i] == '(':
            op_stack.append(s[i])
            i += 1
        elif s[i] == ')':
            while op_stack[-1] != '(':
                op = op_stack.pop()
                b = num_stack.pop()
                a = num_stack.pop()
                num_stack.append(apply_op(a, b, op))
            op_stack.pop()
            i += 1
        else:
            i += 1

    while op_stack:
        op = op_stack.pop()
        b = num_stack.pop()
        a = num_stack.pop()
        num_stack.append(apply_op(a, b, op))

    return num_stack.pop()

def precedence(op):
    if op in '+-':
        return 1
    elif op in '*/':
        return 2
    else:
        return 0

def apply_op(a, b, op):
    if op == '+':
        return a + b
    elif op == '-':
        return a - b
    elif op == '*':
        return a * b
    elif op == '/':
        return a // b

print(eval_expr('(1+2)*(3+4)')) # expected output: 21
print(eval_expr('1+2*3-4/2')) # expected output: 5

在这个示例代码中，我们使用了一个 Python 列表作为栈，将整数和操作符压入栈中，然后在遇到操作符时弹出栈顶的两个操作数，并根据操作符进行计算，并将计算结果再次压入栈中。在遇到右括号时，我们从操作数栈和操作符栈中依次弹出操作数和操作符，直到遇到左括号为止，然后将计算结果压入操作数栈中。最后，当表达式遍历完毕时，栈中只剩下一个元素，这个元素就是表达式的计算结果。