计算表达式_计算表达式的值 - CSDN
精华内容
参与话题
  • 数据结构与算法 计算表达式(一)

    千次阅读 2019-03-25 19:23:03
    数据结构与算法计算表达式(一) 一、简单说明 计算中缀表达式。比如1+2*3、(56-20-6)/(4+2-1)。 二、实现主要思路 1、为各运算符指定优先级 说明:‘=’是为了辅助比较运算符,这样子设置优先级,只有...

                                             数据结构与算法  计算表达式(一)

    一、简单说明

            计算中缀表达式。比如1+2*3、(56-20-6)/(4+2-1)。

    二、实现主要思路

        1、为各运算符指定优先级

        

              说明:‘=’是为了辅助比较运算符,这样子设置优先级,只有括号情况下才会有优先级相等的情况。

        2、逐个扫描算数表达式,运算数用一个栈(num)存储、运算符用一个栈(op)存储

        3、当右运算符优先级低于左运算符时,op栈弹出一个运算符,num栈弹出两个运算数,然后进行计算。

        4、扫描表达式结束,继续扫描执行先压栈而没有执行的运算符

        5、最后num栈的第一个元素就是表达式的结果。

        举例说明:表达式 (56-20)/(4+2)

            

    三、效果

        

        

    四、源码

      exp.c源文件

    #include <stdio.h>
    #include <stdlib.h> //memset()函数所在的头文件 
    #define SIZE 100   //定义临时存放数据的空间大小 
     
    struct  OP //运算符结构体  (这个结构体其实是一个栈的结构)
    {
    	char data[SIZE];         //存放运算符 
    	int top;                 //相当于栈顶指针   
    }op;                         //定义结构体变量,op存放运算符 
     
    struct   NUM//运算数结构体  (这个结构体其实是一个栈的结构)
    {
    	float data[SIZE];         //存放运算数 
    	int top;                 //相当于栈顶指针   
    }num;                        //定义结构体变量,num存放运算数
     
    struct	PRI		//用来存储运算符的优先级 
    {
    	char op;	//运算符 
    	int pri;	//优先级 
    };
     
    //定义左运算符优先级结构体数组 
    struct PRI lpri[] = {{'=',0},{'(',1},{'+',3},{'-',3},{'*',5},{'/',5},{')',6}};
     
    //定义右运算符优先级结构体数组
    struct PRI rpri[] = {{'=',0},{'(',6},{'+',2},{'-',2},{'*',4},{'/',4},{')',1}}; 
     
    //函数声明部分  
    int LeftPri(char op);//求左运算符op的优先级
    int RightPri(char op);//求右运算符op的优先级
    int IsOp(char ch);//判断ch是否是运算符
    int JudgePri(char lop,char rop); //判断左右运算符的优先级 
    float CountExp(char* exp);//计算表达式 
    float Str2Float(char* str); //字符串转换为 float数字 
    void Count(char op);//*/+-运算 
     
    int main(int argc,char* argv[])
    {
    	char exp1[] = "(56-20-6)/(4+2-1)" ;
    	char exp2[] = "5-1*2*3+12/2/2"; 
    	float res = CountExp(exp1);
    	printf("(56-20-6)/(4+2-1)的结果是:%lf\n",res);
    	res = CountExp(exp2);
    	printf("5-1*2*3+12/2/2的结果是:%lf\n",res);
    	return 0;
    }
     
      
    int LeftPri(char op)//求左运算符op的优先级
    {
    	int i = 0;//计数器
    	for(i = 0;i < sizeof(lpri)/sizeof(lpri[0]);i++)//求左运算符的个数sizeof(lpri)/siozeof(lpri[0]) 
    	{
    		if(lpri[i].op == op)//如果 左运算符结构体有匹配的运算符 
    		{
    			return lpri[i].pri;//返回对应的运算符的优先级 
    		} 
    	} 
    	
    	return -1;//没有匹配的运算符 
    } 
     
     
    int RightPri(char op)//求右运算符op的优先级 
    {
    	int i = 0;//计数器
    	for(i = 0;i < sizeof(rpri)/sizeof(rpri[0]);i++)//求右运算符的个数sizeof(lpri)/siozeof(lpri[0]) 
    	{
    		if(rpri[i].op == op)//如果 右运算符结构体有匹配的运算符 
    		{
    			return rpri[i].pri;//返回对应的运算符的优先级 
    		} 
    	} 
    	
    	return -1;//没有匹配的运算符 
    }
     
     
    int IsOp(char ch)//判断ch是否是运算符 
    {
    	//如果是指定的运算符则返回1,否则返回0 
    	if(ch == '*' || ch == '/' || ch == '+' || ch == '-' || ch == '(' || ch == ')' )
    	{
    		return 1;
    	}
    	else
    	{
    		return 0;
    	} 
    }
     
     
    int JudgePri(char lop,char rop)//判断左右运算符的优先级  左运算符大于右运算符返回1,相等返回0,左小于右返回-1 
    {
    	if(LeftPri(lop)> RightPri(rop))//左运算符大于右运算符返回1
    	{
    		return 1;
    	} 
    	else if(LeftPri(lop)== RightPri(rop))//相等返回0,只有左右括号这一种情况 
    	{
    		return 0;
    	}
    	else   //左运算符小于右运算符返回-1
    	{
    		return -1;
    	}
    }
     
     
    float CountExp(char* exp) //计算表表达式 
    {
    	
    	memset(&(num.data),0,SIZE);  //将num结构体中的数组data清零 
    	memset(&(op.data),0,SIZE);   //将op结构体中的数组data清零
    	num.top = -1;                //初始化栈顶指针     
    	op.top= -1;    
    	
    	op.data[++op.top] = '=';  //将'='进栈 ,先++
    	
    	int i = 0; //用来指示str位置 
    	char str[10] = {0};//临时存放字符串数字 
    	
    	while(*exp!='\0')    //循环扫描exp表达式 
    	{
    		
    		if(!IsOp(*exp))   //如果不是运算符 
    		{
    			i = 0;
    			memset(str,0,10);//每循环一次次清零 
    			while(*exp>='0' && *exp<='9')//是数字 
    			{
    				str[i++] = *exp++ ;//将数字字符添加到str中,添加后i加1 
    			}
    			str[i++] = '#';//人为加上结束符 ,辅助进行字符串转换为 float数字 
    			num.data[++num.top] =  Str2Float(str);//将字符串转换为 float数字并赋值给 num的data数组,注意top先++; 
    		}
    		else  //是运算符 
    		{
    			switch(JudgePri(op.data[op.top],*exp))
    			{
    				case -1://栈顶的运算符优先级低,进栈 
    						op.data[++op.top] = *exp; 
    						break;
    				case 0://优先级一样,说明是括号 ,只有这一种情况
    						op.top--;//将'('退栈
    						break;
    				case 1://栈顶的运算符优先级高,先出栈进行计算,后入栈
    						do
    						{
    							Count(op.data[op.top--]);//*/+- 运算 
    						}while(JudgePri(op.data[op.top],*exp) == 1);//直到栈顶的运算符优先级不比 右运算符的优先级高,才准备将右运算符入栈 
    
    						if(*exp != ')')//如果不是')'才入栈 
    						{
    							op.data[++op.top] = *exp; 
    						}
    						break;
    				default:
    						break;
    			} 
    			exp++;//继续向下扫描exp 
    		} 
    		
    	}
    	
    	
    	for(i = op.top;i>0;i--)//因为上面是按根据表达式执行的,扫描执行先压栈而没有执行的
    	{
    		Count(op.data[i]);
    	}
    	return num.data[0];  //执行完毕,num.data的第一个元素就是结果              
    }
     
     
    float Str2Float(char* str) //字符串转换为 float数字 
    {
    	float flt = 0.0;
    	while(*str >= '0' && *str <= '9')//是数字 
    	{
    		flt =  10*flt+*str++-'0'; 
    	}
    	//*str-'0'解释,比如当str="520",*str是字符'5'时,字符'5'的ASCII码 是 53,
            //而字符'0' 的ASCII码是48,那么 *str-'0' 的值是5,完成字符数字到数字的转换 
            // 10*解释: 比如当str="520",
    	    //第一次时flt = 10*0.0+'5'-'0' ==>是5 
            //第二次时flt = 10*5.0+'2'-'0' ==>是52
            //第三次时flt = 10*5.0+'2'-'0' ==>是520 完成字符串数字到数字的转换
    	return flt; 
    }
     
    void Count(char op)//*/+-运算 
    {
    	float temp = 0.0; //用来存放临时计算结果; 
    	switch(op)
    	{
    		case '*':
    				temp = num.data[num.top--];//取出两个数相乘 
    				temp *= num.data[num.top--];
    				num.data[++num.top] = temp;//将计算结果进栈 
    				break;
    		case '/':
    				temp = num.data[num.top--];//取出被除数 注意是倒着取的 
    				if(temp==0) //被除数不能为0 
    				{
    					printf("\n被除数为0\n");
    					return; 
    				}
    				temp =  num.data[num.top--]/temp; //取出除数         1 ÷2   1是除数,2是被除数 
    				num.data[++num.top] = temp;//将计算结果进栈 
    				break;
    		case '+':
    				temp = num.data[num.top--];//取出两个数相加 ,顺序不影响相加
    				temp += num.data[num.top--]; 
    				num.data[++num.top] = temp;//将计算结果进栈 
    				break;
    		case '-':
    				temp = (num.data[num.top--]);//取出被减数 ,注意是倒着取的 									
    				temp = (num.data[num.top--])-temp;
    				num.data[++num.top] = temp;//将计算结果进栈 
    				break;
    		default:
    				break;
    	}
    }
    

     

    五、注意

     

        有待进一步测试。

    展开全文
  • 计算表达式

    2020-05-19 17:14:03
    对于一个不存在括号的表达式进行计算 输入描述: 存在多种数据,每组数据一行,表达式不存在空格 输出描述: 输出结果 示例1 输入 6/2+3+3*4 输出 18 题目解析:知道符号的优先级,6/2+3+3*4 = 3 + 3 + 12,所以表达式...

    题目描述
    对于一个不存在括号的表达式进行计算

    输入描述:
    存在多种数据,每组数据一行,表达式不存在空格

    输出描述:
    输出结果

    示例1
    输入
    6/2+3+3*4
    输出
    18

    题目解析:知道符号的优先级,6/2+3+3*4 = 3 + 3 + 12,所以表达式实际上最后是一个加减式。优先计算出/,*的部分表达式,最后将结果加在一起。

    代码:

    #include<stdio.h>
    #include<math.h>
    #include<algorithm>
    #include<string.h>
    #include<iostream>
    #include<vector>
    #include<map>
    #include<iomanip>
    using namespace std; 
    const int N = 10000;
    //也可以用中缀表达式求,用栈求中缀表达式。
    //这一种有点缺陷,不会计算1 + 2,可以看我的简单计算器
    
    int main(){
    	double number;
    	char fuhao;
    	double d[N];
    	while(cin >> number){
    		memset(d , 0 , sizeof(d));
    		d[0] = number;
    		int t = 1;
    		while(scanf("%c" , &fuhao) != EOF && fuhao != '\n'){
    			cin >> number;
    			switch(fuhao){
    				case '+':
    					d[t] = number;
    					break;
    				case '-':
    					d[t] = -number;
    					break;
    				case '*':
    					t--;
    					d[t] = d[t] * number;
    					break;
    				case '/':
    					t--;
    					d[t] = d[t] / number;
    					break;
    			}
    			t++;
    		}
    		double rst = 0;
    		for(int i = 0 ; i < t ; i++){
    			rst += d[i];
    		}
    		cout << int(rst) << endl;
    	}
    	return 0;
    }
    
    /* 利用中缀表达式,用栈求中缀表达式。有时间可以完善,出错地方已标出 
    
    #include<stdio.h>
    #include<math.h>
    #include<algorithm>
    #include<string.h>
    #include<iostream>
    #include<vector>
    #include<queue>
    #include<stack>
    #include<map>
    #include<iomanip>
    using namespace std;
    
    int computernum(string number){
    	int sum = 0;
    	int count = number.size() - 1;
    	for(int i = 0 ; i < number.size(); i++){
    		sum += (number[i] - '0') * pow(10,count);
    	}
    	return sum;
    }
    
    int computerResult(int number1, int number2, char fuhao){
    	
    	int rst = 0;
    	switch(fuhao){
    		case '+':
    			rst = number1 + number2;
    			break;
    		case '-':
    			rst = number1 - number2;
    		    break;
    		case '*':
    			rst = number1 * number2;
    			break;
    		case '/':
    			rst = number1 / number2;
    			break;
    	}
    	cout << "number1: " << number1 << " number2: " << number2 << " fuhao: "<<fuhao << " rst: " << rst << endl;
    	return rst;
    }
    
    bool betterfuhao(char a,char b){
    	cout << a << " : " << b<< endl;
    	if((b == '/' && a == '+') || (b == '/' && a == '-') || (b == '*' && a == '+') || (b == '*' && a == '-')){
    	  	return true;
    	}else{
    	  	return false;
    	}
    }
    int main()
    {
    	string function;
    	vector<string> vc;
    	vector<char> vc1;
    	stack<int> st1;
    	stack<char> st2;
    	while(cin >> function){
    		string temp1,temp2;
    		int index = 0;
    		for(int i = 0; i < function.size(); i++){
    			if(function[i] == '/' || function[i] == '+' || function[i] == '-' ||function[i] == '*'){
    				vc.push_back(function.substr(index,i-index));
    				vc1.push_back(function[i]);
    				index = i + 1;
    			}
    		}
    		vc.push_back(function.substr(index, (function.size() - index)));
    		st1.push(computernum(vc[0]));
    		for(int i =1 ; i < vc.size(); i++){
    			if(st2.empty()){        //栈空,直接放
    			    st1.push(computernum(vc[i]));
    				st2.push(vc1[i - 1]);
    			}else{ 
    				if(betterfuhao(st2.top(),vc1[i - 1])){    //优先级大进 
    					st2.push(vc1[i - 1]);
    				}else{                       //优先级小出去 
    					char fuhao = st2.top();
    					st2.pop();
    					st2.push(vc1[i - 1]);        //出去了再进来优先级小的 (******这里有问题,需要继续比较符号大小)
    					int number2 = st1.top();
    					st1.pop();
    					int number1 = st1.top();
    					st1.pop();
    					int rst = computerResult(number1,number2,fuhao);  //计算
    					st1.push(rst);                         
    				}
    				st1.push(computernum(vc[i]));
    			}
    		}
    		int t = st2.size();
    		for(int i = 0; i < t;i++){
    			char fuhao = st2.top();
    			st2.pop();
    			int number2 = st1.top();
    			st1.pop();
    			int number1 = st1.top();
    			st1.pop();
    			int rst = computerResult(number1,number2,fuhao);
    			st1.push(rst);
    		}
    		cout << st1.top() << endl;
    		vc.clear();
    		vc1.clear();
    		st1.pop();
    	}
        return 0;
    }
    */	
    
    展开全文
  • 表达式计算

    2020-02-22 22:44:50
     输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。 输入格式  输入一行,包含一个表达式。 输出格式  输出这个表达式的值。 样例输入 1-2+3*(4-5) 样例输出 -4 数据规模和约定  ...

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

    #include <stdio.h>
    #include <string.h>
    typedef struct {
    	int top,sz[100];
    }nur;
    typedef struct {
    	int top;
    	char sign[100];
    }fh;
    
    void calcu(nur*,fh*);
    void popFh(fh*,char*);
    void pushFh(fh*,char);
    void pushNur(nur*,int);
    int ssz(char*);
    void popNur(nur*,int*);
    void cal(char*);
    int yxj(char);
    int main(void) 
    {
    	char zfc[100+1];
    	scanf("%s",zfc);
    	int out = 0;
    	cal(zfc);
    	return 0;
    }
    void popFh(fh*fhs,char*s)
    {
    	*s = fhs->sign[fhs->top--];
    }
    void calcu(nur*nurs,fh*fhs)
    {
    	int a,b;
    	popNur(nurs,&b);
    	popNur(nurs,&a);
    	char c;
    	popFh(fhs,&c);
    	switch(c)
    	{
    		case '+':
    		a += b;
    		break;
    		case '-':
    		a -= b;
    		break;
    		case '*':
    		a *= b;
    		break;
    		case '/':
    		a /= b;
    		break;
    	}
    	pushNur(nurs,a);
    }
    
    void pushFh(fh*f,char ch)
    {
    	f->sign[++f->top] = ch;
    }
    void pushNur(nur*n,int num)
    {
    	n->sz[++n->top] = num;
    }
    int ssz(char*z)
    {
    	return *z <= '9' && *z >= '0';
    }
    
    void popNur(nur*n,int*v)
    {
    	*v = n->sz[n->top];
    	n->top--;
    }
    void cal(char*zfc)
    {
    	nur nurs = {0};
    	nurs.top = -1;
    	fh fhs = {0};
    	fhs.top = -1;
    	int flag = 0;
    	while(*zfc != '\0')
    	{
    		int tmp = 0;
    		if(ssz(zfc))
    		{
    			if(flag)
    			{
    				popNur(&nurs,&tmp);
    			}
    			else
    			{
    				tmp = 0;	
    			}
    			flag = 1;
    			tmp = 10*tmp + (*zfc - '0');
    			pushNur(&nurs,tmp);
    		}
    		else if(*zfc == '+' ||*zfc == '-' ||*zfc == '*' ||*zfc == '/')
    		{
    			flag = 0;
    			while(fhs.top > -1 && fhs.sign[fhs.top] != '(' && (yxj(fhs.sign[fhs.top]) >= yxj(*zfc)))
    			{
    				calcu(&nurs,&fhs);
    			}
    			pushFh(&fhs,*zfc);	 
    		}
    		else if(*zfc == '(')
    		{
    			flag = 0;
    			pushFh(&fhs,*zfc);
    		}
    		else
    		{
    			flag = 0;
    			while(fhs.sign[fhs.top] != '(')
    			{
    				calcu(&nurs,&fhs);
    			}
    			char ch;
    			popFh(&fhs,&ch);
    		}
    		zfc++;
    	}
    	while(fhs.top >= 0)
    	{
    		calcu(&nurs,&fhs);
    	}
    	printf("%d",nurs.sz[0]);
    }
     
    int yxj(char c)
    {
    	switch(c)
    	{
    		case '+':
    		case '-':
    		return 1;	
    		case '*':
    		case '/':
    		return 2;
    		case '(':
    		case ')':
    		return 3;
    	}
    }
    
    展开全文
  • 数学计算表达式解析

    千次阅读 2019-01-16 11:29:54
    用了将近两个晚上的时间,终于完成了大部分表达式的解析,写这篇文章来记录下遇到的问题。 问题 动态字符串实现 最棘手的就是动态内存的分配,在这块遇到了很大的困难,经过百度,也是解决了问题。 参考链接:...

    写在前面

    最近在写一个计算器的项目,其中最麻烦的就是数学表达试的解析,用C语言解决问题,每一步基本都要自己实现,非常锻炼逻辑能力。用了将近两个晚上的时间,终于完成了大部分表达式的解析,写这篇文章来记录下遇到的问题。

    问题

    动态字符串实现

    最棘手的就是动态内存的分配,在这块遇到了很大的困难,经过百度,也是解决了问题。
    参考链接:https://blog.csdn.net/ljwy1234/article/details/79036371
    涉及到二维指针。

    解析

    这个程序主要解决的是括号,乘除,加减的运算优先级的处理。
    参考链接:https://blog.csdn.net/yorhomwang/article/details/76691459
    主要思想和这篇博客中的一样:

    1. 首先进行括号代换,就是将括号中的表达式单独计算出来,计算出来的字符串代替原来括号的位置。
    2. 然后进行乘除晕眩,将解析式中的乘除单独计算出来,计算出来的字符串代替原来乘除的位置。
    3. 最后进行加减法的运算,从左到右进行计算,得到结果。

    代码中运用到了指针数组,数组中存放的都是指针,每个指针指向表达式中的子串。
    这种方法可以运用于命令行参数的解析。

    代码示例

    代码可以直接运行

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    /****************************str*****************************/
    
    char *str_init()
    {
        char *p = (char *)malloc(1);
        p[0] = '\0';
    
        return p;
    }
    
    void str_free(char *p)
    {
        free(p);
    }
    
    void str_append(char **src, const char *str)
    {
        int len = strlen(*src) + strlen(str);
    
        char *str1_tmp = *src;  //保存原来指针位置
        *src = (char *)malloc(len + 1); //重新申请内存
    
        //操作
        strcpy(*src, str1_tmp);
        strcat(*src, str);
        (*src)[len] = '\0';
    
        free(str1_tmp);
    }
    /****************************str*****************************/
    
    
    /****************************calculate*****************************/
    void deal_split(char *a, int len, char *list[])
    {
        int i = 0, j = 0;
    
        list[j++] = &a[0];
        for (i = 0; i < len; i++)
        {
            if (a[i] == ' ')
            {
                a[i] = '\0';
                list[j++] = &a[i + 1];
            }
        }
    }
    
    //加减
    int deal_add_sub(char *str)
    {
        //分割
        char *list[30] = { NULL };
        deal_split(str, strlen(str), list);
    
        int result = atoi(list[0]);
        int i = 0;
        for (i = 1; i < 10 && list[i] != NULL; i += 2)
        {
            if (*list[i] == '+')
            {
                result += atoi(list[i + 1]);
            }
            if (*list[i] == '-')
            {
                result -= atoi(list[i + 1]);
            }
        }
        return result;
    }
    
    //乘除
    char *deal_mul_div(char *str)
    {
        //分割
        char *list[30] = { NULL };
        deal_split(str, strlen(str), list);
    
        char *dst = str_init(); //输出字符串
        char *temp = list[0];
    
        char itoa_temp[10] = {0};
    
        int i = 0;
        for (i = 1; i < 30 && list[i] != NULL; i += 2)
        {
            if (*list[i] == '+')
            {
                str_append(&dst, temp);
                str_append(&dst, " + ");
                temp = list[i + 1];
            }
            else if (*list[i] == '-')
            {
                str_append(&dst, temp);
                str_append(&dst, " - ");
                temp = list[i + 1];
            }
            else if (*list[i] == '*')
            {
                int value = atoi(temp);
                value *= atoi(list[i + 1]);
                itoa(value, itoa_temp, 10);
                temp = itoa_temp;
            }
            else if (*list[i] == '/')
            {
                int value = atoi(temp);
                value /= atoi(list[i + 1]);
                itoa(value, itoa_temp, 10);
                temp = itoa_temp;
            }
        }
        str_append(&dst, temp);
        return dst;
    }
    
    void printf_list(char *list[])
    {
        int iii = 0;
        for (iii = 0; iii < 30 && list[iii] != NULL; iii++)
        {
            printf("%s\n", list[iii]);
        }
    }
    
    //括号
    char *deal_bracket(char *str)
    {
        //分割
        char *list[30] = { NULL };
        deal_split(str, strlen(str), list);
    
        char *dst = str_init(); //输出字符串
        char *dst_temp = str_init();
        char *temp = list[0];
    
        char itoa_temp[10] = {0};
    
        int i = 0;
        for (i = 1; i < 30 && list[i] != NULL; i++)
        {
            if (*list[i] == '+')
            {
                str_append(&dst, temp);
                str_append(&dst, " + ");
                temp = list[i + 1];
            }
            else if (*list[i] == '-')
            {
                str_append(&dst, temp);
                str_append(&dst, " - ");
                temp = list[i + 1];
            }
            else if (*list[i] == '*')
            {
                str_append(&dst, temp);
                str_append(&dst, " * ");
                temp = list[i + 1];
            }
                    else if (*list[i] == '/')
            {
                str_append(&dst, temp);
                str_append(&dst, " / ");
                temp = list[i + 1];
            }
            else if (*list[i] == '(')
            {
                i++;
                str_append(&dst_temp, list[i]);
    
                i++;
                while (*list[i] != ')')
                {
                    str_append(&dst_temp, " ");
                    str_append(&dst_temp, list[i]);
                    i++;
                }
    
                char *p1 = deal_mul_div(dst_temp);
                int value = deal_add_sub(p1);
    
                itoa(value, itoa_temp, 10);
                temp = itoa_temp;
            }
        }
        str_append(&dst, temp);
    
        str_free(dst_temp);
        return dst;
    }
    
    /****************************calculate*****************************/
    
    int main()
    {
        char a[100] = "6 / 2 + ( 2 * 5 + 2 * 2 ) - 9 / 3";
        printf("original = %s\n", a);
        char *p = deal_bracket(a);
        printf("bracket  = %s\n", p);
        char *pp = deal_mul_div(p);
        str_free(p);
        printf("mul_div  = %s\n", pp);
        int ppp = deal_add_sub(pp);
        str_free(pp);
        printf("result   = %d\n", ppp);
    
        return 0;
    }
    
    

    反思

    展开全文
  •  输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除 输入格式  输入一行,包含一个表达式 输出格式  输出这个表达式的值 样例输入 1-2+3*(4-5) 样例输出 -4 数据规模和约定  ...
  • 计算中缀表达式

    万次阅读 多人点赞 2018-05-10 20:57:03
    转载自https://blog.csdn.net/qq_26286193/article/details/80214805“计算中缀表达式”可以称得上是一个特别经典的关于栈的算法题,几乎在所有数据结构教材中都会涉及,而且很多公司面试或者笔试的时候都会把这道题...
  • 计算机如何计算我们的表达式

    千次阅读 2018-07-21 22:33:30
    计算机的工作本质就是做数学运算,计算机喜欢做后缀运算,而我们自己却是喜欢做中缀运算, 所以计算机就会自动将我们的中缀运算转化成后缀...1遍历中缀表达式的数字的符号,对于数字,直接输出。 2对于符号:左括...
  • 【经典算法】-算术表达式求值

    万次阅读 2017-09-28 18:26:07
    中缀表达式如果要先计算操作符优先级低的两个数,比如上面要优先计算3+4,这里就必须带括号,指明计算的优先级,负责就会按照操作符默认的优先级来计算。 后缀表达式(逆波兰表达式) 上
  • Java 中计算字符串表达式的值

    千次阅读 2018-08-25 10:54:44
    Java 中计算字符串表达式的值 在 Java 中计算字符串数值表达式可以用 javax.script.ScriptEngine#eval(java.lang.String),通过调用 JavaScript 来计算 import javax.script.ScriptEngine; import javax.script...
  • python2中input输入表达式: python3中input输入表达式: 此时在输出时,将参数加上eval转化就可以了
  • c语言中表达式的运算顺序

    万次阅读 2016-10-25 20:31:36
    c语言中表达式的运算顺序由优先级和结合性决定。 1.先按运算符优先级运算。2.如果相邻若干个运算符优先级相同,则按结合方向来运算。 比如:1+2-3*4的运算为:有优先级先做*运算,3*4得到12;表达式为1+2-12,算数...
  • 表达式计算结果必须为节点集。

    千次阅读 2018-02-08 13:23:49
    表达式计算结果必须为节点集。在使用 Html Agility Pack:c# HTML 解析利器 对 HTML 进行解析时,如果你使用的 选择器 是 类似JQuery、jsoup 的 Selector,那么你将经常遇到这样的错误!如下图:因为 ...
  • 1.中缀表达式转换成后缀表达式: 首先需要注意的是:中缀转后缀的结果并不唯一。例如:(a+b+c*d)/e是一个中缀表达式,ab+cd*+e/与abcd*++e/都是其后缀表达式。 转换方式:先根据中缀表达式的各操作符的优先级,...
  • 图解后缀表达式计算过程

    万次阅读 多人点赞 2016-08-11 22:51:11
    为了解释后缀表达式的好处,我们先来看看,计算机如何应用后缀表达式计算出最终的结果20的。 后缀表达式:9 3 1-3*+ 10 2/+ 规则:从左到右遍历表达式的每个数字和符号,遇到是数字就进栈,遇到是符号...
  • 一般我们平时用的计算式都是中缀表达式,因为符号都是在操作数的中间的。相对应的符号在操作数后面的就叫后缀表达式(也称逆波兰式),符号在操作数前面的就叫前缀表达式(也称波兰式)。 为什么要把中缀表达式转化...
  • 然后往界面里面添加功能,添加完之后,编译通过了,但是在点到某一个按钮的时候,出现说:“读取位置是访问位置冲突”,通过调试,发现里面很多位置的变量显示:“cxx0030 错误 无法计算表达式的值” 解决办法: ...
  • 后缀表达式计算

    千次阅读 2016-09-12 08:37:46
    1.中缀表达式转后缀表达式;2.后缀表达式计算
  • C++三元运算符?:

    万次阅读 2016-04-19 13:55:21
    C++有3种运算符:算数运算符、关系运算符和逻辑运算符。运算符在计算机中的执行顺序 ...如果代码行中的运算符比较多,用括号确定表达式中每一个子表达式计算顺序,避免使用默认优先级。C++中唯一
  • 算法渐近表达式、算法规模习题

    千次阅读 2019-05-04 22:49:14
  • java 8 lambda 表达式的优缺点总结

    万次阅读 2018-12-12 15:00:08
    最近接触到 lambda 表达式后,发现它基本上可以消灭所有 for 循环,换句话说,所有的 for 循环都能被 lambda 表达式改写。 但我发现,它并不是特别完美的,经过我查阅国内外不少网站的资料,加上自己试验,总结出...
1 2 3 4 5 ... 20
收藏数 590,924
精华内容 236,369
关键字:

计算表达式