表达式计算 订阅
表达式计算(expression evaluation)是程序设计语言编译中的一个最基本问题,也是早期计算机语言研究的一项重要成果,它使得高级语言程序员可以使用与数学形式相一致的方式书写表达式,如a*b+c/d-c(x+y)。计算机科学计算语言FORTRAN就因Formula Translator(公式翻译家)而得名。 [1] 展开全文
表达式计算(expression evaluation)是程序设计语言编译中的一个最基本问题,也是早期计算机语言研究的一项重要成果,它使得高级语言程序员可以使用与数学形式相一致的方式书写表达式,如a*b+c/d-c(x+y)。计算机科学计算语言FORTRAN就因Formula Translator(公式翻译家)而得名。 [1]
信息
定    义
使用与数学形式一致的表达式
类    型
中缀表达式、后缀表达式
应用学科
计算机原理
中文名
表达式计算
系    统
计算机
外文名
expression evaluation
表达式计算组成
高级程序设计语言允许多种类型的表达式:算术表达式、关系表达式和逻辑表达式等。表达式由操作数、运算符和括号组成。表达式习惯的书写形式是一个双目运算符(binary operator)位于两个操作数之间,如a+b,这类表达式称为中缀表达式(infix expression)。除了双目运算符外,还有单目运算符(unary operator),如I++和一a。条件运算符是C语言中唯一的三目运算符(ternary operator)。为正确计算表达式的值,任何程序设计语言都明确规定了运算符的优先级。在C语言中,当使用括号时,从最内层括号开始计算;对于相邻的两个运算符,优先级高的先计算;如果两个运算符的优先级相同,运算次序由结合方向决定。例如,*与/是自左向右结合的,因此,a*b/c的运算次序是先乘后除。 [1]  在中缀表达式中,运算符具有不同的优先级,并且还可以使用括号改变运算的次序,因此运算规律比较复杂,不适于计算机求解表达式。与中缀表达式相对应的还有后缀表达式和前缀表达式。运算符在操作数之后的表达式称为后缀表达式。后缀表达式的特点如下:1、后缀表达式的操作数与中缀表达式的操作数先后次序相同,而运算符的先后次序不同;2、后缀表达式中没有括号,而且运算符没有优先级;3、后缀表达式计算过程严格按照从左到右的顺序进行。从以上特点可以看出,后缀表达式比较适合计算机求解。求解后缀表达式的过程为:从左到有依次扫描后缀表达式,若遇到运算符,则对该运算符前面的连续两个操作数用该运算符进行运算。 运算符在操作数之前的表达式称为前缀表达式。前缀表达式的特点与后缀表达式的特点相同,只是求解过程不同,其求解过程为:从右到左依次扫描前缀表达式,若遇到运算符,则对该运算符后面的连续两个操作数用该运算符进行运算。 综上所述,利用计算机求解表达式分为两个步骤:1、把中缀表达式转换为后缀表达式或前缀表达式;2、按照后缀表达式或前缀表达式的运算过程计算表达式的值。 [2] 
收起全文
精华内容
下载资源
问答
  • 表达式计算

    2014-09-12 17:12:02
    c++中的表达式计算

    基本的思路是将中缀表达式转换为后缀表达式,消除括号,然后计算。后缀表达式又称逆波兰表达式。主要通过栈来实现。


    中缀表达式转换为后缀表达式:

    1.从左到右逐个扫描中缀表达式中的各项,遇到结束符“#” 转6,否则继续。这里选择想中追表达式中添加一个#或自行判断是否到字符串的末尾。

    2.遇到操作数直接输出。

    3.若遇到右括号 ,则连续出栈输出,直到遇到左括号为止。左括号出栈但不输出,遇到右括号也不输出。

    4.若是其他操作符,则和栈顶操作符比较优先级,若小于等于栈顶操作符优先级,则连续出栈输出,直到大于栈顶操作符的优先级结束,操作符进栈。

    5。

    6.输出栈中剩余操作符,“#”除外。

    这里我们将输入的一个表达式字符串转换为后缀,且输入表达式是正确无误的。

    #include "Calculator.h"
    
    int calculator::getPriorityInStack(char oper){
    	if(oper == '#')return 0;
    	else if(oper == '(')return 1;
    	else if(oper == '*' || oper == '/')return 5;
    	else if(oper == '+' || oper == '-')return 3;
    	else if(oper == ')')return 7;
    	return -1;
    }
    int calculator::getPriorityOutStack(char oper){
    	if(oper == '#')return 0;
    	else if(oper == '(')return 7;
    	else if(oper == '*' || oper == '/')return 4;
    	else if(oper == '+' || oper == '-')return 2;
    	else if(oper == ')')return 1;
    	return -1;
    }
    string calculator::changeToSuffix(string Prefix){
    	int isp,icp,i = -1 ;
    	string output = "";;
    	operstack.push('#');
    	while(++i < Prefix.length()){
    		isp = getPriorityOutStack( Prefix[i]) ;
    		if(isp == -1){
    			output+=Prefix[i];
    			output+=',';
    		}
    		else{
    			icp = getPriorityInStack( operstack.top() );
    			while(isp <= icp){
    				output += operstack.top();
    				operstack.pop();
    				icp = getPriorityInStack( operstack.top() );
    				output+=',';
    			}
    			operstack.push(Prefix[i]);
    		}
    		
    	}
    	while (!operstack.empty())
    	{
    		output+= operstack.top();
    		operstack.pop();
    		output+=',';
    	}
    	return output.substr(0,output.length()-3);
    }
    

    使用 逗号,将数字分开。

    c++中没有split函数,之后对改好的后缀表达式的运算就只能一个个遍历了。


    后缀表达式的计算:

    扫描表达式,遇到操作数进栈,遇到操作符,出栈两个操作数,然后使用操作符进行计算,先出栈的放在操作符的右边,获得结果进栈,知道遇到结束符。

    int calculator::getResultBySuffix(string Suffix){
    	int i = 0;
    	string buff;
    	int a,b;
    	while( i < Suffix.length()){
    		if(Suffix[i] == ',')
    			i++;
    		buff = "";		
    		while(Suffix[i] >='0' && Suffix[i]<='9'&& i <Suffix.length())
    			buff += Suffix[i++];
    		if(buff != ""){
    			numstack.push(atoi(buff.c_str()));
    		}else{
    			a = numstack.top();
    			numstack.pop();
    			b =  numstack.top();
    			 numstack.pop();
    			if(Suffix[i] == '+')
    				numstack.push(b+a);
    			else if(Suffix[i] == '-')
    				numstack.push(b-a);
    			else if(Suffix[i] == '*')
    				numstack.push(b*a);
    			else if(Suffix[i] == '/')
    				numstack.push(b/a);
    			i++;
    		}
    	
    
    	}
    	i = numstack.top();
    	numstack.pop();
    	return i;
    }
    
    int calculator::getResult(string Prefix){
    	return getResultBySuffix(changeToSuffix(Prefix));
    }
    
    


    完成计算。








    展开全文
  • 超级表达式计算.rar

    2020-03-29 01:35:12
    超级表达式计算.rar 超级表达式计算.rar 超级表达式计算.rar 超级表达式计算.rar 超级表达式计算.rar 超级表达式计算.rar
  • 易语言表达式计算模块源码,表达式计算模块,取表达式计算结果,校验表达式数符规范,校验表达式运算符规范,校验表达式括号规范,取括号内表达式,计算表达式
  • 易语言表达式计算公式解析源码,表达式计算公式解析,表达式计算
  • 表达式计算C++

    千次阅读 2017-10-29 08:04:14
    表达式计算,C++可运行

    原创作者:Daniel

    时间:2017.10.29

    地点:大连理工大学软件学院

    表达式计算至少需要两个栈:1、数据栈 2、运算符栈

    中缀表达式定义:

    <表达式>::=<项> + <项> |<项> - <项> | <项>

    项 ::= <因子> * <因子> | <因子> / <因子> | <因子>

    <因子> ::= <常数> | (表达式)

    <常数> ::= <数字> | <数字> <数字>

    <数字> ::= 0|1|2|3|4|5|6|7|8|9

    中缀表达式计算通常按照我们习惯的先乘除后加减,有括号先算括号。

    逆波兰表达式定义:

    <表达式>::=<项><项> + |<项>  <项> - | <项>

    项 ::= <因子> <因子> *| <因子>  <因子>/ | <因子>

    <因子> ::= <常数>

    <常数> ::= <数字> | <数字> <数字>

    <数字> ::= 0|1|2|3|4|5|6|7|8|9

    在逆波兰表达式中,数字按照原来的顺序出现,运算放在参与运算的两个项或者因子后边

    比如:

    23 + (34 * 45)/(5 + 6 + 7)

    23 34 45*  5 6 +7+/+

    计算逆波兰表达式比中缀表达式要容易一些,具体过程如下:

    1、扫描表达式,操作数入栈

    2、遇到运算符,就在栈顶取出两个元素,用后取出的 操作 先取出的

    3、将运算所得的数字进栈

    4、循环123,直到表达式扫描完成,栈顶元素就是表达式的值

    在计算中缀表达式时有两种方法:1、转化为后缀表达式 2、直接计算

    1、中缀转化后缀方法:

    1)定义操作数的栈内外优先级

    2)扫描中缀表达式,遇到数字就输出

    2)遇到运算符,就将预算符的优先级(栈外优先级)与栈顶元素比较

    若栈外 高于 栈内 进栈

    栈外 低于 栈内,依次弹出运算符输出,直到栈顶元素优先级小于或者等于栈外元素优先级

    如果栈内外优先级相等,则栈顶元素弹出,不输出

    2、直接计算和1 过程基本一致,需要在运算符出栈过程进行算术运算,同时需要管理两个栈。

    #include<stdio.h>
    #include<stdlib.h>
    #include<stack>
    
    int priorityisp(char op) {
    
        switch (op) {
            case '#':
                return 0;
                break;
            case '(':
                return 1;
                break;
            case '^':
                return 7;
                break;
            case '*':
            case '/':
                return 5;
                break;
            case '+':
            case '-':
                return 3;
                break;
            case ')':
                return 8;
                break;
            default:
    
                printf("error!");
                break;
        }
    
        return -1;
    }
    
    int priorityicp(char op) {
    
        switch (op)
        {
            case '#':
                return 0;
                break;
            case '(':
                return 8;
                break;
            case '^':
                return 6;
                break;
            case '*':
            case '/':
                return 4;
                break;
            case '+':
            case '-':
                return 2;
                break;
            case ')':
                return 1;
                break;
            default:
                printf("error!");
                break;
        }
    
        return -1;
    }
    
    char* changeExp(char* exp) {
    
        char* postfixExp = (char*)malloc(sizeof(char) * 20);
        std::stack<char> oper;
        oper.push('#');
        int i = 0;
        int j = -1;
        while (exp[i]) {
    
            switch (exp[i]) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    postfixExp[++j] = exp[i];
                    break;
                default:
                    while (priorityicp(exp[i]) < priorityisp(oper.top())) {
                        postfixExp[++j] = oper.top();
                        oper.pop();
                    }
    
                    if (priorityicp(exp[i]) > priorityisp(oper.top()))
                        oper.push(exp[i]);
    
                    else  {
                        oper.pop();
                    }
    
                    break;
            }
            i++;
        }
    
        postfixExp[++j] = '\0';
        return postfixExp;
    }
    
    int calculate(char* postfixExp) {
    
        std::stack<char> cal;
        int i = 0;
    
        while (postfixExp[i]) {
    
            switch (postfixExp[i]) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    cal.push(postfixExp[i]);
                    break;
                default:
                    int num1 = cal.top() - '0';
                    cal.pop();
    
                    int num2 = cal.top() - '0';
                    cal.pop();
    
                    switch (postfixExp[i]) {
    
                        case '+':
                            cal.push(num2 + num1 + '0');
                            break;
                        case '-':
                            cal.push(num2 - num1 + '0');
                            break;
                        case '*':
                            cal.push(num2 * num1 + '0');
                            break;
                        case '/':
                            cal.push(num2 / num1 + '0');
                            break;
                    }
            }
            i++;
        }
    
        return cal.top() - '0';
    }
    
    int main(int argc, char** argv) {
    
        char InfixExp[20];
        char* PostfixExp;
        int i = 0;
    
        while ((InfixExp[i] = getchar()) != '\n')
            i++;
        InfixExp[i] = '\0';
        PostfixExp = changeExp(InfixExp);
        printf("%d", calculate(PostfixExp));
        system("pause");
    
        return 0;
    }
    


    展开全文
  • 后缀表达式计算

    千次阅读 2018-05-10 21:23:59
    试编写程序,求解一个一位数的后缀表达式计算,表达式支持+,-,*,/操作,其中/为整除。输入表达式输出计算值样例输入32+5*4-样例输出21提示可使用栈 解题关键:1. 理解后缀表达式如何计算2. 当输入的是数字直接...

    描述

    后缀表达式这样一种类型的表达式,操作数在前,操作符在后。例如这样的一位数后缀表达式:

    32+5*4-

    对等的四则表达式为:(3+2)*5-4。

    试编写程序,求解一个一位数的后缀表达式计算,表达式支持+,-,*,/操作,其中/为整除。

    输入

    表达式

    输出

    计算值

    样例输入

    32+5*4-

    样例输出

    21

    提示

    可使用栈

     

    解题关键:

    1. 理解后缀表达式如何计算

    2. 当输入的是数字直接入栈

    3. 当输入运算符时,直接出栈第一个和第二个运算数并且将计算结果入栈

    4. 注意字符与数字之间的转换(因为输入的是字符串)

    C++代码如下:

    #include <iostream>

    #include <stack>

    using namespace std;

    int computer(int a,char op,int b)//op代表运算符 ab为操作数

    {

    if(op == '+')

    return a+b;

    else if(op == '-')

    return a-b;

    else if(op == '*')

    return a*b;

    else

    return a/b;

    }

    int main()

    {

    stack<char> s1;

    string s;

    cin >> s;

    for(int i = 0; i < s.length(); i++)

    {

    if(s[i] == '+' || s[i] == '-' || s[i] =='*' || s[i] == '/')

    {//遇到运算符就要对栈顶两个元素进行计算

    int a = s1.top()-'0'; s1.pop();

    int b = s1.top()-'0'; s1.pop();//-’0’是为了将字符转换成数字

    int c = computer(b,s[i],a);

    s1.push(c+'0');

    }

    else

    {

    s1.push(s[i]);

    }

    }

    cout<<s1.top()-'0';

    return 0;

    }

    展开全文
  • 最近在学习二叉树,学习了怎样计算算术表达式计算算术表达式的大体思路是: 1. 首先是将中缀表达式转换成后缀表达式 2. 将后缀表达式,借助栈就能轻易的求出值 例如: (1+2)x3的后缀表达式是 12+3x,借助一个...

    最近在学习二叉树,学习了怎样计算算术表达式

    计算算术表达式的大体思路是:
    1. 首先是将中缀表达式转换成后缀表达式
    2. 将后缀表达式,借助栈就能轻易的求出值
    例如:
    (1+2)x3的后缀表达式是 12+3x,借助一个栈,将1,2放进去,在发现是+,将1,2弹出,计算1+2,计算出结果(3),放进去,栈中有3,3再遇见‘x’号,将3,3弹出,计算出结果(9),最终计算出结果。

        //确定运算符的优先级
        HashMap<Character,Integer> map=new HashMap<Character,Integer>();
        public void initiall(){
            map.put('#', -1);
            map.put('+', 0);
            map.put('-', 1);
            map.put('*', 2);
            map.put('/', 3);
        }
        //设置一个Linkedlist存放后缀表达式
        //设置一个Stack存放运算符
        private LinkedList<String> linkedlist=new LinkedList<String>();
        private Stack<Character> stack=new Stack<Character>();

    接下来将算术表达式转换成后缀表达式

        public void opeator() throws Exception{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            char[] char_str=br.readLine().toCharArray();
            stack.push('#');
            int i=0;
            while(i<char_str.length){
                if(char_str[i]=='('){
                    stack.push(char_str[i]);
                }
                else if(char_str[i]==')'){
                    Character temp=stack.pop();
                    while(temp!='('){
                        linkedlist.add(temp.toString());
                        temp=stack.pop();
                    }
                }
                else if(map.containsKey(char_str[i])){
                    Character temp=stack.peek();
                    while(temp!='('&&map.get(temp)>map.get(char_str[i])){
                        temp=stack.pop();
                        linkedlist.add(temp.toString());
                        temp=stack.peek();
                    }
                    stack.push(char_str[i]);
                }
                else{
                    linkedlist.add(String.valueOf(char_str[i]));
                }
                i++;
            }
        }

    转换成后缀表达式后,再根据栈求出结果

        public int getResult(){
            Iterator<String> iterator=linkedlist.iterator();
            Stack<Integer> stackInt=new Stack<Integer>();
            while(iterator.hasNext()){
                String str=iterator.next();
                if(str.equals("+")||str.equals("-")||str.equals("*")||str.equals("/")){
                    int a=stackInt.pop();
                    int b=stackInt.pop();
                    int result=0;
                    if(str.equals("+")){
                        result=a+b;
                    }
                    else if(str.equals("-")){
                        result=b-a;
                    }
                    else if(str.equals("*")){
                        result=a*b;
                    }
                    else if(str.equals("/")){
                        result=a/b;
                    }
                    stackInt.push(result);
                }
                else{
                    stackInt.push(Integer.parseInt(str));
                }
            }
            return stackInt.pop();
        }

    可能没有考虑出错的情况,有点不好。

    展开全文
  • 算术表达式计算

    2017-06-06 15:26:00
    前缀表达式计算规则: 从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 op 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,...
  • C++后缀表达式计算

    千次阅读 2019-11-19 22:32:17
    C++后缀表达式计算 继续上篇文章,实现计算器简单计算的功能 上篇文章C++中缀表达式转后缀表达式已经将中缀表达式转换成后缀表达式并保存在队列q中 后缀表达式算法思想: 读取队列q顶端元素,并判断元素类型...
  • 算法训练 表达式计算

    千次阅读 2017-02-21 09:06:56
    算法训练 表达式计算
  • 蓝桥杯训练 表达式计算

    千次阅读 2017-02-01 20:47:14
    算法训练 表达式计算 时间限制:1.0s 内存限制:256.0MB 问题描述  输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。 输入格式  输入一行,包含一个表达式。 输出格式  ...
  • 数学表达式计算

    2013-03-08 13:51:12
    数学表达式计算
  • 简单的前缀表达式计算 简单是指表达式简单,所有数字均为 0~9 之间,不是代码简单 【关于二叉树的递归创建与非递归遍历】 【其他:中缀表达式转后缀表达式】 【其他:后缀表达式计算】 思路 因为给定的是前缀表达式...
  • 用两种方式实现表达式自动计算 - PAGE 2 - 设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 ...
  • [链接里是带小括号表达式计算的代码](https://blog.csdn.net/acm_jl/article/details/51031005 "") ![题目要求](https://img-ask.csdn.net/upload/201811/28/1543365503_20006.jpg) 谢谢各位大佬!
  • 表达式计算引擎-JEP

    2019-10-10 13:07:52
    最近调整了原先的一个中间件的功能,把之前被产品去掉的规则表达式计算又重新添了回去. 这个中间件的基本功能是使用预定义的关键字和数值比对进行判断,从大量的数据中生成告警,主要是用于服务器监控. 这里的表达式...
  • 利用栈实现表达式的计算。括号匹配。 中缀表达式转换为后缀表达式。 逆波兰表达式的计算 package com.yc.algorithm.stack;... * 逆波兰表达式计算 * ( 1 - 2 ) * ( 4 + 5 ) --> -9 */ public class R...
  • javascript之使用逆波兰表达式(后缀表达式)实现算数表达式计算知识点使用JavaScript实现测试 知识点 栈 逆波兰表达式(后缀表达式) 注:具体逆波兰表达式相关介绍可参考 使用JavaScript实现 1.定义栈 class ...
  • 逆波兰表达式计算2.1 代码实现2.2 测试代码3. 波兰表达式计算3.1 代码实现4. 中缀表达式 转 后缀表达式4.1 代码实现4.1.1 定义一个中缀转后缀表达式的类4.1.2 获取操作符的优先级4.1.3 中缀转后缀的过程函数4.1 ...
  • //进行子表达式计算 if(flag==0){ printf("被除数为零"); return 0; } s1[++top1]=result;//计算结果存入栈顶 return 1; } //计算表达式的函数 float getResult(char exp[]){ int i=0;//用于指向...
  • 需求:输入字符串表达式,计算表达式结果 解决:将输入的表示转化为后缀表达式形式(也称作逆波兰式),再计算结果。... * 根据中缀表达式计算结果 * * @param expression * @return */
  • 怎么解决这个jasvascrpt表达式计算的问题 根据表达式计算来实现查询条件的判断,根据条件的判断然后再计算
  • MySQL表达式计算

    千次阅读 2015-08-19 12:23:02
    MySQL表达式计算代码位置:mysql-5.6.26/sql/item_func.cc样例驱动函数mysql-5.6.26/sql/item.cc#resolve_const_item()fix_length_and_decfix_length_and_dec函数负责计算出如下参数,供输出ResultMetaData及后继...
  • 试题 算法训练 表达式计算 题主做这道题目的时候,查了各种各样的别的语言的做法,大多都是转后缀表达式,没有真正的从python的角度实现。 题主本次使用的方法没有外部引入库,两行搞定,也是再一次真真切切的体会...
  • Fel表达式计算引擎

    千次阅读 2018-10-27 15:12:24
    一、Fel表达式计算引擎介绍 Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。 Fel是开放的,引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel...
  • 给出一个由加减乘除和括号构成的表达式计算表达式的值和表达式的前缀和后缀表达式 #include #include #define Inf 1e9 struct tree { double date; char ch; tree *l,*r; tree() { ch='\0'; date=0; l=r=...
  • 表达式计算4

    千次阅读 2021-02-23 22:24:57
    给出一个表达式,其中运算符仅包含+,-,*,/,^(加 减 乘 整除 乘方)要求求出表达式的最终值 数据可能会出现括号情况,还有可能出现多余括号情况 数据可能会出现负数情况 输入描述: 仅一行,即为表达式 输出描述: 仅一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,301
精华内容 18,920
关键字:

表达式计算