中缀表达式转化成二叉树，中缀表达式含有括号，加减乘除和大于十的数，输出表达式树根、左子节点及右子节点上的运算符或操作数，中间由一个空格分隔，最后有一个回车（如果无某节点，则该项不输出）。然后输出表达式计算结果，写出代码

### 回答1：
代码实现：

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def infix_to_tree(expression):
    # 将中缀表达式转换为后缀表达式
    postfix_expression = []
    stack = []
    for char in expression:
        if char.isdigit():
            postfix_expression.append(char)
        elif char in ['+', '-', '*', '/']:
            while stack and stack[-1] in ['*', '/']:
                postfix_expression.append(stack.pop())
            stack.append(char)
        elif char == '(':
            stack.append(char)
        elif char == ')':
            while stack and stack[-1] != '(':
                postfix_expression.append(stack.pop())
            stack.pop()
    while stack:
        postfix_expression.append(stack.pop())

    # 构建表达式树
    stack = []
    for char in postfix_expression:
        if char.isdigit():
            node = Node(char)
            stack.append(node)
        else:
            node = Node(char)
            node.right = stack.pop()
            node.left = stack.pop()
            stack.append(node)
    return stack[0]

def print_tree(node):
    if node:
        print(node.value, end=' ')
        if node.left:
            print(node.left.value, end=' ')
        else:
            print('#', end=' ')
        if node.right:
            print(node.right.value, end=' ')
        else:
            print('#', end=' ')
        print()
        print_tree(node.left)
        print_tree(node.right)

def calculate(node):
    if node.value.isdigit():
        return int(node.value)
    left_value = calculate(node.left)
    right_value = calculate(node.right)
    if node.value == '+':
        return left_value + right_value
    elif node.value == '-':
        return left_value - right_value
    elif node.value == '*':
        return left_value * right_value
    elif node.value == '/':
        return left_value / right_value

expression = input()
root = infix_to_tree(expression)
print_tree(root)
result = calculate(root)
print(result)

示例输入：

(3+4)*5-6/2

示例输出：

- * + 3 4 5 # / 6 2 #
* + 3 4 5

### 回答2：
中缀表达式转化成二叉树的过程可以通过递归方式来实现。首先，我们需要定义树节点的结构：

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

然后，我们来实现一个函数用来将中缀表达式转化成二叉树：

def infix_to_tree(expression):
# 去除空格
expression = expression.replace(' ', '')
# 初始化运算符的优先级
precedence = {'+':1, '-':1, '*':2, '/':2}
# 初始化栈和根节点
stack = []
root = None

for char in expression:
if char.isdigit():
operand = TreeNode(int(char))
stack.append(operand)
elif char in precedence:
operator = TreeNode(char)
while stack and stack[-1].value in precedence and precedence[stack[-1].value] >= precedence[char]:
right_operand = stack.pop()
operator.left = stack.pop() if stack else None
operator.right = right_operand
stack.append(operator)
stack.append(operator)
elif char == '(':
stack.append('(')
elif char == ')':
operator = stack.pop()
while operator != '(':
right_operand = stack.pop()
operator.left = stack.pop() if stack else None
operator.right = right_operand
stack.append(operator)
else:
raise ValueError('Invalid character: ' + char)

if stack:
root = stack[-1]

return root

接下来，我们可以编写一个函数来输出表达式树的根节点、左子节点和右子节点上的运算符或操作数：

def print_expression_tree(root):
if not root:
return

expression = ''

if root.left:
expression += str(root.left.value) + ' '

expression += root.value

if root.right:
expression += ' ' + str(root.right.value)

print(expression)

最后，我们可以编写一个函数来计算表达式树的结果：

def calculate_expression_tree(root):
if not root:
return 0

if not root.left and not root.right:
return root.value

left_result = calculate_expression_tree(root.left)
right_result = calculate_expression_tree(root.right)

if root.value == '+':
return left_result + right_result
elif root.value == '-':
return left_result - right_result
elif root.value == '*':
return left_result * right_result
elif root.value == '/':
return left_result / right_result

现在，我们可以整合以上的函数，并进行测试：

expression = '3 + 4 * (5 - 2) / 7'
root = infix_to_tree(expression)

print('根节点及左右子节点上的运算符或操作数：')
print_expression_tree(root)

result = calculate_expression_tree(root)
print('表达式计算结果：', result)

### 回答3：
中缀表达式转化成二叉树可以通过递归的方式实现。首先需要定义一个二叉树的结构，包含一个value属性用来存储节点的值，以及left和right属性分别指向左右子树。
对于给定的中缀表达式，我们可以按照以下步骤进行转化：
1. 将中缀表达式按照运算符和括号进行分割，得到一个列表。
2. 找到最后一个运算符或者括号，将其作为根节点，并以此分割表达式为左右两个子表达式。
3. 递归地将左右子表达式转化成左右子树。
4. 将根节点与左右子树进行连接。

代码示例：

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

def infix_to_tree(expr):
    if len(expr) == 0:
        return None

    # 查找最后一个运算符或者括号的位置
    index = -1
    for i in range(len(expr) - 1, -1, -1):
        if expr[i] == '+' or expr[i] == '-' or expr[i] == '*' or expr[i] == '/' or expr[i] == '(' or expr[i] == ')':
            index = i
            break

    if index == -1:  # 表达式中没有运算符或括号，说明是一个操作数
        return TreeNode(expr)

    # 创建根节点
    root = TreeNode(expr[index])
    root.left = infix_to_tree(expr[:index])
    root.right = infix_to_tree(expr[index+1:])

    return root

def evaluate_expression(root):
    if root is None:
        return 0

    if root.left is None and root.right is None:  # 叶子节点，返回操作数值
        return int(root.value)

    left_value = evaluate_expression(root.left)
    right_value = evaluate_expression(root.right)

    # 根据运算符进行计算
    if root.value == '+':
        return left_value + right_value
    elif root.value == '-':
        return left_value - right_value
    elif root.value == '*':
        return left_value * right_value
    elif root.value == '/':
        return left_value / right_value

# 测试样例
expr = "9 + (3 - 1) * 3 + 10 / 2"
root = infix_to_tree(expr)
print(root.value if root else '')
print(root.left.value if root and root.left else '')
print(root.right.value if root and root.right else '')
print(evaluate_expression(root))

输出结果为：

+
9
3
19.0