基于数组与栈的表达式递归求值及指定数组存储实现咨询

这其实是一个典型的逐步迭代式表达式求值需求，核心是按顺序累积运算结果并存储到数组中。我给你几种实现思路，包括最直观的迭代方式、递归方式，还有结合栈的实现，你可以根据自己的场景选择：

一、直观的迭代实现（最易理解） #

这种方式直接按步骤处理操作数，逻辑清晰，适合大多数场景：

# 替换成你实际使用的操作数值或变量
a = 1  # 二进制 0001
b = 2  # 二进制 0010
c = 4  # 二进制 0100
d = 8  # 二进制 1000
e = 16 # 二进制 10000

# 把所有操作数整理到列表，方便遍历
operands = [a, b, c, d, e]
# 初始化存储中间结果的数组
result_arr = []

# 第一步：计算前两个操作数的|运算，存入数组索引0
if len(operands) >= 2:
    first_result = operands[0] | operands[1]
    result_arr.append(first_result)
    print(f"第一步：a|b = {first_result}，存入result_arr[0]")

    # 从第三个操作数开始，依次和上一步结果运算
    for step_idx, current_op in enumerate(operands[2:]):
        # 当前结果要存入的数组索引是 step_idx + 1
        next_result = result_arr[-1] | current_op
        result_arr.append(next_result)
        print(f"第{step_idx+2}步：result_arr[{step_idx}] | {current_op} = {next_result}，存入result_arr[{step_idx+1}]")
else:
    print("错误：操作数数量少于2，无法执行运算")

# 最终输出结果数组
print("\n最终结果数组：", result_arr)

逻辑说明： #

• 先把所有操作数放到列表中，统一管理
• 优先处理前两个操作数的|运算，结果存入数组的第一个位置（索引0）
• 遍历剩下的操作数，每一步都取数组的最后一个元素（也就是上一步的运算结果）和当前操作数执行|运算，把新结果追加到数组中，自动对应到下一个索引位置

二、递归实现（贴合你提到的递归求值需求） #

如果必须用递归逻辑，我们可以通过递归函数逐步处理剩余的操作数，利用调用栈来维护运算顺序：

def recursive_eval(remaining_ops, result_arr=None):
    # 初始化结果数组（仅第一次调用时执行）
    if result_arr is None:
        result_arr = []
    
    # 递归终止条件：没有剩余操作数可处理
    if not remaining_ops:
        return result_arr
    
    # 第一次调用：处理前两个操作数
    if len(result_arr) == 0:
        if len(remaining_ops) >= 2:
            # 计算前两个操作数的结果
            current_res = remaining_ops[0] | remaining_ops[1]
            result_arr.append(current_res)
            # 递归处理剩下的操作数（从第三个开始）
            return recursive_eval(remaining_ops[2:], result_arr)
        else:
            return result_arr
    else:
        # 已有中间结果，取最后一个和当前第一个操作数运算
        current_res = result_arr[-1] | remaining_ops[0]
        result_arr.append(current_res)
        # 递归处理剩下的操作数
        return recursive_eval(remaining_ops[1:], result_arr)

# 调用递归函数
operands = [a, b, c, d, e]
recursive_result = recursive_eval(operands)
print("递归实现的结果数组：", recursive_result)

逻辑说明： #

• 递归函数接收两个参数：剩余待处理的操作数列表，以及当前的结果数组
• 第一次调用时，先计算前两个操作数的结果并存入数组，然后递归处理剩下的操作数
• 后续递归调用时，每次取结果数组的最后一个元素和当前第一个剩余操作数运算，将结果追加到数组后，继续递归处理剩下的操作数，直到没有剩余操作数为止

三、结合栈的实现（贴合你提到的栈需求） #

栈的思路和迭代类似，我们可以用栈来维护中间结果（本质上递归也是利用了调用栈，这里是显式使用栈）：

operands = [a, b, c, d, e]
result_arr = []
# 初始化栈，先存入前两个操作数
op_stack = [operands[0], operands[1]]

# 第一步：计算前两个操作数的结果
first_res = op_stack.pop() | op_stack.pop()
result_arr.append(first_res)
# 把第一步结果压入栈，作为后续运算的基础
op_stack.append(first_res)

# 处理剩下的操作数
for current_op in operands[2:]:
    current_res = op_stack.pop() | current_op
    result_arr.append(current_res)
    op_stack.append(current_res)

print("基于栈的结果数组：", result_arr)

逻辑说明： #

• 先将前两个操作数压入栈，弹出后计算|结果，存入数组并重新压入栈
• 后续每个操作数，都弹出栈顶的中间结果，和当前操作数运算，将新结果存入数组并压回栈中，以此完成逐步累积运算

内容的提问来源于stack exchange，提问作者Anwesha Patel