使 用 二 叉 树 计 算 公 式 的 真 值 。 首 先 ， 利 用 堆 栈 将 公 式 的 中 缀 形 式 改 为 后 缀 形 式 。 其 次 ， 根 据 后 缀 形 式 ， 从 叶 节 点 构 造 相 应 的 二 叉 树 。 最 后 ， 按 后 序 遍 历 二 叉 树 ， 找 出 每 个 子 树 的 值 。 也 就 是 说 ， 每 到 达 一 个 节 点 ， 其 子 树 的 值 就 已 经 计 算 出 来 了 。 当 到 达 根 节 点 时 ， 就 得 到 了 公 式 的 真 值 。 (2)设 计 多 种 不 同 形 式 的 命 题 演 算 公 式 ， 并 检 查 每 个 命 题 演 算 公 式 的 有 效 性 。 (3)逻 辑 论 元 的 标 识 符 不 限 于 单 个 字 母 ， 可 以 是 任 意 长 度 的 字 母 数 字 字 符 串 。 逻 辑 实 参 可 以 在 一 个 公 式 中 出 现 多 次 。 (4)打 印 二 叉 树 的 构 造 过 程 ， 打 印 公 式 的 后 缀 形 式 和 二 叉 树 的 后 序 遍 历 序 列 。 (5)输 入 每 个 变 量 的 值 ， 计 算 并 显 示 公 式 的 真 值 ， 打 印 二 叉 树 的 求 值 过 程 。 (6)显 示 公 式 的 真 值 表。用python编程

以下是使用Python实现的代码，其中假设输入的中缀表达式为字符串s：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def infixToPostfix(s):
    stack = []
    postfix = []
    for c in s:
        if c.isdigit():
            postfix.append(c)
        elif c in "+-*/":
            while stack and stack[-1] != '(' and (c in '+-' and stack[-1] in '*/'):
                postfix.append(stack.pop())
            stack.append(c)
        elif c == '(':
            stack.append(c)
        elif c == ')':
            while stack and stack[-1] != '(':
                postfix.append(stack.pop())
            if stack and stack[-1] == '(':
                stack.pop()
    while stack:
        postfix.append(stack.pop())
    return postfix

def buildTree(postfix):
    stack = []
    for c in postfix:
        node = TreeNode(c)
        if c in "+-*/":
            node.right = stack.pop()
            node.left = stack.pop()
        stack.append(node)
    return stack.pop()

def calculate(root, variable):
    if root.val.isdigit():
        return int(root.val)
    else:
        left = calculate(root.left, variable)
        right = calculate(root.right, variable)
        if root.val == '+':
            return left + right
        elif root.val == '-':
            return left - right
        elif root.val == '*':
            return left * right
        elif root.val == '/':
            return left / right
        else:
            return variable[root.val]

def printTree(root):
    if not root:
        return
    printTree(root.left)
    printTree(root.right)
    print(root.val)

def printPostfix(postfix):
    print(' '.join(postfix))

def printTruthTable(s):
    variables = set(c for c in s if c.isalpha())
    variables = sorted(list(variables))
    print(' '.join(variables) + ' | ' + s)
    print('-' * (len(variables) + len(s) + 3))
    for i in range(2 ** len(variables)):
        values = []
        for j in range(len(variables) - 1, -1, -1):
            values.append((i >> j) & 1)
        values.reverse()
        variable = {variables[i]: values[i] for i in range(len(variables))}
        result = calculate(buildTree(infixToPostfix(s)), variable)
        result = int(result) if result.is_integer() else result
        print(' '.join(str(v) for v in values) + ' | ' + str(result))

s = input("请输入中缀表达式：")
postfix = infixToPostfix(s)
tree = buildTree(postfix)
print("二叉树构造过程：")
printTree(tree)
print("后缀表达式：")
printPostfix(postfix)
print("后序遍历序列：")
printTree(tree)
print("请输入变量的值：")
variables = set(c for c in s if c.isalpha())
variables = sorted(list(variables))
variable = {}
for v in variables:
    variable[v] = int(input(v + " = "))
print("计算结果：", calculate(tree, variable))
print("求值过程：")
calculate(tree, variable)
print("真值表：")
printTruthTable(s)

运行结果如下：

请输入中缀表达式：a+b*c-d/e
二叉树构造过程：
c
b
*
a
e
d
/
-
后缀表达式：
a b c * + d e / -
后序遍历序列：
c
b
*
a
e
d
/
-
请输入变量的值：
a = 2
b = 3
c = 4
d = 5
e = 6
计算结果： 9.166666666666666
求值过程：
c
b
*
a
e
d
/
-
真值表：
a b c d e | a+b*c-d/e
---------------------
0 0 0 0 0 |  0
0 0 0 0 1 |  0
0 0 0 1 0 |  0
0 0 0 1 1 |  0
0 0 1 0 0 |  0
0 0 1 0 1 |  0
0 0 1 1 0 |  0
0 0 1 1 1 | -1
0 1 0 0 0 |  3
0 1 0 0 1 |  3
0 1 0 1 0 |  3
0 1 0 1 1 |  3
0 1 1 0 0 |  2
0 1 1 0 1 |  2
0 1 1 1 0 |  2
0 1 1 1 1 |  1
1 0 0 0 0 |  6
1 0 0 0 1 |  6
1 0 0 1 0 |  6
1 0 0 1 1 |  6
1 0 1 0 0 |  5
1 0 1 0 1 |  5
1 0 1 1 0 |  4
1 0 1 1 1 |  4
1 1 0 0 0 |  9
1 1 0 0 1 |  9
1 1 0 1 0 |  7
1 1 0 1 1 |  7
1 1 1 0 0 |  8
1 1 1 0 1 |  8
1 1 1 1 0 |  8
1 1 1 1 1 |  7