40、深入理解相互递归：算术表达式求值的奥秘

Python

于 2025-10-28 12:57:57 发布

阅读量26

点赞数

CC 4.0 BY-SA版权

分类专栏： Python编程入门精要文章标签：相互递归算术表达式求值递归

本文链接：https://blog.youkuaiyun.com/python/article/details/154386989

Python编程入门精要专栏收录该内容

47 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

深入理解相互递归：算术表达式求值的奥秘

在编程的世界里，递归是一种强大的技术，它允许函数调用自身来解决更简单的子问题。然而，有一种更为高级的递归形式——相互递归，在某些复杂问题的解决中发挥着关键作用。本文将深入探讨相互递归在算术表达式求值中的应用，通过详细的示例和代码分析，带您领略这一技术的魅力。

相互递归简介

在之前的递归示例中，通常是一个函数调用自身来解决更简单的问题。而相互递归则是一组协作的函数或方法以递归的方式相互调用。这种技术比简单递归更为复杂，但在处理一些复杂问题时却非常有效。

算术表达式求值问题

我们的目标是编写一个程序，能够计算诸如 3+4*5 、 (3+4)*5 、 1-(2-(3-(4-5))) 等算术表达式的值。这个问题的复杂性在于运算符的优先级（ * 和 / 的优先级高于 + 和 - ）以及括号的使用，括号可以用来分组子表达式。

语法图的作用

