PAT_A1130#Infix Expression

Source:

PAT A1130 Infix Expression (25 分)

Description:

Given a syntax tree (binary), you are supposed to output the corresponding infix expression, with parentheses reflecting the precedences of the operators.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤ 20) which is the total number of nodes in the syntax tree. Then N lines follow, each gives the information of a node (the i-th line corresponds to the i-th node) in the format:

data left_child right_child

where data is a string of no more than 10 characters, left_child and right_child are the indices of this node's left and right children, respectively. The nodes are indexed from 1 to N. The NULL link is represented by −. The figures 1 and 2 correspond to the samples 1 and 2, respectively.

infix1.JPGinfix2.JPG
Figure 1Figure 2

Output Specification:

For each case, print in a line the infix expression, with parentheses reflecting the precedences of the operators. Note that there must be no extra parentheses for the final expression, as is shown by the samples. There must be no space between any symbols.

Sample Input 1:

8
* 8 7
a -1 -1
* 4 1
+ 2 5
b -1 -1
d -1 -1
- -1 6
c -1 -1

Sample Output 1:

(a+b)*(c*(-d))

Sample Input 2:

8
2.35 -1 -1
* 6 1
- -1 4
% 7 8
+ 2 3
a -1 -1
str -1 -1
871 -1 -1

Sample Output 2:

(a*2.35)+(-(str%871))

Keys:

Code:

 1 /*
 2 Data: 2019-08-11 21:33:00
 3 Problem: PAT_A1130#Infix Expression
 4 AC: 16:51
 5 
 6 题目大意:
 7 打印中缀表达式
 8 输入:
 9 第一行给出,结点个数N<=20
10 接下来N行,给出结点i(1~N)的,键值,左孩子编号,右孩子编号(空子树-1)
11 
12 基本思路:
13 静态树存储,输出中缀表达式
14 */
15 #include<cstdio>
16 const int M=1e2;
17 struct node
18 {
19     char data[10];
20     int l,r;
21 }infix[M];
22 
23 void Express(int root, int rt)
24 {
25     if(root == -1)
26         return;
27     if(root!=rt && (infix[root].l!=-1 || infix[root].r!=-1))
28         printf("(");
29     Express(infix[root].l,rt);
30     printf("%s", infix[root].data);
31     Express(infix[root].r,rt);
32     if(root!=rt && (infix[root].l!=-1 || infix[root].r!=-1))
33         printf(")");
34 }
35 
36 int main()
37 {
38 #ifdef ONLINE_JUDGE
39 #else
40     freopen("Test.txt", "r", stdin);
41 #endif // ONLINE_JUDGE
42 
43     int n,h[M]={0};
44     scanf("%d\n", &n);
45     for(int i=1; i<=n; i++)
46     {
47         scanf("%s %d %d\n", infix[i].data, &infix[i].l, &infix[i].r);
48         if(infix[i].l!=-1)  h[infix[i].l]=1;
49         if(infix[i].r!=-1)  h[infix[i].r]=1;
50     }
51     for(int i=1; i<=n; i++)
52         if(h[i]==0)
53             Express(i,i);
54 
55     return 0;
56 }

 

