精华内容
下载资源
问答
  • 后缀表达式计算结果

    2016-03-10 10:04:44
    import java.util.Stack;public class StackApp { private Stack<String> stack; private String[] content; public StackApp(String content) { // TODO Auto-generated constructor stub
    import java.util.Stack;
    
    public class StackApp {
    
        private Stack<String> stack;
        private String[] content;
    
        public StackApp(String content) {
            // TODO Auto-generated constructor stub
            this.content = content.split(" ");
            this.stack = new Stack<String>();
        }
    
        public Stack<String> getStack() {
            return stack;
        }
    
    
        public void setStack(Stack<String> stack) {
            this.stack = stack;
        }
    
        public String[] getContent() {
            return content;
        }
    
        public void setContent(String[] content) {
            this.content = content;
        }
    
        public String calculate(){
            for(int i = 0; i < this.getContent().length; i++){
    
                if(
                        (
                        this.getContent()[i].equals("+") 
                        || this.getContent()[i].equals("-") 
                        || this.getContent()[i].equals("*") 
                        || this.getContent()[i].equals("/")
                        ) 
                        && 
                        this.getStack().size() >= 2
                    ){
    
                    this.getStack().push(this.getContent()[i]);
                    this.subcalculate();
                    continue;
    
                }else{
                    this.getStack().push(this.getContent()[i]);
                    continue;
                }
            }
    
    
            return this.getStack().isEmpty()? null : this.getStack().pop();
        }
    
        public void subcalculate(){
            //运算符
            String ch = this.getStack().pop();
            //两个运算数
            String a = this.getStack().pop();
            String b = this.getStack().pop();
            int rt = 0;
    
            switch (ch.charAt(0)) {
            case '+':
                rt = Integer.parseInt(b) + Integer.parseInt(a);
                this.getStack().push(String.valueOf(rt));
                break;
            case '-':
                rt = Integer.parseInt(b) - Integer.parseInt(a);
                this.getStack().push(String.valueOf(rt));
                break;
            case '*':
                rt = Integer.parseInt(b) * Integer.parseInt(a);
                this.getStack().push(String.valueOf(rt));
                break;
            case '/':
                rt = Integer.parseInt(b) / Integer.parseInt(a);
                this.getStack().push(String.valueOf(rt));
                break;
            default:
                System.out.println("未识别运算符");
                break;
            }
        }
    
    
        public static void main(String[] args) {
            String content = "9 3 1 - 3 * + 10 2 / +";
    
            StackApp sa = new StackApp(content);
            System.out.println(sa.calculate());
        }
    
    
    }
    

    参考《大话数据结构》
    一开始,构造函数没有new出栈,一直报空指针,哎~╮(╯_╰)╭

    展开全文
  • 在上一篇中缀表达式转换为后缀表达式,我们已经将中缀表达式转换为了后缀表达式,接下来我们看看怎么根据后缀表达式计算结果。       先创建一个数据结构,栈,作为存储。       ...

          在上一篇中缀表达式转换为后缀表达式,我们已经将中缀表达式转换为了后缀表达式,接下来我们看看怎么根据后缀表达式计算出结果。
          先创建一个数据结构,,作为存储。
          同样,我们把后缀表达式看作是一个字符串,然后从左到右一个一个字符进行判断,规则如下:

    • A.如果是数字,直接进栈
    • B.如果是+或*,(加法或乘法),则将弹出栈顶两个元素,进行相加或相乘,将计算结果压入栈中
    • C. 如果是-或/,(减法或除法),则弹出一个数字为x,弹出一个数字为y,然后y-x或y/x,最后将计算结果压入栈中

      后缀表达式的字符循环完成之后,栈里应该就只有一个数字,这个数字就是我们要的计算结果。
      以上一篇得到的后缀表达式 345*+678+9+ 为例,图示如下
      在这里插入图片描述
    1. 数字345,直接进栈
    2. 遇到*号,5乘4,计算结果20进栈
    3. 遇到+号,20加3,计算结果23进栈
    4. 遇到数字6和7,依次进栈
    5. 遇到*号,7乘以6,计算结果42进栈
    6. 遇到数字8,直接进栈
    7. 遇到+号,8加42,计算结果50进栈
    8. 遇到数字9,直接进栈
    9. 遇到*号,9乘以50,计算结果450进栈
    10. 遇到+号,450加23,计算结果473进栈
      后缀表达式字符判断完毕,把最后结果473输出
      这个例子只有乘法和加法,请自行测试含有加减乘除的四则运算,自己动手,加深印象 +.+

    代码如下:

    // 后缀表达式计算结果
        public static int cal (String s ) {
            Stack<String> stack = new Stack<>();
            char c;
            Pattern p = Pattern.compile("\\d+");
            for (int i = 0; i < s.length(); i++) {
                c = s.charAt(i);
                Matcher m = p.matcher(c+"");
               // 数字直接进栈,然后分别判断加减乘除
                if (m.find()) {
                    stack.push(c+"");
                    continue;
                } else if (c == '+') {
                    int x = Integer.parseInt(stack.pop());
                    int y = Integer.parseInt(stack.pop());
                    stack.push((x+y)+"");
                    continue;
                } else if (c == '*') {
                    int x = Integer.parseInt(stack.pop());
                    int y = Integer.parseInt(stack.pop());
                    stack.push((x*y)+"");
                    continue;
                } else if (c == '-') {
                    int x = Integer.parseInt(stack.pop());
                    int y = Integer.parseInt(stack.pop());
                    stack.push((y-x)+"");
                    continue;
                } else if (c == '/') {
                    int x = Integer.parseInt(stack.pop());
                    int y = Integer.parseInt(stack.pop());
                    stack.push((y/x)+"");
                    continue;
                }
            }
            
           // 最后的结果,栈里只有一个元素,并且是数字
           // peek方法只查看栈顶元素,不弹出; pop方法是查看并弹出栈顶元素
            Matcher m1 = p.matcher(stack.peek());
            if (stack.size() == 1 && m1.find())
                return Integer.parseInt(stack.pop());
            else
                return -1;
        }
    

    把这个方法和上一篇的代码放一起,可以直接测试。

    参考:https://www.cnblogs.com/jiu0821/p/6692878.html

    展开全文
  • calPostfix:后缀表达式计算 in: char* postfix 输入的后缀表达式,每个元素以空格分隔,以 '\0' 结尾。 out: double 输出的结果。 isNumber 输入一个字符,返回是不是0-9的数字字符 isOperator 输入一...

    基础知识

    占坑

    代码,内含注释,基本上看注释就能看懂

    #include<iostream>
    #include<cstdio>
    #include<stack>
    #define max(a,b) (((a) > (b)) ? (a) : (b))
    #define min(a,b) (((a) < (b)) ? (a) : (b))
    #pragma warning(disable:4996)
    using namespace std;
    
    /*
    *中缀转后缀,后缀再计算
    *这些函数整理得比较规整,可以轻松写成一个类。
    *注释详实,不再进行过多解释。
    
    infixToPostfix:中缀表达式转后缀表达式
    	in:
    		char* infix		输入的中缀表达式,可以有小数,不能有空格,以 '\0' 结尾。
    		char* postfix	输出的后缀表达式,每个元素以空格分隔,以 '\0' 结尾
    
    calPostfix:后缀表达式计算
    	in:
    		char* postfix	输入的后缀表达式,每个元素以空格分隔,以 '\0' 结尾。
    	out:
    		double			输出的结果。
    
    isNumber		输入一个字符,返回是不是0-9的数字字符
    isOperator		输入一个字符,返回是不是操作符
    priority		输入一个字符,返回该操作符的优先级
    enum cal_err	可能出现的错误
    */
    typedef enum { wrong_char, no_such_operator }cal_err;
    inline bool isNumber ( char c ) {
    	if ( c >= '0' && c <= '9' ) {
    		return true;
    	} else {
    		return false;
    	}
    }
    inline bool isOperator ( char c ) {
    	switch ( c ) {
    	case '*':
    	case '/':
    	case '+':
    	case '-':
    		return true;
    	default:
    		return false;
    	}
    }
    
    int priority ( char c ) {
    	switch ( c ) {
    	case '*':return 5; break;
    	case '/':return 5; break;
    	case '+':return 4; break;
    	case '-':return 4; break;
    	default:throw no_such_operator;
    	}
    }
    
    /*计算后缀表达式*/
    double calPostfix ( char* postfix ) {
    	stack<double> result;
    
    	/*
    	计算后缀表达式比中缀转后缀简单
    	首先准备一个后缀表达式与一个数字栈
    
    	对于后缀表达式从左到右每个元素
    	如果是数字,则压入数字栈
    	如果是操作符,则弹出数字栈中的两个,以第一次弹出作为右值,第二次弹出作为左值,进行相应计算并入数字栈(因为/与-与数字顺序相关)
    	直到后缀表达式结束,返回栈顶数字
    	*/
    	for ( int i = 0;;) {
    		if ( isNumber ( postfix[i] ) || postfix[i] == '.' ) {
    
    			/*这里将浮点字符串转化为浮点数,有时间可以抽离成单独的函数*/
    			double temp = 0;
    			bool is_int = true;
    			while ( isNumber ( postfix[i] ) || postfix[i] == '.' ) {
    				if ( postfix[i] == '.' ) {
    					is_int = false;
    				} else {
    					if ( is_int ) {
    						temp = ( postfix[i] - '0' ) + temp * 10;
    					} else {
    						temp = ( postfix[i] - '0' ) * 0.1 + temp;
    					}
    				}
    				i++;
    			}
    			i--;
    			result.push ( temp );
    		} else if ( postfix[i] == ' ' ) {
    		} else if ( postfix[i] == '*' ) {
    			double a = result.top ();
    			result.pop ();
    			double b = result.top ();
    			result.pop ();
    
    			result.push ( a * b );
    		} else if ( postfix[i] == '/' ) {
    			double a = result.top ();
    			result.pop ();
    			double b = result.top ();
    			result.pop ();
    
    			result.push ( b / a );
    		} else if ( postfix[i] == '+' ) {
    			double a = result.top ();
    			result.pop ();
    			double b = result.top ();
    			result.pop ();
    
    			result.push ( a + b );
    		} else if ( postfix[i] == '-' ) {
    			double a = result.top ();
    			result.pop ();
    			double b = result.top ();
    			result.pop ();
    
    			result.push ( b - a );
    		} else if ( postfix[i] == '\0' ) {
    			return result.top ();
    		} else {
    			throw wrong_char;
    			return 0;
    		}
    		i++;
    	}
    
    }
    
    /*中缀转后缀,注释详实*/
    void infixToPostfix ( char* infix, char* postfix ) {
    	int j = 0;//目的下标
    	int i = 0;//源下标
    	stack<char> op_stack;
    
    	/*
    	中缀转后缀需要一个中缀表达式,一个存放后缀表达式的缓冲区,一个符号栈
    
    	对于中缀表达式从左到右每个元素
    	1.如果是数字,直接进入后缀表达式
    	2.如果是操作符
    		->循环判断开始
    		1.如果 符号栈为空 或 栈顶为左括号,则直接入栈
    		2.如果 当前操作符比栈顶符号优先级高,也直接入栈
    		3.如果 当前操作符比栈顶符号优先级低或相等,则栈顶元素弹出到后缀表达式,并重新进行此判断
    		(强调“重新进行此的判断”是为了优化程序结构,这样表述就只需要写一个while循环)
    		<-循环判断结束
    	3.如果是左右括号
    		1.如果是左括号,则入栈
    		2.如果是右括号,则栈弹出到后缀表达式,直到左括号,并抛弃左括号
    	*/
    
    	/*每次循环,i均指向当前循环需要被判断的位置*/
    	for ( ;;) {
    		if ( isNumber ( infix[i] ) || infix[i] == '.' ) {
    			/*数字字符直接输出到后缀表达式,直到下一位不是数字字符输出空格到后缀表达式并跳出循环 */
    			while ( isNumber ( infix[i] ) || infix[i] == '.' ) {
    				postfix[j++] = infix[i++];
    			}
    			postfix[j++] = ' ';
    			i--;
    		} else if ( isOperator ( infix[i] ) ) {
    			while ( true ) {
    				if ( op_stack.empty () || op_stack.top () == '(' ) {
    					op_stack.push ( infix[i] );
    					break;
    				} else if ( priority ( infix[i] ) > priority ( op_stack.top () ) ) {
    					op_stack.push ( infix[i] );
    					break;
    				} else {
    					postfix[j++] = op_stack.top ();
    					postfix[j++] = ' ';
    					op_stack.pop ();
    				}
    			}
    		} else if ( infix[i] == ')' ) {
    			while ( op_stack.top () != '(' ) {
    				postfix[j++] = op_stack.top ();
    				postfix[j++] = ' ';
    				op_stack.pop ();
    			}
    			op_stack.pop ();
    		} else if ( infix[i] == '(' ) {
    			op_stack.push ( infix[i] );
    		} else if ( infix[i] == '\0' ) {
    			break;
    		} else {
    			throw wrong_char;
    			return;
    		}
    
    		i++;//循环末,i处于本次循环判断处,需要让其指向下次循环判断处。
    	}
    	while ( !op_stack.empty () ) {
    		postfix[j++] = op_stack.top ();
    		postfix[j++] = ' ';
    		op_stack.pop ();
    	}
    	postfix[j++] = '\0';
    	return;
    
    }
    
    
    
    int main () {
    	//freopen ( "input.txt", "r", stdin );
    
    	char  str[2000];
    	int num;
    	cin >> num;//输入表达式数量
    
    	for ( int i = 0; i < num; i++ ) {
    		cin >> str;//输入一个表达式,前后都不加"#"
    		char* postfix = new char[strlen ( str ) * 4];
    		infixToPostfix ( str, postfix );
    		//cout << postfix << '\n';
    		printf ( "%.2lf\n", calPostfix ( postfix ) );
    		delete[] postfix;
    	}
    
    	return 0;
    }
    
    展开全文
  • 每日AC - 后缀表达式计算结果-leetcode-evaluate-reverse-polish-notation 题目描述 Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are+,-,*,/...


    每日AC  - 后缀表达式计算结果-leetcode-evaluate-reverse-polish-notation

    题目描述


    Evaluate the value of an arithmetic expression in Reverse Polish Notation.

    Valid operators are+,-,*,/. Each operand may be an integer or another expression.

    Some examples:

      ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
      ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6
    


    昨日在地铁上看《大话数据结构》回顾下大学时光, 这个逆波兰, 有机会再奉献一份 中缀表达式变后缀的算法


    后缀表达式 计算结果,抓住, 符号前来两个必须是数字, 才可以进行计算  == equals 不能乱用


    AC 代码:

    import java.util.Stack;
    
    /**
     * 类说明
     * 
     * <pre>
     * Modify Information:
     * Author        Date          Description
     * ============ =========== ============================
     * DELL          2017年6月21日    Create this file
     * </pre>
     * 
     */
    
    public class EvalRPN {
    
        /**
         * 您的代码已保存 答案错误:您提交的程序没有通过所有的测试用例 case通过率为0.00%
         * 
         * 测试用例: ["0","3","/"]
         * 
         * 对应输出应该为:
         * 
         * 0
         * 
         * 你的输出为:
         * 
         * java.util.EmptyStackException
         * 
         * 但是本地IDE运行没问题 ,最好的方式是将 == 变成 equals 
         * @param tokens
         * @return
         */
        public int evalRPN(String[] tokens) {
            int result = 0;
            Stack<String> s= new Stack<String>();
            for(int i = 0; i <tokens.length ;i++){
                if(tokens[i].equals("+") || tokens[i].equals("-") ||tokens[i].equals("*") ||tokens[i].equals("/")){
                    int first =Integer.parseInt(s.pop());
                    int second = Integer.parseInt(s.pop());
                    int cop = 0;
                    if(tokens[i].equals("+")){
                        cop = first+second;
                        s.push(cop+"");
                    } else if(tokens[i].equals("-")){
                        cop = second - first;
                        s.push(cop+"");
                    }else if(tokens[i].equals("/")){
                        cop = second/first;
                        s.push(cop+"");
                    } else if(tokens[i].equals("*")){
                        cop = second*first;
                        s.push(cop+"");
                    }
                }else{
                    s.push(tokens[i]);
                }
            }
            result = Integer.parseInt(s.pop());
            
            return result;
            
        }
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            String[] str = { "2", "1", "+", "3", "*" };
            String[] str1 = { "4", "13", "5", "/", "+" };
            String[] str2 = { "0", "3", "/" };
            int ans = new EvalRPN().evalRPN(str2);
            System.out.println(ans);
        }
    
    }
    


    展开全文
  • 一.后缀表达式计算结果 后缀表达式 规则:从左到右遍历表达式的每个数字和符号,遇到是数字就进栈,遇到是符号,就将处于栈顶两个数字出栈,进行运算,运算结果进栈,一直到最终获得结果。
  • * 中缀表达式转换成后缀表达式: 从输入(中缀表达式)中读取的字符,规则: 操作数: 写至输出 左括号: 推其入栈 右括号: 栈非空时重复以下步骤--> * 若项不为(,则写至输出; 若项为(,则推出循环 operator...
  • /*** 中缀表达式转换成后缀表达式: 从输入(中缀表达式)中读取的字符,规则: 操作数: 写至输出 左括号: 推其入栈 右括号: 栈非空时重复以下步骤-->* 若项不为(,则写至输出; 若项为(,则推出循环 operator...
  • 思路: ...3.通过后缀表达式计算结果:思路见注释(详细) package stack; import java.util.ArrayList; import java.util.List; import java.util.Stack; public class PolandNotation { p...
  • 题目来源:中国大学MOOC - 北京大学《数据结构与算法》- 第三章 栈与队列 3.1 栈 ...计算结果 1 23+(34*45)/(5+6+7) 23 34 45 * 5 6 + 7 + / + 108 2 1*(2-(3+4)) 1 2 3 4 + - * -5 3 1+2-3+4-5+6 ...
  • 中缀表达式转后缀表达式中缀表达式转后缀表达式的规则。1.遇到操作数:直接输入到后缀表达式栈2.遇到运算符,直接入操作符栈3.遇到左括号:直接将其入栈4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈...
  • 后缀表达式计算

    2012-03-09 20:52:17
    后缀表达式的计算,输入一个后缀表达式利用栈来计算结果
  • /*中缀表达式转成后缀表达式 "12+((22+31)*4)-5" ==> 12 22 31 + 4 * + 5 -第一步,将中缀表达式转成中缀字符串list,方便遍历 [12, +, (, (, 22, +, 31, ), *, 4, ), -, 5]第二步,将中缀字符串list转成后缀...
  • /*中缀表达式转成后缀表达式 "12+((22+31)*4)-5" ==> 12 22 31 + 4 * + 5 -第一步,将中缀表达式转成中缀字符串list,方便遍历 [12, +, (, (, 22, +, 31, ), *, 4, ), -, 5]第二步,将中缀字符串list转成后缀...
  • 无奈之下只能学习下计算表达式的过程:后缀表达式。1.人脑计算(中缀表达式)我们计算一个式子是从左往右看,遇到数先保留在脑子里,遇到运算符也先存在大脑,接着遇到下一个数,还得看看这个数后面有没有更高等级的...
  • /*中缀表达式转成后缀表达式 "12+((22+31)*4)-5" ==> 12 22 31 + 4 * + 5 -第一步,将中缀表达式转成中缀字符串list,方便遍历 [12, +, (, (, 22, +, 31, ), *, 4, ), -, 5]第二步,将中缀字符串list转成后缀...
  • C++后缀表达式计算

    千次阅读 2019-11-19 22:32:17
    C++后缀表达式计算 继续上篇文章,实现计算器简单计算的功能 上篇文章C++中缀表达式转后缀表达式已经将中缀表达式转换成后缀表达式并保存在队列q中 后缀表达式算法思想: 读取队列q顶端元素,并判断元素类型...
  • 后缀表达式计算过程的规则非常简单:从左到右依次扫描,当读到运算符时,就对该运算符前面的两个操作数执行相应的运算,直至得到表达式的结果。 编写程序模拟编译系统计算中缀表达式的过程,大体分为两步: (1) 将...
  • 最近在学习二叉树,学习了... (1+2)x3的后缀表达式是 12+3x,借助一个栈,将1,2放进去,在发现是+,将1,2弹出,计算1+2,计算结果(3),放进去,栈中有3,3再遇见‘x’号,将3,3弹出,计算结果(9),最终计算结果
  • 一、后缀表达式求值: 1.遍历后缀表达式;  1)、若是进行运算的数值,压入栈内  2)、若是运算符,取出栈顶的两个操作数,先取出的为右操作数,后取出的为左操作数,然后进行运算,运算结果压栈。 2.最后遍历...
  • java中缀表达式转后缀表达式计算结果(可以处理多位数
  • 有趣的数据结构算法10——利用栈计算后缀表达式结果解题思路实现代码GITHUB下载连接 在前一天已经利用栈完成2进制到8进制的转换。但是栈的应用方面还有很多,本次我将讲解如何计算后缀表达式结果。 解题思路 ...
  • 也利用栈,将后缀表达式计算结果。 ①中缀表达式转后缀表达式 如1+2*3/(3-1) ---> 1 2 3 * 3 1 -/ + 转换的思想: 一个空的后缀表达式 一个存放符号的栈s 在转换的过程中,需要加入空格以区分不同数字与...
  • 后缀表达式计算求值

    2021-04-10 18:11:31
    上一篇文章中中缀表达式 转 后缀表达式 说明了中缀表达式 转化为后缀表达式的过程, 此篇文章 讲述一下后缀表达式计算是如何计算的 根据百度百科中描述的计算方法: 新建一个表达式,如果当前字符为变量或者为数字,...
  • 需求:输入字符串表达式,计算表达式结果 解决:将输入的表示转化为后缀表达式形式(也称作逆波兰式),再计算结果。... * 根据中缀表达式计算结果 * * @param expression * @return */

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,342
精华内容 536
关键字:

后缀表达式计算结果