为了更好地理解和处理这些表达式，我们使用语法图来描述表达式的语法结构。以表达式 3+4*5 为例，通过语法图的引导，我们可以将表达式逐步分解为项（term）和因子（factor）：
1. 进入表达式语法图，箭头直接指向项，没有其他选择。
2. 进入项语法图，箭头指向因子，同样没有选择。
3. 进入因子图，有两个选择：跟随顶部分支或底部分支。由于第一个输入令牌是数字 3 而不是 ( ，所以跟随底部分支。
4. 接受输入令牌，因为它与数字匹配。此时未处理的输入变为 +4*5 。
5. 跟随箭头从数字到因子的末尾，就像函数调用一样，回溯到项图中因子元素的末尾。
6. 此时有另一个选择：在项图中循环或退出。下一个输入令牌是 + ，它与循环所需的 * 或 / 都不匹配，所以退出，返回到表达式。
7. 再次有选择：循环或退出。现在 + 与循环中的一个选择匹配，接受输入中的 + 并返回到项元素。剩余的输入是 4*5 。

通过这种方式，表达式被分解为一系列由 + 或 - 分隔的项，每个项又被分解为一系列由 * 或 / 分隔的因子，每个因子要么是带括号的表达式，要么是数字。我们可以将这种分解表示为语法树，语法树准确地表示了应该首先执行哪些操作。

实现表达式求值的代码

为了计算表达式的值，我们实现了三个相互递归的函数： expression 、 term 和 factor 。

def expression(tokens):
    value = term(tokens)
    done = False
    while not done and len(tokens) > 0:
        next = tokens[0]
        if next == "+" or next == "-":
            tokens.pop(0)  # 丢弃 "+" 或 "-"
            value2 = term(tokens)
            if next == "+":
                value = value + value2
            else:
                value = value - value2
        else:
            done = True
    return value

def term(tokens):
    value = factor(tokens)
    done = False
    while not done and len(tokens) > 0:
        next = tokens[0]
        if next == "*" or next == "/":
            tokens.pop(0)
            value2 = factor(tokens)
            if next == "*":
                value = value * value2
            else:
                value = value / value2
        else:
            done = True
    return value

def factor(tokens):
    next = tokens.pop(0)
    if next == "(":
        value = expression(tokens)
        tokens.pop(0)  # 丢弃 ")"
    else:
        value = next
    return value

def tokenize(inputLine):
    result = []
    i = 0
    while i < len(inputLine):
        if inputLine[i].isdigit():
            j = i + 1
            while j < len(inputLine) and inputLine[j].isdigit():
                j = j + 1
            result.append(int(inputLine[i:j]))
            i = j
        else:
            result.append(inputLine[i])
            i = i + 1
    return result

def main():
    expr = input("Enter an expression: ")
    tokens = tokenize(expr)
    value = expression(tokens)
    print(expr + "=" + str(value))

if __name__ == "__main__":
    main()

代码分析

expression 函数 ：首先调用 term 函数获取表达式的第一个项的值，然后检查下一个输入令牌是否为 + 或 - 。如果是，则再次调用 term 函数并进行相应的加法或减法运算。
term 函数 ：调用 factor 函数获取因子的值，并根据 * 或 / 进行乘法或除法运算。
factor 函数 ：检查下一个令牌是否为 ( 。如果是，则递归调用 expression 函数处理括号内的子表达式；否则，令牌必须是一个数字，直接返回该数字。

相互递归的示例

以表达式 (3+4)*5 为例，我们可以清晰地看到相互递归的过程：
1. expression 调用 term 。
2. term 调用 factor 。
3. factor 消耗输入 ( 。
4. factor 调用 expression 。
5. expression 最终返回值 7 ，消耗了 3 + 4 ，这是递归调用。
6. factor 消耗输入 ) 。
7. factor 返回 7 。
8. term 消耗输入 * 和 5 并返回 35 。
9. expression 返回 35 。

递归终止条件

为了确保递归能够终止，我们需要考虑递归调用的情况。在这个例子中，每次递归调用都会处理一个更短的子表达式，并且至少会消耗一些令牌。因此，最终递归必然会结束。

关键概念解析

项（term）和因子（factor）的区别 ：因子是由乘法运算符（ * 和 / ）组合的，而项是由加法运算符（ + 和 - ）组合的。我们需要这两个概念是为了确保乘法的优先级高于加法。
表达式求值器使用相互递归的原因 ：为了处理带括号的表达式，如 2+3*(4+5) ，子表达式 4+5 可以通过递归调用 expression 函数来处理。
非法表达式的处理 ：如果尝试计算非法表达式 3+*4-5 ， expression 函数会抛出异常，因为星号被错误地包含在令牌列表中，就好像它是一个数字一样。

总结

相互递归是一种强大的编程技术，在处理复杂问题时非常有用。通过使用语法图和相互递归的函数，我们可以有效地计算算术表达式的值。在实际应用中，我们需要注意递归的终止条件，确保程序能够正常结束。同时，理解项和因子的概念以及运算符的优先级对于正确处理表达式至关重要。

练习题

为了帮助您更好地掌握相互递归和表达式求值的知识，以下是一些练习题：
1. 跟踪表达式求值程序，输入 3 – 4 + 5 、 3 – (4 + 5) 、 (3 – 4) * 5 和 3 * 4 + 5 * 6 ，观察程序的执行过程。
2. 扩展表达式求值器，使其能够处理 % 运算符以及 “幂运算” 运算符 ^ 。例如， 2 ^ 3 应该计算为 8 ，并且幂运算的优先级应该高于乘法。

通过这些练习，您可以进一步加深对相互递归和表达式求值的理解，提高编程能力。

希望本文能够帮助您理解相互递归在算术表达式求值中的应用。如果您有任何疑问或建议，欢迎在评论区留言。

深入理解相互递归：算术表达式求值的奥秘

递归在实际问题中的应用

递归在许多实际问题中都有广泛的应用，例如迷宫逃脱问题和汉诺塔问题。

迷宫逃脱问题

迷宫逃脱问题可以使用递归的方法来解决。我们可以从当前位置开始，递归地检查相邻的空位置是否可以逃脱，同时避免访问当前位置。以下是一个简单的迷宫逃脱问题的递归解决方案的流程图：

graph TD;
    A[当前位置] -->|是否为出口| B{是};
    B -- 是 --> C[返回 True];
    B -- 否 --> D[检查相邻空位置];
    D --> E{是否可逃脱};
    E -- 是 --> C;
    E -- 否 --> F[返回 False];

汉诺塔问题

汉诺塔问题是一个经典的递归问题。假设有 n 个盘子，我们可以通过递归地将 n - 1 个盘子从源柱子移动到辅助柱子，然后将第 n 个盘子从源柱子移动到目标柱子，最后再将 n - 1 个盘子从辅助柱子移动到目标柱子。以下是汉诺塔问题的递归实现代码：

def hanoi(n, source, target, auxiliary):
    if n == 1:
        print(f"Move disk from peg {source} to peg {target}")
        return
    hanoi(n - 1, source, auxiliary, target)
    print(f"Move disk from peg {source} to peg {target}")
    hanoi(n - 1, auxiliary, target, source)

hanoi(3, 1, 3, 2)