转载于:https://www.cnblogs.com/blue-lin/p/11132490.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
这是上题的代码:def infix_to_postfix(expression): precedence = {'!': 3, '&': 2, '|': 1, '(': 0} op_stack = [] postfix_list = [] token_list = expression.split() for token in token_list: if token.isalnum(): postfix_list.append(token) elif token == '(': op_stack.append(token) elif token == ')': top_token = op_stack.pop() while top_token != '(': postfix_list.append(top_token) top_token = op_stack.pop() else: # operator while op_stack and precedence[op_stack[-1]] >= precedence[token]: postfix_list.append(op_stack.pop()) op_stack.append(token) while op_stack: postfix_list.append(op_stack.pop()) return ' '.join(postfix_list) class Node: def __init__(self, value): self.value = value self.left_child = None self.right_child = None def build_expression_tree(postfix_expr): operator_stack = [] token_list = postfix_expr.split() for token in token_list: if token.isalnum(): node = Node(token) operator_stack.append(node) else: right_node = operator_stack.pop() left_node = operator_stack.pop() node = Node(token) node.left_child = left_node node.right_child = right_node operator_stack.append(node) return operator_stack.pop() def evaluate_expression_tree(node, variable_values): if node.value.isalnum(): return variable_values[node.value] else: left_value = evaluate_expression_tree(node.left_child, variable_values) right_value = evaluate_expression_tree(node.right_child, variable_values) if node.value == '!': return not left_value elif node.value == '&': return left_value and right_value elif node.value == '|': return left_value or right_value expression = "!a & (b | c)" postfix_expression = infix_to_postfix(expression) expression_tree = build_expression_tree(postfix_expression) variable_values = {'a': True, 'b': False, 'c': True} result = evaluate_expression_tree(expression_tree, variable_values) print(result)
06-12
好的,感谢提供代码。以下是针对你的问题的解答: 1. 打印二叉树构造过程 在 build_expression_tree 函数中,operator_stack 列表存储了构建二叉树的过程。我们可以在函数中添加打印语句来查看二叉树构建过程。 代码如下: ``` def build_expression_tree(postfix_expr): operator_stack = [] token_list = postfix_expr.split() for token in token_list: if token.isalnum(): node = Node(token) operator_stack.append(node) else: right_node = operator_stack.pop() left_node = operator_stack.pop() node = Node(token) node.left_child = left_node node.right_child = right_node operator_stack.append(node) # 打印二叉树构建过程 print([i.value for i in operator_stack]) return operator_stack.pop() ``` 在运行 build_expression_tree 函数时,将会打印出二叉树构建过程。 2. 打印后缀表达式和二叉树后序遍历序列 在函数 infix_to_postfix 中,postfix_list 列表存储了后缀表达式。我们可以在函数返回后缀表达式的同时,打印出后缀表达式。 代码如下: ``` def infix_to_postfix(expression): precedence = {'!': 3, '&': 2, '|': 1, '(': 0} op_stack = [] postfix_list = [] token_list = expression.split() for token in token_list: if token.isalnum(): postfix_list.append(token) elif token == '(': op_stack.append(token) elif token == ')': top_token = op_stack.pop() while top_token != '(': postfix_list.append(top_token) top_token = op_stack.pop() else: # operator while op_stack and precedence[op_stack[-1]] >= precedence[token]: postfix_list.append(op_stack.pop()) op_stack.append(token) while op_stack: postfix_list.append(op_stack.pop()) # 打印后缀表达式 print(f"后缀表达式:{' '.join(postfix_list)}") return ' '.join(postfix_list) def build_expression_tree(postfix_expr): operator_stack = [] token_list = postfix_expr.split() for token in token_list: if token.isalnum(): node = Node(token) operator_stack.append(node) else: right_node = operator_stack.pop() left_node = operator_stack.pop() node = Node(token) node.left_child = left_node node.right_child = right_node operator_stack.append(node) # 打印二叉树构建过程 print([i.value for i in operator_stack]) return operator_stack.pop() expression = "!a & (b | c)" postfix_expression = infix_to_postfix(expression) expression_tree = build_expression_tree(postfix_expression) # 打印二叉树后序遍历序列 print("二叉树后序遍历序列:", end="") def postorder(node): if node: postorder(node.left_child) postorder(node.right_child) print(node.value, end=" ") postorder(expression_tree) print() ``` 在运行程序时,将会先打印出后缀表达式,然后是构建二叉树的过程,最后打印出二叉树的后序遍历序列。 3. 打印二叉树评估过程 在 evaluate_expression_tree 函数中,我们可以添加打印语句来查看二叉树评估的过程。 代码如下: ``` def evaluate_expression_tree(node, variable_values): if node.value.isalnum(): return variable_values[node.value] else: left_value = evaluate_expression_tree(node.left_child, variable_values) right_value = evaluate_expression_tree(node.right_child, variable_values) if node.value == '!': result = not left_value elif node.value == '&': result = left_value and right_value elif node.value == '|': result = left_value or right_value # 打印二叉树评估过程 print(f"节点 {node.value} 的值为 {result}") return result expression = "!a & (b | c)" postfix_expression = infix_to_postfix(expression) expression_tree = build_expression_tree(postfix_expression) variable_values = {'a': True, 'b': False, 'c': True} result = evaluate_expression_tree(expression_tree, variable_values) print(result) ``` 在运行程序时,将会先打印出后缀表达式,然后是构建二叉树的过程,接着会打印出二叉树评估的过程。 4. 显示公式真值表 可以通过遍历变量的所有取值,来计算表达式的真值表。 代码如下: ``` expression = "!a & (b | c)" postfix_expression = infix_to_postfix(expression) expression_tree = build_expression_tree(postfix_expression) # 遍历变量的所有可能取值 variable_values = {'a': True, 'b': False, 'c': True} variable_names = list(variable_values.keys()) print(" ".join(variable_names), expression) for i in range(2**len(variable_names)): values = [bool(int(x)) for x in bin(i)[2:].zfill(len(variable_names))] variable_values = dict(zip(variable_names, values)) result = evaluate_expression_tree(expression_tree, variable_values) print(" ".join([str(int(x)) for x in values]), int(result)) ``` 在运行程序时,将会先打印出后缀表达式,然后是构建二叉树的过程,接着会打印出真值表。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值