Python中的堆栈

什么是堆栈？

堆栈（Stack）是计算机科学中的一种数据结构，它是一种线性的数据结构，具有“后进先出”（LIFO）的特点。类比一个物理上的堆栈，新放进去的东西永远放在堆栈的最顶端，而取出来的东西也只能从堆栈的最顶端取出来。

堆栈的应用场景

堆栈最典型的应用场景是函数的调用栈。在函数调用时，操作系统会为每一个函数开辟一定的内存单元用于保存函数的局部变量以及其他状态信息。每当函数被调用时，就会在栈中分配一定的内存用来保存函数的局部变量等。当函数返回时，这些保存的变量状态将从栈中弹出。

堆栈还可以应用于诸如算式求解、括号匹配、表达式转换等计算机程序问题。

Python如何实现堆栈？

Python中以列表形式实现堆栈，即使用列表的append()函数模拟入栈操作，使用pop()函数模拟出栈操作，示例代码如下：

# 创建一个空的堆栈
stack = []

# 入栈
stack.append(1)
stack.append(2)

# 出栈
print(stack.pop())  # 输出2
print(stack.pop())  # 输出1

# 如果堆栈已空
if not stack:
    print("堆栈已空")

使用堆栈解决问题

案例一：算式求解

堆栈在算式求解问题中也是十分常用的。下面演示一个使用堆栈求算式值的Python代码，此代码能够处理加、减、乘、除以及带括号的复杂算式：

def calc_formula(formula):
    """
    此函数可计算加、减、乘、除以及带括号的算式
    """
    # 存放数字的堆栈
    nums_stack = []
    # 存放运算符的堆栈
    op_stack = []
    # 处理字符串，遇到数字压入nums_stack，遇到运算符则判断是否弹出
    for ch in formula:
        if ch >= '0' and ch<= '9':
            nums_stack.append(float(ch))
        elif ch == '(':
            op_stack.append(ch)
        elif ch == ')':
            while op_stack and op_stack[-1] != '(':
                a = nums_stack.pop()
                b = nums_stack.pop()
                op = op_stack.pop()
                nums_stack.append(calculator(a, b, op))
            op_stack.pop()
        elif ch in '+-*/':
            while op_stack and op_stack[-1] in '+-*/' and get_priority(ch) <= get_priority(op_stack[-1]):
                a = nums_stack.pop()
                b = nums_stack.pop()
                op = op_stack.pop()
                nums_stack.append(calculator(a, b, op))
            op_stack.append(ch)
    while op_stack:
        a = nums_stack.pop()
        b = nums_stack.pop()
        op = op_stack.pop()
        nums_stack.append(calculator(a, b, op))
    return nums_stack[-1]

def get_priority(op):
    """
    获取运算符优先级
    """
    if op in '*/':
        return 1
    elif op in '+-':
        return 0

def calculator(a, b, op):
    """
    进行简单计算
    """
    if op == '+':
        return b + a
    elif op == '-':
        return b - a
    elif op == '*':
        return b * a
    elif op == '/':
        return b / a

# 使用示例
formula = '2 + ((3 + 4) * 5) - 6'
print(calc_formula(formula))  # 输出23.0

案例二：表达式转换

表达式转换即将一种形式的表达式转换成另一种形式的表达式，其中最常见的即中缀表达式转后缀表达式。下面演示一个简单的将中缀表达式转后缀表达式的Python代码：

def infix_to_postfix(infix_expression):
    """
    将中缀表达式转换为后缀表达式
    """
    # 运算符优先级
    precedence = {'*': 3, '/': 3, '+': 2, '-': 2, '(': 1}
    # 存储运算符的堆栈
    op_stack = []
    # 存储后缀表达式的列表
    postfix_expression = []
    # 分离出中缀表达式中的各项
    token_list = infix_expression.split()

    for token in token_list:
        # 如果是数字，将其加入后缀表达式
        if token.isnumeric():
            postfix_expression.append(token)
        # 如果是左括号，将其压入运算符堆栈
        elif token == '(':
            op_stack.append(token)
        # 如果是右括号，将堆栈中的运算符弹出，并加入后缀表达式
        elif token == ')':
            top_token = op_stack.pop()
            while top_token != '(':
                postfix_expression.append(top_token)
                top_token = op_stack.pop()
        # 如果是运算符，弹栈直至该运算符栈顶优先级低于该运算符
        else:
            while op_stack and precedence[op_stack[-1]] >= precedence[token]:
                postfix_expression.append(op_stack.pop())
            op_stack.append(token)

    while op_stack:
        postfix_expression.append(op_stack.pop())

    return ' '.join(postfix_expression)

# 使用示例
infix_expression = '2 + 3 * 4 - (5 * 6 + 7 * 8)'
postfix_expression = infix_to_postfix(infix_expression)
print(postfix_expression)  # 输出 2 3 4 * + 5 6 * 7 8 * + - 

总结

Python中以列表形式实现堆栈，append()函数模拟入栈操作，pop()函数模拟出栈操作。堆栈可应用于函数调用栈、算式求解、括号匹配、表达式转换等计算机程序问题。本文演示了两个使用堆栈解决问题的Python案例，可供参考和学习。