精华内容
下载资源
问答
  • 四则运算表达式求值(利用前缀后缀表达式)
    千次阅读
    2019-04-11 11:27:36

    个人主页:http://redtongue.cn or https://redtongue.github.io/

    中缀表达式

    中缀表达式就是常见的运算表达式,如(3+4)*5-6
    

    前缀表达式

    前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前
    比如:- * + 3 4 5 6
    

    前缀表达式的计算机求值

    从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,
    弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 op 次顶元素),
    并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果
    

    例子(- * + 3 4 5 6)

    1. 从右至左扫描,将6、5、4、3压入堆栈
    2. 遇到+运算符,因此弹出3和4(3为栈顶元素,4为次顶元素,注意与后缀表达式做比较),计算出3+4的值,得7,再将7入栈
    3. 接下来是*运算符,因此弹出7和5,计算出7×5=35,将35入栈
    4. 最后是-运算符,计算出35-6的值,即29,由此得出最终结果

    将中缀表达式转换为前缀表达式

    1. 初始化两个栈:运算符栈s1,储存中间结果的栈s2

    2. 从右至左扫描中缀表达式

    3. 遇到操作数时,将其压入s2

    4. 遇到运算符时,比较其与s1栈顶运算符的优先级

      1. 如果s1为空,或栈顶运算符为右括号“)”,则直接将此运算符入栈
      2. 否则,若优先级比栈顶运算符的较高或相等,也将运算符压入s1
      3. 否则,将s1栈顶的运算符弹出并压入到s2中,再次转到(4-1)与s1中新的栈顶运算符相比较
    5. 遇到括号时

      1. 如果是右括号“)”,则直接压入s1
      2. 如果是左括号“(”,则依次弹出S1栈顶的运算符,并压入S2,直到遇到右括号为止,此时将这一对括号丢弃
    6. 重复步骤2至5,直到表达式的最左边

    7. 将s1中剩余的运算符依次弹出并压入s2

    8. 依次弹出s2中的元素并输出,结果即为中缀表达式对应的前缀表达式

    具体过程

    例如:1+((2+3)*4)-5具体过程,如下表

    扫描到的元素S2S1说明
    55数字,直接入栈
    -5-s1为空,运算符直接入栈
    )5-)右括号直接入栈
    454-)数字,直接入栈
    *54-)*s1栈顶是右括号,直接入栈
    )54-)*)右括号直接入栈
    )5 4-)x)右括号直接入栈
    35 4 3-)x)数字
    +5 4 3-)x)+s1栈顶是右括号,直接入栈
    25 4 3 2-)x)+数字
    (5 4 3 2 +-)x左括号,弹出运算符直至遇到右括号
    (5 4 3 2 + *-同上
    +5 4 3 2 + *-+优先级与-相同,入栈
    15 4 3 2 + * 1-+数字
    到达最左端5 4 3 2 + * 1 + -s1剩余运算符

    结果是:- + 1 × + 2 3 4 5

    后缀表达式

    后缀表达式又称逆波兰表达式,与前缀表达式相似,只是运算符位于操作数之后
    

    后缀表达式计算机求值

    与前缀表达式类似,只是顺序是从左至右:
    从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,
    用运算符对它们做相应的计算(次顶元素 op 栈顶元素),并将结果入栈;
    重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果
    

    例子(3 4 + 5 * 6 -)

    1. 从左至右扫描,将3和4压入堆栈;
    2. 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素,注意与前缀表达式做比较),计算出3+4的值,得7,再将7入栈;
    3. 将5入栈;
    4. 接下来是×运算符,因此弹出5和7,计算出7×5=35,将35入栈;
    5. 将6入栈;
    6. 最后是-运算符,计算出35-6的值,即29,由此得出最终结果。

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

    1. 初始化两个栈:运算符栈s1和储存中间结果的栈s2;
    2. 从左至右扫描中缀表达式;
    3. 遇到操作数时,将其压s2;
    4. 遇到运算符时,比较其与s1栈顶运算符的优先级:
      1. 如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
      2. 否则,若优先级比栈顶运算符的高,也将运算符压入s1(注意转换为前缀表达式时是优先级较高或相同,而这里则不包括相同的情况);
      3. 否则,将s1栈顶的运算符弹出并压入到s2中,再次转到(4-1)与s1中新的栈顶运算符相比较;
    5. 遇到括号时:
      1. 如果是左括号“(”,则直接压入s1;
      2. 如果是右括号“)”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃;
    6. 重复步骤2至5,直到表达式的最右边;
    7. 将s1中剩余的运算符依次弹出并压入s2;
    8. 依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式(转换为前缀表达式时不用逆序)

    具体过程

    例如,将中缀表达式“1+((2+3)*4)-5”转换为后缀表达式的过程如下:

    扫描到的元素S2S1说明
    11数字,直接入栈
    +1+s1为空,运算符直接入栈
    (1+ (左括号,直接入栈
    (1+ ( (同上
    21 2+ ( (数字
    +1 2+ ( ( +s1栈顶为左括号,运算符直接入栈
    31 2 3+ ( ( +数字
    )1 2 3 ++ (右括号,弹出运算符直至遇到左括号
    *1 2 3 ++ ( *s1栈顶为左括号,运算符直接入栈
    41 2 3 + 4+ ( *数字
    )1 2 3 + 4 *+右括号,弹出运算符直至遇到左括号
    -1 2 3 + 4 * +--与+优先级相同,因此弹出+,再压入-
    51 2 3 + 4 * + 5-数字
    到达最右端1 2 3 + 4 * + 5 -s1中剩余的运算符

    因此结果为“1 2 3 + 4 × + 5 -”

    备注

    参考 https://www.cnblogs.com/chensongxian/p/7059802.html

    代码是自己有python搞得,transform可以去除空格,一般题目里面有这样的需求。

    源代码

    class Solution:
    def calculator(self,s):
        li=self.transform(s)
        print('li',li)
        forward=self.forward(li)
        print("forward",forward)
        result1=self.calForward(forward)
        print("result1:",result1)
    
        back=self.back(li)
        print("back",back)
        result2=self.calBack(back)
        print("result2:",result2)
    
    def calBack(self,back):#计算后缀表达式
        s=[]
        for i in range(len(back)):
            if(isinstance(back[i],int)):
                s.append(back[i])
            else:
                b=s.pop()
                a=s.pop()
                s.append(self.cal(a,b,back[i]))
        if(len(s)==0):
            return None
        return s[-1]
    
    def back(self,li):#得到后缀表达式
        s1=[]
        s2=[]
        for i in range(len(li)):
            if(isinstance(li[i],int)):#li[i]是数字
                s2.append(li[i])
            elif(li[i] in '+-*/'):#li[i]是运算符
                while(True):
                    if(len(s1)==0 or s1[-1]=='('):#s1为空或栈顶为‘(’,压栈
                        s1.append(li[i])
                        break
                    elif(self.get(li[i])>self.get(s1[-1])):#优先级大于等于栈顶,压栈
                        s1.append(li[i])
                        break
                    else:#s1的栈顶元素压入s2,重复上述步骤
                        s2.append(s1.pop())
            else:
                if(li[i]=='('):#右括号压栈
                    s1.append(li[i])
                else:#左括号,将s1栈顶元素压入s2,直至遇到右括号
                    tar=s1.pop()
                    while(tar!='('):
                        s2.append(tar)
                        tar=s1.pop()
        while(s1):
            s2.append(s1.pop())
        return s2
    
    def calForward(self,forward):#计算前缀表达式
        s=[]
        for i in range(len(forward)):
            if(isinstance(forward[i],int)):
                s.append(forward[i])
            else:
                a=s.pop()
                b=s.pop()
                s.append(self.cal(a,b,forward[i]))
        if(len(s)==0):
            return None
        return s[-1]
    
    def forward(self,li):#得到前缀表达式
        s1=[]
        s2=[]
        for i in range(len(li)-1,-1,-1):
            if(isinstance(li[i],int)):#li[i]是数字
                s2.append(li[i])
            elif(li[i] in '+-*/'):#li[i]是运算符
                while(True):
                    if(len(s1)==0 or s1[-1]==')'):#s1为空或栈顶为‘)’,压栈
                        s1.append(li[i])
                        break
                    elif(self.get(li[i])>=self.get(s1[-1])):#优先级大于等于栈顶,压栈
                        s1.append(li[i])
                        break
                    else:#s1的栈顶元素压入s2,重复上述步骤
                        s2.append(s1.pop())
            else:
                if(li[i]==')'):#右括号压栈
                    s1.append(li[i])
                else:#左括号,将s1栈顶元素压入s2,直至遇到右括号
                    tar=s1.pop()
                    while(tar!=')'):
                        s2.append(tar)
                        tar=s1.pop()
        while(s1):
            s2.append(s1.pop())
        return s2
                
    
    def transform(self,s):#转换字符串,得到数字和运算符的链表形式
        li=[]
        judge=False
        index=0
        for tar in s:
            if(tar==' '):
                continue
            elif(tar in '+-*/()'):
                if(judge):
                    li.append(index)
                    judge=False
                    index=0
                li.append(tar)
            else:
                index=index*10+int(tar)
                judge=True
        if(judge):
            li.append(index)
        return li
    
    def cal(self,a,b,ch):#计算
        if(ch=='+'):
            return a+b
        elif(ch=='-'):
            return a-b
        elif(ch=='*'):
            return a*b
        elif(ch=='/'):
            return a/b
        else:
            return 0
    
    def get(self,ch):#得到优先级
        if(ch in '+-'):
            return 1
        elif(ch in '*/'):
            return 3
        else:
            return 0
    
    更多相关内容
  • 主要介绍了java实现任意四则运算表达式求值算法,实例分析了基于java实现表达式四则运算求值的原理与技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 四则运算表达式求值

    2019-03-14 11:11:15
    按中缀形式输入一个四则运算表达式,利用算法优选算法把其转换为后缀表达式输出,并求表达式。假设输入的表达式中的操作数都是1位整数。
  • java实现四则运算表达式求值

    千次阅读 2019-10-16 21:05:50
    中缀表达式就是"9+(3-1)×3+10÷2",相对应的后缀表达式是"9 3 1 - 3 * + 10 2 /",叫后缀的原因在于所有的符号都是要在运算数字的后面出现,而且没有括号,这样的表述对于我们来说是很难受的,但我们聪明的计算机...

    先来个例子 9+(3-1)×3+10÷2,最重要的就是两步

    ①将中缀表达式转化为后缀表达式
    ②将后缀表达式进行运算得出结果

    那么什么是中缀和后缀表达式呢?

    中缀表达式就是"9+(3-1)×3+10÷2",相对应的后缀表达式是"9 3 1 - 3 * + 10 2 /",叫后缀的原因在于所有的符号都是要在运算数字的后面出现,而且没有括号,这样的表述对于我们来说是很难受的,但我们聪明的计算机喜欢。

    1.将中缀表达式转化为后缀表达式

    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2.将后缀表达式进行运算得出结果

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    附代码如下

    import java.util.Stack;
    
    public class Calculator {
        public static int priority(char a) {//判断符号优先级
            switch (a) {
                case '+':
                case '-':
                case '(':
                    return 1;
                case '*':
                case '/':
                    return 2;
            }
            return 0;
        }
    
        public static char[] middleToBack(String exp) {//中缀表达式转后缀表达式
            Stack<Character> stack = new Stack();//栈用来进出运算的符号
            char[] arr = exp.toCharArray();
            char[] brr = new char[arr.length * 2];//保存后缀表达式,需在数字和符号之间加空格区分,因此长度定为arr的2倍
            int count = 0;//标记brr
    
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length - 1) {//防止越界
                    brr[count++] = arr[i];
                    brr[count++] = ' ';
                } else if ((arr[i] >= '0' && arr[i] <= '9') && !(arr[i + 1] >= '0' && arr[i + 1] <= '9')) {
                    brr[count++] = arr[i];
                    brr[count++] = ' ';
                } else if (arr[i] >= '0' && arr[i] <= '9') {
                    brr[count++] = arr[i];
                } else {//符号
                    if (stack.isEmpty()) {
                        stack.push(arr[i]);
                    } else if (arr[i] == '(') {
                        stack.push(arr[i]);
                    } else if (arr[i] == ')') {
                        while (stack.peek() != '(') {//'('与')'之间的符号出栈
                            brr[count++] = stack.peek();
                            brr[count++] = ' ';
                            stack.pop();
                        }
                        stack.pop();//将'('出栈
                    } else if (priority(arr[i]) >= priority(stack.peek())) {//如果优先级高于或等于栈顶元素,直接入栈
                        stack.push(arr[i]);
                    } else if (priority(arr[i]) < priority(stack.peek())) {//如果优先级低于栈顶元素,依次出栈
                        while (!stack.isEmpty()) {
                            brr[count++] = stack.peek();
                            brr[count++] = ' ';
                            stack.pop();
                        }
                        stack.push(arr[i]);
                    }
                }
            }
            while (!stack.empty()) {
                brr[count++] = stack.peek();
                brr[count++] = ' ';
                stack.pop();
            }
            System.out.print(brr);
            System.out.println();
            return brr;
        }
    
        public static void calculate(char[] brr) {//后缀表达式求得计算结果
            Stack<Integer> stack = new Stack();//栈用来进出运算的数字
            for (int i = 0; i < brr.length; ) {
                String number = "";
                if (brr[i] == ' '||brr[i]=='\0') {//空格或为空
                    i++;
                    continue;
                }
                if (brr[i] >= '0' && brr[i] <= '9') {//数字入栈
                    while (brr[i] >= '0' && brr[i] <= '9') {
                        number += brr[i];
                        i++;
                    }
                    stack.push(Integer.valueOf(number));//字符型转整型入栈
                } else if(brr[i]=='+'||brr[i]=='-'||brr[i]=='*'||brr[i]=='/') {//符号
                    int top1 = stack.peek();
                    stack.pop();
                    int top2 = stack.peek();
                    stack.pop();
                    int result = operate(top2,top1,brr[i]);//注意top2和top1的位置
                    stack.push(result);
                    i++;
                }
            }
            System.out.println(stack.peek());
        }
    
        public static int operate(int item1, int item2, char operator) {
            int result = 0;
            switch (operator) {
                case '+':
                    result = item1 + item2;
                    break;
                case '-':
                    result = item1 - item2;
                    break;
                case '*':
                    result = item1 * item2;
                    break;
                case '/':
                    result = item1 / item2;
                    break;
            }
            return result;
        }
    
        public static void main(String[] args) {
            String exp = "9+(3-1)*3+10/2";
            char[] brr = middleToBack(exp);
            calculate(brr);
        }
    }

    测试结果
    在这里插入图片描述
    参考书籍:《大话数据结构》 程杰 著

    展开全文
  •   ...   ...该题目有两个版本。...这个题目还有一种更常用的方法就是用栈来做,栈的表达式求值。在数据结构里学过。 在这里主要用来训练递归。          

                                                                                                                                                点击此处返回总目录

     

    该题目有两个版本。

    第一个版本是简化了的版本,假设运算符和结果都是整数。

    第二个版本是复杂一些,即POJ 4132的题目,数字可以是小数。

     

     

    一、简单版本

    【题目】

     

    其中表达式的定义为:

     

                 

     

    【分析】

    表达式的定义用到了项的定义。

    项的定义用到了因子,项就是任意多个因子通过乘号或除号连在一块。

    因子怎么定义的呢。因子可以是一个整数,也可以是左括号+表达式+有括号。

     

    这时候就用到了递归,在因子里面用到了表达式的定义,在表达式定义中用到了项,在项的定义中又用到了因子的定义。这实际上就是间接的递归。

    单个的整数是因子,就是整个递归的出口。

     

     

    这道题目是比较难的,用到了java中的预读取字节的方法。

    InputStream.mark(i)      //在现在这个地方做一下几号。这样就可以读一些字节进来,如果读的字节数不超过i位,

                                            可以使用InputStream.reset()函数回到刚才标记的位置。

     

     

    【代码】

     

     

    【结果】

     

     

     

    -----------------------------------------------------------------------------------------------------------------------------

    二、复杂版本(POJ 4132)

     

    【题目】

     

     

    【代码】

     

    【结果】

     

     

    不知道为什么,在POJ里面提交不通过,报错了

    我觉得可能是输入的原因,大家可以帮我检查,不胜感谢~~

     

     

     

     

    【总结】

    这个题目还有一种更常用的方法就是用栈来做,栈的表达式求值。在数据结构里学过。

    在这里主要用来训练递归。

     

     

     

     

     

    展开全文
  • 预备知识: 栈:栈是限定仅在表尾... 中缀表达式:我们平常所用的四则表达式就是中缀表达式 后缀表达式:所有符号都是在运算数字的后面出现,这就是后缀表达 中缀表达式转后缀表达式: 从左到右遍历中缀表达式的...

    预备知识:

    • 参考书籍《大话数据结构》、《算法笔记》
    • 栈:栈是限定仅在表尾进行插入和删除操作的线性表;栈又称为是后进先出的线性表;
    • 图解:
    •     队列:队列是只允许在一端进行插入,而在另一端进行删除操作的线性表,即队列是一种先进先出的线性表。
    •     图解:
    •  中缀表达式:我们平常所用的四则表达式就是中缀表达式(比如:9+(3-1)x3+10÷2)
    • 后缀表达式:所有符号都是在运算数字的后面出现,这就是后缀表达(比如:9 3 1 - 3 * +10 2 / +)

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

    • 从左到右遍历中缀表达式的每个数字和符号,若是数字就输出,即变成后缀表达式的一部分;若是符号,则判断其与栈顶符号的优先级,如果优先级高于栈顶符号,则栈顶元素依次出栈并输出,并将当前符号进栈,一直到最终输出后缀表达式为止。

    后缀表达式进行计算 :

    • 从左到右遍历表达式的每个数字和符号,遇到是数字就进栈,遇到是符号,就将处于栈顶的两个数字输出,进行运算,运算结果进栈,一直到最终获得结果。

    NO code you say a .....

    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<stack> 
    #include<map>
    #include<queue>
    using namespace std;
    struct node{
    	double num;//操作数 
    	char op;//操作符号 
    	bool flag;//true表示操作数,false表示操作符号 
    };
    
    string str;
    stack<node> s;//保存操作符的栈
    queue<node> q;//保存后缀表达式序列
    map<char,int> op;
    
    //将中缀表达式转换为后缀表达式 
    void Change(){
    	double num;
    	node temp;
    	for(int i=0;i<str.length();){
    		if(str[i]>='0'&&str[i]<='9'){//如果是数字 
    			temp.flag=true;//标记是数字
    			temp.num=str[i++]-'0';//记录这个操作数的第一个数位
    			while(i<str.length()&&str[i]>='0'&&str[i]<='9'){
    				temp.num=temp.num*10+(str[i]-'0');//更新这个操作数 
    				i++;
    			} 
    			q.push(temp);//将这个操作数压进后缀表达式的队列中 
    		}else{//如果是操作符
    			temp.flag=false;//标记是操作符
    			//只要操作符栈的栈顶元素比操作符优先级稿
    			//就把操作符栈顶元素弹出到后缀表达式的队列中
    			while(!s.empty()&&op[str[i]]<=op[s.top().op]){
    				q.push(s.top());
    				s.pop();
    			} 
    			temp.op=str[i];
    			s.push(temp);//把该操作符压入操作符栈
    			i++; 
    		}
    	}
    	//如果操作符栈中还有操作符,就把它弹出到后缀表达式的队列中
    	while(!s.empty()){
    		q.push(s.top());
    		s.pop();
    	} 
    } 
    
    double Cal(){//计算后缀表达式 
    	double temp1,temp2;
    	node cur,temp;
    	while(!q.empty()){//只要后缀表达式队列非空
    	    cur=q.front();//cur记录队首元素 
    		q.pop();
    		if(cur.flag==true) s.push(cur);//如果是操作数,直接压入栈 
    		else{//如果是操作符 
    			temp2=s.top().num;//弹出第二操作数 
    			s.pop();
    			temp1=s.top().num;//弹出第一操作数
    			s.pop();
    			temp.flag=true;//临时记录操作数
    			if(cur.op=='-') temp.num=temp1-temp2;//减法
    			else if(cur.op=='+') temp.num=temp1+temp2;//加法
    			else if(cur.op=='*') temp.num=temp1*temp2;//乘法
    			else temp.num=temp1/temp2;
    			s.push(temp); 
    		}
    		
    	}
    	return s.top().num;//栈顶元素就是后缀表达式的值 
    }
    int main()
    {
    	//设定操作符的优先级
    	op['+']=op['-']=1;
    	op['*']=op['/']=2;
    	while(getline(cin,str),str!="0"){
    		for(string::iterator it=str.end();it!=str.begin();it--){
    			if(*it==' ') str.erase(it);//把表达式中的空格都去掉 
    		}
    		while(!s.empty()) s.pop();//初始化栈
    		Change();//将中缀表达式转换为后缀表达式 
    		printf("%.2f\n",Cal());//计算后缀表达式 
    	} 
    	return 0;
     } 

     

    展开全文
  • C++四则运算表达式求值算法 C++四则运算表达式求值算法
  • 最近在看数据结构,其中栈的应用中有一个关于四则运算表达式求值。觉得有点意思,所以实现并记录之。 20世纪50年代,波兰逻辑学家Jan Łukasiewicz想到了一种不需要括号的后缀表达法,即逆波兰(Reverse Polish ...
  • 四则运算表达式求值(栈+二叉树-c++版).docx
  • 本课程设计为四则运算表达式求值,用于带小括号的一定范围内正负数的四则运算标准(中缀)表达式的求值。注意事项: 1、请保证输入的四则表达式的合法性。输入的中缀表达式中只能含有英文符号“+”、“-”、“*”、...
  • 湖南大学数据结构实验4四则运算表达式求值实验报告
  • 一个可以带括号的小学算术四则运算表达式 Input: 一行,一个四则运算表达式。'*'表示乘法,'/'表示除法 Output: 一行,该表达式的,保留小数点后面两位 Sample Input: 输入样例1: 3.4 输入样例2...
  • 例题: 四则运算表达式求值 输入为四则运算表达式,仅由整数、+、-、*、/ 、(、) 组成, 没有空格,要求。假设运算符结果都是整数 。 "/"结果也是整数 表达式可以为项或项加减 项可以为单因子或者因子乘除 ...
  • 通过学习《大话数据结构》,练习对栈的使用,此测试是四则运算表达式求值
  • Java实现四则运算表达式求值前言最近在复习数据结构与算法,在栈的应用中了解到计算机计算四则运算表达式的算法。计算机计算四则运算主要分两步: 将中缀表达式转化为后缀表达式; 将后缀表达式进行运算得出结果。 ...
  • 对于四则运算表达式,如 10+20-3*(10-5)+8 ,我们如何用程序实现这个运算表达式求值呢?可以使用 一种不需要括号的后缀表达法,我们也称为逆波兰(RPN)表示,如上面的例子 10+20-3*(10-5)+8,使用后缀表示法就变成...
  • 四则运算表达式求值思路说明使用双栈来实现——存放数值的栈nums与存放运算符的栈ops.算法步骤对原始表达式字符串exp进行预处理, 将其转为一个元素对应一个数值或运算符的列表explist.遍历explist, 每个元素依次压入...
  • 四则运算表达式求值(利用前缀后缀表达式)中缀表达式前缀表达式前缀表达式的计算机求值例子(- * + 3 4 5 6)将中缀表达式转换为前缀表达式具体过程结果是:- + 1 × + 2 3 4 5后缀表达式后缀表达式计算机求值例子...
  • #include #include #include using namespace std; /************************************************************************/ /* 表达式求值
  • 4132:四则运算表达式求值 总时间限制: 1000ms 内存限制: 65536kB 描述 一个可以带括号的小学算术四则运算表达式 输入 一行,一个四则运算表达式。’‘表示乘法,’/'表示除法 输出 一行,该表达式的,保留...
  • 栈与队列之栈的应用四则运算表达式求值 栈在四则运算表达式求值的应用为逆波兰表达式(后缀表达式) 普通算式(中缀表达式):9 + (3 - 1) * 3 + 10 / 2 ---(1) 逆波兰表达式(后缀表达式):9 3 1 - 3 * + ...
  • 栈的特点栈是计算机中非常基础而又极其重要的一种数据结构,许多算法的实现都离不开栈,它的特点是“先进后出”,也可以说“后进先出”。 打一个形象的比方:栈好比一个弹夹,最先放入...而最后放入的子弹最先打出。
  • 一种四则运算表达式求值算法,比如输入字符串“1+2*(3+5)-7”,输出结果10.
  • 1.前/中/后缀表达式的转换(首先需要明白三者之间的转换)   自然表达式转换为前/中/后缀表达式,其实是很简单的。首先将自然表达式按照优先级顺序,构造出与表达式相对应的二叉树,然后对二叉树进行前/中/后缀...
  • 用算法来实现简单表达式(指只包含+-*/四则运算及括号的表达式求值的困难在于无法从表达式直接确定运算的顺序。因为我们常用的表达式形式是:表达式+运算符+表达式(即中缀表达式)。我们无法确定“运算符”与后面...
  • 四则运算 表达式求值,可以计算小数,很有用哦。。可以学习和参考哈哈。。。。。。。。。。。。。
  • 四则运算表达式求值,是利用栈来完成四则运算,首先将中缀表达式转换为后缀表达式,最后使用计算机完成后缀表达式的运算。这两个均是栈的应用实例,递归的底层使用栈来实现,而四则运算的两个过程均使用栈来完成。
  • 输入一个只包含个位数字的简单四则运算表达式字符串,计算该表达式的 注: 表达式只含 +, -, *, /, (, ), 四则运算符 表达式数值只包含个位整数(0-9),且不会出现0作为除数的情况 要考虑加减乘除按通常四则运算...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,604
精华内容 61,841
关键字:

四则运算表达式求值