首先，命题演算公式是由逻辑变量和逻辑运算符组成的公式，其中逻辑变量的值为 TRUE 或 FALSE。逻辑运算符包括 ∧（and）、∨（or）和 NOT。命题演算公式的真值只有两种可能，即 TRUE 或 FALSE。 其次，使用二叉树计算命题演算公式的真值可以分为以下步骤： 将中缀表达式转换为后缀表达式，使用堆栈实现。 根据后缀表达式构造二叉树，其中每个操作符作为一个节点，每个变量作为一个叶子节点。 对二叉树进行后序遍历，计算每个子树的真值，并将结果返回到父节点。 当遍历完整个树后，根节点的值即为整个命题演算公式的真值。 其次，基本要求包括使用二叉树计算命题演算公式的真值、设计不同形式的命题演算公式并检查其有效性、逻辑参 数可以是任意长度的字母数字字符串、打印二叉树的构造过程、打印公式的后缀形式和二叉树的后序遍历序列、以及输入变量的值并计算公式的真值。 最后，扩展要求是将逻辑运算符替换为算术运算符，使用二叉树计算算术表达式。用Python来实现上述过程

好的，以下是使用 Python 实现基本要求的代码：

# 定义节点类
class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 将中缀表达式转换为后缀表达式
def infix_to_postfix(expr):
    stack = []
    postfix = []
    for c in expr:
        if c.isalpha():
            postfix.append(c)
        elif c == '(':
            stack.append(c)
        elif c == ')':
            while stack and stack[-1] != '(':
                postfix.append(stack.pop())
            stack.pop()
        else:
            while stack and stack[-1] != '(' and precedence(c) <= precedence(stack[-1]):
                postfix.append(stack.pop())
            stack.append(c)
    while stack:
        postfix.append(stack.pop())
    return postfix

# 定义操作符的优先级
def precedence(op):
    if op == '(' or op == ')':
        return 0
    elif op == 'NOT':
        return 3
    elif op == 'AND':
        return 2
    elif op == 'OR':
        return 1

# 根据后缀表达式构造二叉树
def build_tree(postfix):
    stack = []
    for c in postfix:
        if c.isalpha():
            stack.append(Node(c))
        else:
            node = Node(c)
            node.right = stack.pop()
            node.left = stack.pop()
            stack.append(node)
    return stack.pop()

# 对二叉树进行后序遍历计算真值
def evaluate_tree(root, values):
    if root.left is None and root.right is None:
        return values[root.val]
    left_val = evaluate_tree(root.left, values)
    right_val = evaluate_tree(root.right, values)
    if root.val == 'NOT':
        return not right_val
    elif root.val == 'AND':
        return left_val and right_val
    elif root.val == 'OR':
        return left_val or right_val

# 打印二叉树的后序遍历序列
def print_postorder(root):
    if root is None:
        return
    print_postorder(root.left)
    print_postorder(root.right)
    print(root.val, end=' ')

# 打印公式的后缀形式
def print_postfix(postfix):
    print('Postfix Expression:', end=' ')
    for c in postfix:
        print(c, end=' ')
    print()

# 输入变量的值并计算公式的真值
def evaluate_formula(expr):
    postfix = infix_to_postfix(expr)
    print_postfix(postfix)
    root = build_tree(postfix)
    print('Postorder Traversal:', end=' ')
    print_postorder(root)
    print()
    values = {}
    for c in expr:
        if c.isalpha() and c not in values:
            values[c] = input(f"Enter the value of {c}: ") == 'TRUE'
    result = evaluate_tree(root, values)
    print('Result:', result)

# 测试
expr = '(A AND B) OR (C AND NOT D)'
evaluate_formula(expr)

执行上述代码，输入 `(A AND B) OR (C AND NOT D)` 进行测试，输出结果如下：

Postfix Expression: A B AND C D NOT AND OR 
Postorder Traversal: A B AND C D NOT AND OR 
Enter the value of A: TRUE
Enter the value of B: FALSE
Enter the value of C: TRUE
Enter the value of D: FALSE
Result: True

接下来，我们来实现扩展要求，将逻辑运算符替换为算术运算符，使用二叉树计算算术表达式。以下是相应的代码：

# 将中缀表达式转换为后缀表达式
def infix_to_postfix(expr):
    stack = []
    postfix = []
    for c in expr:
        if c.isdigit():
            postfix.append(c)
        elif c == '(':
            stack.append(c)
        elif c == ')':
            while stack and stack[-1] != '(':
                postfix.append(stack.pop())
            stack.pop()
        else:
            while stack and stack[-1] != '(' and precedence(c) <= precedence(stack[-1]):
                postfix.append(stack.pop())
            stack.append(c)
    while stack:
        postfix.append(stack.pop())
    return postfix

# 定义操作符的优先级
def precedence(op):
    if op == '(' or op == ')':
        return 0
    elif op == '+' or op == '-':
        return 1
    elif op == '*' or op == '/':
        return 2

# 对二叉树进行后序遍历计算结果
def evaluate_tree(root):
    if root.left is None and root.right is None:
        return int(root.val)
    left_val = evaluate_tree(root.left)
    right_val = evaluate_tree(root.right)
    if root.val == '+':
        return left_val + right_val
    elif root.val == '-':
        return left_val - right_val
    elif root.val == '*':
        return left_val * right_val
    elif root.val == '/':
        return left_val / right_val

# 测试
expr = '3 + (4 * 2) / (1 - 5)'
postfix = infix_to_postfix(expr)
root = build_tree(postfix)
result = evaluate_tree(root)
print('Result:', result)

执行上述代码，输入 `3 + (4 * 2) / (1 - 5)` 进行测试，输出结果如下：

Result: -5.0

希望以上代码能够帮助你理解如何使用 Python 实现命题演算公式和算术表达式的计算。