表达式计算 订阅
表达式计算(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] 
收起全文
精华内容
下载资源
问答
  • 【c++】表达式计算

    2018-10-29 18:15:31
    计算任意表达式(整数+-*/^)的结果。原理为带优先级的符号(括号内的算式优先级加三),然后优先级从大到小遍历
  • 表达式计算

    2017-12-12 20:41:46
    利用c语言实现的表达式计算,数据结构。vs2012测试成功
  • 用C#实现的表达式计算引擎,支持词法分析,语法分析, 支持自定义关键字,自定义语法规则, 可以在项目里用来实现自定义逻辑计算。
  • c++数学表达式计算

    2016-10-30 14:45:28
    c++ 实现数学表达式计算 支持 常见的数学函数。如sin cos sqrt abs ... 支持 大多数运算符。 使用良好的设计模式,易于维护和拓展。
  • 用两种方式实现表达式自动计算 - PAGE 2 - 设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 ...
  • Spark SQL 表达式计算

    2017-05-16 10:23:05
    表达式计算在Spark SQL中随处可见,本演讲将简介表达式、UDF、UDAF、UDTF的概念,主要的API,以及如何扩展Spark SQL函数库。本演讲还将提及Catalyst在计划阶段和Project Tungsten在执行层做的优化,以及未来性能提升...
  • 易语言表达式计算模块源码 系统结构:取表达式计算结果,校验表达式数符规范,校验表达式运算符规范,校验表达式括号规范,取括号内表达式,计算表达式, ======启动程序集 | | | |------ _启动
  • 中缀表达式计算程序,手动实现运算数栈和运算符栈。
  • 表达式计算Demo.rar

    2019-08-31 16:01:34
    在很多的程序设计中,需要用户交互的数学运算,所以运算的规则不能写死,需要扩展,那么这个类可以很好解决这个难题,NCalc 是一个能够进行表达式计算的一系列程序集( Assembly )。我们主要使用 Expression 类,这个类...
  • Fel在源自于企业项目,设计目标是为了满足不断变化的功能需求和性能需求。...编译执行就是将表达式编译成字节码(生成java代码和编译模块都是可以扩展和替换的) Fel基于Java1.5开发,适用于Java1.5及以上版本。
  • 易语言JS脚本组件表达式计算源码,JS脚本组件表达式计算
  • 易语言表达式计算公式解析源码,表达式计算公式解析,表达式计算
  • 输入计算表达式,输出结果. 支持在运算符枚举类增加新的的自定义运算符,以及自定义运算的实现
  • 内容索引:VC/C++源码,字符处理,算法 VC++表达式计算工具源代码,用来计算各种表达式,包括复数、括号、加减乘除,并按照四则运算的顺序处理。  因本人水平有限,不可避免存在bug,望指教!
  • 编译原理表达式计算

    2019-03-04 22:34:48
    本项目用两种方式实现表达式自动计算:一是,用扫两遍表达式的方法;二是,用扫一遍表达式的方法。
  • JS脚本组件表达式计算.rar
  • 精品文档 一设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 1中缀转后缀 需要建一个操作符栈op和一个字符...
  • C#实现表达式计算的例子,支持变量。 如输入 1+2+3+(4*5) 输出:26 string[] key={"a","b","c"}; string[] val={"1","2","3"}; 输入:a+b+c 输出6
  • c语言中缀表达式计算

    2015-01-03 18:15:23
    利用c语言写的中缀表达式,主要数据结构是栈。
  • 简易计算器,可进行多种复制的表达式运算,内含多个版本
  • 资源介绍:逆波兰表达式计算易语言源码例程程序演示了逆波兰表达式的解析。逆波兰表达式计算易语言源码仅供参考。资源作者:三叶资源网资源界面:资源下载:
  • 后缀表达式计算

    2012-03-09 20:52:17
    后缀表达式计算,输入一个后缀表达式利用栈来计算结果
  • VC 函数表达式计算源码实例及测试截图,德国老外的程序,可以计算各种不同的函数、四则运算,还可以处理括号,计算正余弦等,值得借鉴的一款函数表达式计算工具。
  • ExpressionEvaluator表达式计算帮助文档 ExpressionEvaluator表达式计算帮助文档
  • 一个开源的Java表达式计算引擎 Java代码 /** * java 表达式计算引擎 * @author Michael sun */ public class TestExpr4j { /** * @param args */ public static void main(String[] args) { ...
  • C++后缀表达式计算

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

    C++后缀表达式计算

    继续上篇文章,实现计算器简单计算的功能

    上篇文章C++中缀表达式转后缀表达式已经将中缀表达式转换成后缀表达式并保存在队列q中

    后缀表达式算法思想:

    1. 读取队列q顶端元素,并判断元素类型
      (1)若是数,将数压入运算栈sum中;
      (2)若是运算符,取出栈sum顶端的两个元素计算,结果压回栈sum;

    2. 将队列顶端元素出栈,重复1操作,直至队列为空,此时sum中结果即为中缀表达式运算结果。

    队列顶端元素对应类型值

    在这里插入图片描述

    代码

    #include <iostream>
    #include<string>
    #include <stack>
    #include <queue>
    using namespace std;
    
    stack<char> s;//存放运算符的栈
    queue<string> q;//输出队列(用于计算后缀表达式)
    stack<double> sum;//用于计算后缀表达式
    string str = "";//读取整个数字串并保存
    int isp(char c)//栈内元素优先级判断
    {
     switch (c)
     {
     case '#':
      return 0;
     case '(':
      return 1;
     case '+':
     case '-':
      return 3;
     case '*':
     case '/':
     case '%':
      return 5;
     case ')':
      return 6;
     }
    }
    int icp(char c)//栈外元素优先级判断
    {
     switch (c) {
     case '#':
      return 0;
     case ')':
      return 1;
     case '+':
     case '-':
      return 2;
     case '*':
     case '/':
     case '%':
      return 4;
     case '(':
      return 6;
     }
    }
    void postfix(string input)//中缀表达式转后缀表达式代码
    {
     s.push('#');//将#压入栈顶
     input += '#';//添加#号作为结束符
     for (int i = 0; i < input.length(); i++)
     {
      if ((input[i] >= '0' && input[i] <= '9') || input[i] == '.')
      {
       str += input[i];
      }
      else
      {
       if (str.length() > 0)//将数放入直接输出到队列中
       {
        q.push(str);
        str = "";
       }
       while (isp(s.top()) > icp(input[i]))
       {
        string a;//因为不能直接在栈和队列间转换字符和字符串类型,所以先将字符转成 字符串再出栈进队列
        a = s.top();
        q.push(a);
        s.pop();
       }
       //判断站外元素优先级决定元素是应该去除(=),还是进栈(<)
       if (isp(s.top()) == icp(input[i]))
       {
        s.pop();
       }
       else
       {
        s.push(input[i]);
       }
      }
     }
    }
    
    int wordType(string str)//队列顶元素类型
    {
     if (str == "+")
     {
      return 1;
     }
     else if (str == "-")
     {
      return 2;
     }
     else if (str == "*")
     {
      return 3;
     }
     else if (str == "/")
     {
      return 4;
     }
     else {
      return 0;//元素数字
     }
    }
    void addOperation()//加运算,取运算栈的两个栈顶元素进行操作,结果压回运算栈
    {
     double temp1, temp2,result;
     temp2 = sum.top();//先取操作数2(运算符后面的操作数)
     sum.pop();
     temp1 = sum.top();//再取操作数1(运算符前面的操作数)
     sum.pop();
     result = temp1 + temp2;
     sum.push(result);
    }
    void subOperation()//减运算
    {
     double temp1, temp2, result;
     temp2 = sum.top();
     sum.pop();
     temp1 = sum.top();
     sum.pop();
     result = temp1 - temp2;
     sum.push(result);
    }
    void mulOperation()//乘运算
    {
     double temp1, temp2, result;
     temp2 = sum.top();
     sum.pop();
     temp1 = sum.top();
     sum.pop();
     result = temp1 * temp2;
     sum.push(result);
    }
    void divOperation()//除运算
    {
     double temp1, temp2, result;
     temp2 = sum.top();
     sum.pop();
     temp1 = sum.top();
     sum.pop();
     result = temp1 / temp2;
     sum.push(result);
    }
    void suffix()//计算后缀表达式,结果保留在栈sum中
    {
     while (q.empty() == false)
     {
      int objType;//队列顶元素的类型(0:数字;1:+;2:-;3:*;4:/)
      objType = wordType(q.front());
      switch (objType)
      {
      case 0:
       sum.push(atof(q.front().c_str())); break;//使用c_str()方法将string转换成double型,将数字放入计算栈中
      case 1:
       addOperation(); break;
      case 2:
       subOperation(); break;
      case 3:
       mulOperation(); break;
      case 4:
       divOperation(); break;
      }
      q.pop(); //将队列顶元素出队列
     }
    }
    
    int main()
    {
     string input;
     string och;
     cin >> input;
     postfix(input);
     //while (q.empty() == false)//队列不为空则输出队列元素
     //{
     // och = q.front();
     // cout << och;
     // q.pop();
     //}
     suffix();
     cout << sum.top() << endl;
    }
    

    实验结果

    在这里插入图片描述
    结果正确,自行验证。

    展开全文
  • 中缀表达式计算C++实现
  • Java实现表达式计算求值

    万次阅读 多人点赞 2019-07-21 21:20:34
     输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。 输入格式  输入一行,包含一个表达式。 输出格式  输出这个表达式的值。 样例输入 1-2+3*(4-5) 样例输出 -4 数据规模和约定  ...

    问题描述
      输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。
    输入格式
      输入一行,包含一个表达式。
    输出格式
      输出这个表达式的值。
    样例输入
    1-2+3*(4-5)
    样例输出
    -4
    数据规模和约定
      表达式长度不超过100,表达式运算合法且运算过程都在int内进行。

    package com.liuzhen.systemExe;
    
    
    import java.util.Scanner;
    import java.util.Stack;
    
    
    public class Main{
        //计算表达式的值
        public void getExpressionValue(String A){
            char[] arrayA = A.toCharArray();
            Stack<Integer> Value = new Stack<Integer>();      //存放运算数字及表达式计算结果
            Stack<Character> Operator =  new Stack<Character>();   //存放运算符
            for(int i = 0;i < A.length();i++){
                int temp = 0;
                if(arrayA[i] >= '0' && arrayA[i] <= '9'){
                    temp = arrayA[i] - '0';
                    i = i + 1;
                    while(i < A.length() && arrayA[i] >= '0' && arrayA[i] <= '9'){
                        temp = temp * 10 + (arrayA[i] - '0');
                        i++;
                    }
                    i--;     //对应上面一句i = i+1;因为在for循环中有i++自增操作,若不执行此句,会导致i自增两次
                    Value.push(temp);
                }
                else{
                    if(Operator.empty()){
                       Operator.push(arrayA[i]);
                    }
                    else{
                        char temp1 = Operator.pop();   //进栈前,存放运算符栈中栈顶存放字符
                        int judge = comparePriority(temp1,arrayA[i]);  //比较当前字符与栈顶字符优先级
                        if(judge == 1){           //当前字符优先级小于栈顶字符
                            int tempA = Value.pop();
                            int tempB = Value.pop();
                            int result = computeNumber(tempB,tempA,temp1);
                            Value.push(result);
                            Operator.push(arrayA[i]);
                        }
                        if(judge == 0){           //当前字符优先级大于栈顶字符
                            Operator.push(temp1);
                            Operator.push(arrayA[i]);
                        }
                        if(judge == 2){  //字符')'遇到'(',刚好使得'('出栈
                            System.out.println("'('刚好遇到')'");   //这种情况也应该不会出现,按照给定优先级,')'一般会先遇到+、-、*、/字符
                        }
                        if(judge == 3){   //此时')'刚好准备进栈
                            while(temp1 != '('){          //')'字符要等到第一个'('出栈才能结束循环
                                //System.out.println(temp1);
                                int tempA = Value.pop();
                                int tempB = Value.pop();
                                int result = computeNumber(tempB,tempA,temp1);
                                Value.push(result);
                                temp1 = Operator.pop();  
                            }
                        }
                        if(judge == -1){    //此时,说明当前栈顶字符为')',这是不存在的,因为遇到')',按要求不让进栈
                            System.out.println("出现栈顶有')'错误!!!");
                        }
                    }
                }
            }
            
            while(!Operator.empty() && !Value.empty()){   //此时,字符栈中还存在运算符的情况
                char temp1 = Operator.pop();
                int tempA = Value.pop();
                int tempB = Value.pop();
                int result = computeNumber(tempB,tempA,temp1);
                Value.push(result);
            }
            System.out.println(Value.pop());   //此时运算符栈为空,数字栈中只存在表达式计算最终结果
        }
        //计算a operator b的值,operator = {+,-,*,/}
        public int computeNumber(int a,int b,char operator){
            int result;
            switch(operator){
            case '+': 
                result = a+b;
                break;
            case '-':
                result = a-b;
                break;
            case '*': 
                result = a*b;
                break;
            case '/': 
                result = a/b;
                break;        
            default:  
                result = 0;
                break;
            }
            return result;
        }
        //判断运算符a和b的优先级
        public int comparePriority(char a,char b){
            //使用二维数组表达运算符之间的优先级,行用字符a表示,列用字符b表示
            int[][] Value = {{1,1,0,0,0,3},
                    {1,1,0,0,0,3},
                    {1,1,1,1,0,3},
                    {1,1,1,1,0,3},
                    {0,0,0,0,0,2},
                    {-1,-1,-1,-1,-1,-1}};
            int i = 0;
            int j = 0;
            if(a == '+')
                i = 0;
            if(a == '-')
                i = 1;
            if(a == '*')
                i = 2;
            if(a == '/')
                i = 3;
            if(a == '(')
                i = 4;
            if(a == ')')
                i = 5;
            
            if(b == '+')
                j = 0;
            if(b == '-')
                j = 1;
            if(b == '*')
                j = 2;
            if(b == '/')
                j = 3;
            if(b == '(')
                j = 4;
            if(b == ')')
                j = 5;
            return Value[i][j];
        }
        
        public static void main(String[] args){
            Main test = new Main(); 
            Scanner in = new Scanner(System.in);
            System.out.println("请输入一个算法表达式:");
            String A = in.nextLine();
            test.getExpressionValue(A);
        
        }
    }
    

    运行结果:

    请输入一个算法表达式:
    1-2+3*(4-5)
    -4
    
    
    请输入一个算法表达式:
    1-2*((2+3)*2-(2+3))
    -9
    
    
    请输入一个算法表达式:
    1-2*((2+3)*(2+3))
    -49
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 703,343
精华内容 281,337
关键字:

表达式计算