Evaluate Postfix Expression_后缀表达式求解

6-2 Evaluate Postfix Expression(25 分)
Write a program to evaluate a postfix expression. You only have to handle four kinds of operators: +, -, x, and /.
Format of functions:

ElementType EvalPostfix( char *expr );
where expr points to a string that stores the postfix expression. It is guaranteed that there is exactly one space between any two operators or operands. The function EvalPostfix is supposed to return the value of the expression. If it is not a legal postfix expression, EvalPostfix must return a special value Infinity which is defined by the judge program.
Sample program of judge:

#include <stdio.h>
#include <stdlib.h>

typedef double ElementType;
#define Infinity 1e8
#define Max_Expr 30   /* max size of expression */

ElementType EvalPostfix( char *expr );

int main()
{
    ElementType v;
    char expr[Max_Expr];
    gets(expr);
    v = EvalPostfix( expr );
    if ( v < Infinity )
        printf("%f\n", v);
    else
        printf("ERROR\n");
    return 0;
}

/* Your function will be put here */
Sample Input 1:

11 -2 5.5 * + 23 7 / -
Sample Output 1:

-3.285714
Sample Input 2:

11 -2 5.5 * + 23 0 / -
Sample Output 2:

ERROR
Sample Input 3:

11 -2 5.5 * + 23 7 / - *
Sample Output 3:

ERROR
Special thanks to Sirou Zhu (朱思柔) for providing a valuable test case.
后缀表达式求值,简单模拟
没啥好说的

#include <stdio.h>
#include <stdlib.h>
#include<cstring>
#include<cmath>
#include<cctype>
#include<iostream>
using namespace std;
typedef double ElementType;
#define Infinity 1e8
#define Max_Expr 30   /* max size of expression */

ElementType EvalPostfix(char *expr)
{
    double stk[1111], p1, p2;
    int len = strlen(expr), i, j, f = 0,top=-1;
    char *tmp;
    for (i = 0; expr[i]; i++)
    {
        if (!i)
        {
            if (expr[0] == '-' && expr[1] == '\0')
                return Infinity;
            if (!isdigit(expr[0])&&expr[0]!='-')
                f = 1;
        }
        else if (expr[i] != '.' && !isdigit(expr[i]))
        {
            f = 1;
        }
    }
    expr[len] = ' ', expr[len + 1] = '\0';
//  cout << f << endl;
    if (!f)
        return atof(expr);
    i = 0;// 11 -2 5.5 * +23 7 / -
    while (expr[i]!='\0')
    {
        if (expr[i] == ' ')
        {
            expr[i++] = '\0';
            tmp = expr;
            expr += i;
            i = 0;
            if (!strchr("0123456789.+-*/", tmp[0]))
                return Infinity;
            if (strchr("*/+-", tmp[0]) && tmp[1] == '\0')
            {
                if (top - 2 < -1)
                    return Infinity;
                p1 = stk[top--];
                p2 = stk[top--];
                if (tmp[0] == '+')
                    stk[++top] = p1 + p2;
                else if (tmp[0] == '-')
                    stk[++top] = p2 - p1;
                else if (tmp[0] == '*')
                    stk[++top] = p2*p1;
                else if (tmp[0] == '/')
                {
                    if (p1 == 0)
                        return Infinity;
                    stk[++top] = p2 / p1;
                }
            }
            else
                stk[++top] = atof(tmp);
        }
        else i++;
    }
    if (top - 1 == -1)  
        return stk[0];
    return Infinity;
}

int main()
{
    ElementType v;
    char expr[Max_Expr];
    gets_s(expr);
    v = EvalPostfix(expr);
    if (v < Infinity)
        printf("%f\n", v);
    else
        printf("ERROR\n");
    return 0;
}
  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 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、付费专栏及课程。

余额充值