精华内容
下载资源
问答
  • 题目:问题描述输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。输入格式输入一行,包含一个表达式。输出格式输出这个表达式的值...回忆起了后缀表达式的知识中缀表达式转后缀表达式的方...

    题目:

    问题描述

    输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。

    输入格式

    输入一行,包含一个表达式。

    输出格式

    输出这个表达式的值。

    样例输入

    1-2+3*(4-5)

    样例输出

    -4

    数据规模和约定

    表达式长度不超过100,表达式运算合法且运算过程都在int内进行。

    初看此题,从人的直观角度来说很简单,先遍历括号内的运算完再重新遍历,但是很麻烦。

    回忆起了后缀表达式的知识

    中缀表达式转后缀表达式的方法:

    1.遇到操作数:直接输出(添加到后缀表达式中)

    2.栈为空时,遇到运算符,直接入栈

    3.遇到左括号:将其入栈

    4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。

    5.遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈

    6.最终将栈中的元素依次出栈,输出。

    后缀表达式的计算机求值:

    与前缀表达式类似,只是顺序是从左至右:

    从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 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,由此得出最终结果。

    一开始,我先把中缀表达式转换为后缀表达式,再对后缀表达式求值。

    有一个很大的问题,数字的保存,转化为后缀表达式时保存为char字符,对于大于9的数字保存很麻烦。

    后来想了想,可以直接借用后缀表达式的计算方法。

    代码如下

    public class Main {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Scanner scanner = new Scanner(System.in);

    Stack nums = new Stack(); // 保存数字

    Stack opes = new Stack(); // 保存操作符

    String string = scanner.nextLine();

    int n = 0; // 保存每一个数字

    char[] cs = string.toCharArray();

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

    char temp = cs[i];

    if (Character.isDigit(cs[i])) {

    n = 10 * n + Integer.parseInt(String.valueOf(cs[i])); // 大于10的数字保存

    } else {

    if (n != 0) {

    nums.push(n);

    n = 0;

    }

    if (temp == '(') {

    opes.push(temp);

    } else if (temp == ')') {

    while (opes.peek() != '(') { // 括号里面运算完

    int t = cal(nums.pop(), nums.pop(), opes.pop());

    nums.push(t);

    }

    opes.pop();

    } else if (isType(temp) > 0) {

    if (opes.isEmpty()) { // 栈为空直接入栈

    opes.push(temp);

    } else {

    // 若栈顶元素优先级大于或等于要入栈的元素,将栈顶元素弹出并计算,然后入栈

    if (isType(opes.peek()) >= isType(temp)) {

    int t = cal(nums.pop(), nums.pop(), opes.pop());

    nums.push(t);

    }

    opes.push(temp);

    }

    }

    }

    }

    // 最后一个字符若是数字,未入栈

    if (n != 0) {

    nums.push(n);

    }

    while (!opes.isEmpty()) {

    int t = cal(nums.pop(), nums.pop(), opes.pop());

    nums.push(t);

    }

    System.out.println(nums.pop());

    }

    // 返回的是运算符的优先级,数字和()不需要考虑

    public static int isType(char c) {

    if (c == '+' || c == '-') {

    return 1;

    } else if (c == '*' || c == '/') {

    return 2;

    } else {

    return 0;

    }

    }

    // 运算次序是反的,跟入栈出栈次序有关

    public static int cal(int m, int n, char c) {

    int sum = -987654321;

    if (c == '+') {

    sum = n + m;

    } else if (c == '-') {

    sum = n - m;

    } else if (c == '*') {

    sum = n * m;

    } else if (c == '/') {

    sum = n / m;

    }

    return sum;

    }

    }

    &lbrack;Swust OJ 322&rsqb;--东6宿舍灵异事件&lpar;中缀表达式转化为后缀表达式的简单运用&rpar;

    题目链接:http://acm.swust.edu.cn/problem/322/ Time limit(ms): 1000 Memory limit(kb): 65535     Descripti ...

    蓝桥杯 ALGO-156 表达式计算 JAVA代码 栈的应用

    算法训练 表达式计算   时间限制:1.0s   内存限制:256.0MB      问题描述 输入一个只包含加减乖除和括号的合法表达式,求表达式的值.其中除表示整除. 输入格式 输入一行,包含一个 ...

    Java堆栈的应用2----------中缀表达式转为后缀表达式的计算Java实现

    1.堆栈-Stack 堆栈(也简称作栈)是一种特殊的线性表,堆栈的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置进行插入和删除操作,而堆栈只允许在固定一端进行插入和删除 ...

    《java数据结构与算法》笔记-CH4-8栈结构实现后缀表达式计算结果

    /** * 中缀表达式转换成后缀表达式: 从输入(中缀表达式)中读取的字符,规则: 操作数: 写至输出 左括号: 推其入栈 右括号: 栈非空时重复以下步骤--> * 若项不为(,则写至输出: 若 ...

    数据结构Java实现06----中缀表达式转换为后缀表达式

    本文主要内容: 表达式的三种形式 中缀表达式与后缀表达式转换算法 一.表达式的三种形式: 中缀表达式:运算符放在两个运算对象中间,如:(2+1)*3.我们从小做数学题时,一直使用的就是中缀表达式. 后 ...

    Java数据结构和算法(六)——前缀、中缀、后缀表达式

    前面我们介绍了三种数据结构,第一种数组主要用作数据存储,但是后面的两种栈和队列我们说主要作为程序功能实现的辅助工具,其中在介绍栈时我们知道栈可以用来做单词逆序,匹配关键字符等等,那它还有别的什么功能吗 ...

    java四则运算----前缀、中缀、后缀表达式

    接到一个新需求,需要实现可配置公式,然后按公式实现四则运算. 刚拿到需求,第一反应就是用正则匹配‘(’,‘)’,‘+’,‘-’,‘*’,‘/’,来实现四则运算,感觉不复杂. 然后开始coding.发现 ...

    实现Linux下dc的功能,计算后缀表达式的值

    提交测试截图和码云练习项目链接,实现Linux下dc的功能,计算后缀表达式的值 -将运算符写在两个操作数之后的表达式称为"后缀表达式",如上面的中缀表达式可转换为后缀表达式1 2 ...

    【java】中缀表达式转后缀表达式 java实现

    算法: 中缀表达式转后缀表达式的方法:1.遇到操作数:直接输出(添加到后缀表达式中)2.栈为空时,遇到运算符,直接入栈3.遇到左括号:将其入栈4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出 ...

    随机推荐

    sql 取汉字首字母

    )) ) --用于加密 --WITH ENCRYPTION as begin declare @intLen int ) ) set @intLen = len(@str) set @strRet = ...

    Android基础总结(八)

    服务两种启动方式(掌握) startService 开始服务,会使进程变成为服务进程 启动服务的activity和服务不再有一毛钱关系 bindService 绑定服务不会使进程变成服务进程 绑定服务 ...

    linux shell 字符串操作

    转:http://justcoding.iteye.com/blog/1963463 在做shell批处理程序时候,经常会涉及到字符串相关操作.有很多命令语句,如:awk,sed都可以做字符串各种操作 ...

    &lbrack;bzoj3694&rsqb;最短路

    Description 给出一个$n$个点$m$条边的无向图,$n$个点的编号从$1-n$,定义源点为$1$. 定义最短路树如下:从源点$1$经过边集$T$到任意一点$i$有且仅有一条路径,且这条路径 ...

    grade web的构建约定 convention

    --2015.09.24 当使用gradle构建web应用时: src/main/javasrc/main/resourcessrc/main/webapp/resourcessrc/main/web ...

    java 的Swing

    1.原来的AWT组件来自java.awt包,而AWT组件的java应用程序在不同平台的界面显示不同.但是在不同平台运用Swing开发的应用程序,就可以使用同一的GUI界面. 2.SWing组件通常被称 ...

    BGP基础【第三部】

    静态路由的优点:安全稳定.缺点:配置繁琐不灵活.动态路由的优缺点则反之. BGP边界网关路由协议 路径向量(rip是距离矢量) 到达目的网段所要经过的所有as BGP选路不看度量值而参考13种路径属性 ...

    C&num; 根据路径删除文件或文件夹

    如何根据路径删除文件或文件夹? 1.首先我们要判断路径是文件或者是文件夹 那么我们可以通过 FileAttributes attr = File.GetAttributes(path); 来得到路径的 ...

    FTP配置的一些笔记

    1.必须关闭防火墙 iptables -F iptables -X iptables -Z vi /etc/selinux/config          SELINUX=disabled seten ...

    展开全文
  • 题目:问题描述输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。输入格式输入一行,包含一个表达式。输出格式输出这个表达式的值...回忆起了后缀表达式的知识中缀表达式转后缀表达式的方...

    题目:

    问题描述

    输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。

    输入格式

    输入一行,包含一个表达式。

    输出格式

    输出这个表达式的值。

    样例输入

    1-2+3*(4-5)

    样例输出

    -4

    数据规模和约定

    表达式长度不超过100,表达式运算合法且运算过程都在int内进行。

    初看此题,从人的直观角度来说很简单,先遍历括号内的运算完再重新遍历,但是很麻烦。

    回忆起了后缀表达式的知识

    中缀表达式转后缀表达式的方法:

    1.遇到操作数:直接输出(添加到后缀表达式中)

    2.栈为空时,遇到运算符,直接入栈

    3.遇到左括号:将其入栈

    4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。

    5.遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈

    6.最终将栈中的元素依次出栈,输出。

    后缀表达式的计算机求值:

    与前缀表达式类似,只是顺序是从左至右:

    从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 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,由此得出最终结果。

    一开始,我先把中缀表达式转换为后缀表达式,再对后缀表达式求值。

    有一个很大的问题,数字的保存,转化为后缀表达式时保存为char字符,对于大于9的数字保存很麻烦。

    后来想了想,可以直接借用后缀表达式的计算方法。

    代码如下

    1 public classMain {2 public static voidmain(String[] args) {3 //TODO Auto-generated method stub

    4 Scanner scanner = newScanner(System.in);5 Stack nums = new Stack(); //保存数字

    6 Stack opes = new Stack(); //保存操作符

    7 String string =scanner.nextLine();8 int n = 0; //保存每一个数字

    9 char[] cs =string.toCharArray();10 for (int i = 0; i < cs.length; i++) {11 char temp =cs[i];12 if(Character.isDigit(cs[i])) {13 n = 10 * n + Integer.parseInt(String.valueOf(cs[i])); //大于10的数字保存

    14 } else{15 if (n != 0) {16 nums.push(n);17 n = 0;18 }19 if (temp == '(') {20 opes.push(temp);21 } else if (temp == ')') {22 while (opes.peek() != '(') { //括号里面运算完

    23 int t =cal(nums.pop(), nums.pop(), opes.pop());24 nums.push(t);25 }26 opes.pop();27 } else if (isType(temp) > 0) {28 if (opes.isEmpty()) { //栈为空直接入栈

    29 opes.push(temp);30 } else{31 //若栈顶元素优先级大于或等于要入栈的元素,将栈顶元素弹出并计算,然后入栈

    32 if (isType(opes.peek()) >=isType(temp)) {33 int t =cal(nums.pop(), nums.pop(), opes.pop());34 nums.push(t);35 }36 opes.push(temp);37 }38 }39 }40 }41 //最后一个字符若是数字,未入栈

    42 if (n != 0) {43 nums.push(n);44 }45 while (!opes.isEmpty()) {46 int t =cal(nums.pop(), nums.pop(), opes.pop());47 nums.push(t);48 }49 System.out.println(nums.pop());50 }51

    52 //返回的是运算符的优先级,数字和()不需要考虑

    53 public static int isType(charc) {54 if (c == '+' || c == '-') {55 return 1;56 } else if (c == '*' || c == '/') {57 return 2;58 } else{59 return 0;60 }61 }62

    63 //运算次序是反的,跟入栈出栈次序有关

    64 public static int cal(int m, int n, charc) {65 int sum = -987654321;66 if (c == '+') {67 sum = n +m;68 } else if (c == '-') {69 sum = n -m;70 } else if (c == '*') {71 sum = n *m;72 } else if (c == '/') {73 sum = n /m;74 }75 returnsum;76 }77 }

    展开全文
  • package 表达式运算; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Stack; import org.junit....
    package 表达式运算;


    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Stack;


    import org.junit.Test;


    public class InfixInToSuffix {


    private int [] isp ={0,1,7,5,5,5,3,3,8};//#(^*/%+-)的栈内优先级
    private int [] icp ={0,8,6,4,4,4,2,2,1};//#(^*/%+-)的引入 优先级
    private String sOpt = "#(^*/%+-)";


    public static void main(String [] args){
    InfixInToSuffix test = new InfixInToSuffix();
    System.out.println(test.calMidSuffix("3*( 17-2 -5)"));
    System.out.println(test.toSuffix("3*( 17-2 - 5 -1)"));
    System.out.println(test.calEndSuffix("17.0 2.0 - 5.0 - 3.0 *"));
    }
    /**
    * 将 中缀表达式 转化为 后缀表达式
    * @param 中缀表达式
    * @return 后缀表达式
    */
    public String toSuffix(String infix) {
    Stack<Double>  stNum = new Stack<Double>();
    Stack<Character>  stOpt = new Stack<Character>();
    String sResult = "";
    Boolean firstCal = true;
    String sInput = infix;
    char [] input = sInput.toCharArray();
    for(int i=0; i<input.length; i++){
    char cInput = input[i];
    if(isNum(cInput)){
    String tmp = "" + cInput;
    for(int j=i+1; j<input.length; j++){
    if(isNum(input[j]) || input[j] == '.'){
    tmp += input[j];
    i = j;
    }else{
    break;
    }
    }
    stNum.add(Double.valueOf(tmp));
    }else if(cInput == ' '){
    continue;
    }else if(optPosion(cInput) != -1){
    if(stOpt.empty() || icp[optPosion(cInput)] > isp[optPosion(stOpt.peek())]){
    stOpt.push(cInput);
    }else if(icp[optPosion(cInput)] == isp[optPosion(stOpt.peek())]){
    stOpt.pop();
    }else if(icp[optPosion(cInput)] < isp[optPosion(stOpt.peek())]){
    do{
    char cOpt = stOpt.pop();
    double optNum1 = stNum.pop();
    double optNum2 = stNum.pop();
    if(firstCal){
    sResult = sResult + optNum2 + " "+ optNum1 + " "+ cOpt;
    firstCal = false;
    }else{
    sResult = sResult + " " + optNum1 + " "+ cOpt;
    }

    stNum.push(calNum(cOpt,optNum1,optNum2));
    }while(!stOpt.empty() && icp[optPosion(cInput)] < isp[optPosion(stOpt.peek())]);
    if(!stOpt.empty() && icp[optPosion(cInput)] == isp[optPosion(stOpt.peek())]){
    stOpt.pop();
    }else{
    stOpt.push(cInput);
    }
    }
    }
    }
    while(!stOpt.empty()){
    char cOpt = stOpt.pop();
    double optNum1 = stNum.pop();
    double optNum2 = stNum.pop();
    sResult = sResult + " " + optNum2 + " " + cOpt;
    stNum.push(calNum(cOpt,optNum1,optNum2));
    }
    return sResult;
    }


    /**
    * 将 中缀表达式 进行 运算 计算出结果

    * @param equation
    * @return 表达式运算结果
    */
    public String calMidSuffix(String infix) {
    Stack<Double>  stNum = new Stack<Double>();
    Stack<Character>  stOpt = new Stack<Character>();
    String sResult = null;
    String sInput = infix ;
    char [] input = sInput.toCharArray();
    for(int i=0; i<input.length; i++){
    char cInput = input[i];
    if(isNum(cInput)){
    String tmp = "" + cInput;
    for(int j=i+1; j<input.length; j++){
    if(isNum(input[j]) || input[j] == '.'){
    tmp += input[j];
    i = j;
    }else{
    break;
    }
    }
    stNum.add(Double.valueOf(tmp));
    }else if(cInput == ' '){
    continue;
    }else if(optPosion(cInput) != -1){
    if(stOpt.empty() || icp[optPosion(cInput)] > isp[optPosion(stOpt.peek())]){
    stOpt.push(cInput);
    }else if(icp[optPosion(cInput)] == isp[optPosion(stOpt.peek())]){
    stOpt.pop();
    }else if(icp[optPosion(cInput)] < isp[optPosion(stOpt.peek())]){
    do{
    char cOpt = stOpt.pop();
    double optNum1 = stNum.pop();
    double optNum2 = stNum.pop();
    stNum.push(calNum(cOpt,optNum1,optNum2));
    }while(!stOpt.empty() && icp[optPosion(cInput)] < isp[optPosion(stOpt.peek())]);
    if(!stOpt.empty() && icp[optPosion(cInput)] == isp[optPosion(stOpt.peek())]){
    stOpt.pop();
    }else{
    stOpt.push(cInput);
    }
    }
    }
    }
    while(!stOpt.empty()){
    char cOpt = stOpt.pop();
    double optNum1 = stNum.pop();
    double optNum2 = stNum.pop();
    stNum.push(calNum(cOpt,optNum1,optNum2));
    }
    sResult = String.valueOf(stNum.peek());
    stNum.clear();
    stOpt.clear();
    return sResult;

    }
    /**
    * 运算结果
    * @param cOpt 运算符 optNum1 optNum2 运算数
    * @return 运算结果

    */
    private Double calNum(char cOpt, double optNum1, double optNum2) {
    // TODO Auto-generated method stub
    switch(cOpt){
    case '+':
    return optNum2 + optNum1;
    case '-':
    return optNum2 - optNum1;
    case '*':
    return optNum2 * optNum1;
    case '/':
    return optNum2 / optNum1;
    default:
    return (double) 0;
    }
    }
    /**
    * 运算结果
    * @param 表达式中的字符
    * @return 运算符在isp 和 icp中的位置

    */
    private int optPosion(char c) {
    // TODO Auto-generated method stub
    return sOpt.indexOf(c);
    }

    /**
    * 运算结果
    * @param 表达式中的字符
    * @return 是否是数字

    */
    private boolean isNum(char c) {
    // TODO Auto-generated method stub
    if(c >= '0' && c <= '9'){
    return true;
    }
    return false;
    }
    /**
    * 将 后缀表达式 进行 运算 计算出结果

    * @param equation
    * @return
    */
    public String calEndSuffix(String infix) {
    Stack<Double>  stNum = new Stack<Double>();
    String sResult = null;
    String sInput = infix;
    char [] input = sInput.toCharArray();
    for(int i=0; i<input.length; i++){
    char cInput = input[i];
    if(isNum(cInput)){
    String tmp = "" + cInput;
    for(int j=i+1; j<input.length; j++){
    if(isNum(input[j]) || input[j] == '.'){
    tmp += input[j];
    i = j;
    }else{
    break;
    }
    }
    stNum.add(Double.valueOf(tmp));
    }else if(cInput == ' '){ //数字分割符
    continue;
    }else if(optPosion(cInput) != -1){
    double optNum1 = stNum.pop();
    double optNum2 = stNum.pop();
    stNum.push(calNum(cInput,optNum1,optNum2));

    }
    }
    /*while(!stOpt.empty()){
    char cOpt = stOpt.pop();
    double optNum1 = stNum.pop();
    double optNum2 = stNum.pop();
    stNum.push(calNum(cOpt,optNum1,optNum2));
    }*/
    sResult = String.valueOf(stNum.peek());
    stNum.clear();
    return sResult;

    }


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

    题目:

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

    初看此题,从人的直观角度来说很简单,先遍历括号内的运算完再重新遍历,但是很麻烦。

    回忆起了后缀表达式的知识

     

    中缀表达式转后缀表达式的方法:
    1.遇到操作数:直接输出(添加到后缀表达式中)
    2.栈为空时,遇到运算符,直接入栈
    3.遇到左括号:将其入栈
    4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。
    5.遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈
    6.最终将栈中的元素依次出栈,输出。

    后缀表达式的计算机求值:
    与前缀表达式类似,只是顺序是从左至右:
    从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 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,由此得出最终结果。

     

    一开始,我先把中缀表达式转换为后缀表达式,再对后缀表达式求值。

    有一个很大的问题,数字的保存,转化为后缀表达式时保存为char字符,对于大于9的数字保存很麻烦。

    后来想了想,可以直接借用后缀表达式的计算方法。

    代码如下

     1 public class Main {
     2     public static void main(String[] args) {
     3         // TODO Auto-generated method stub
     4         Scanner scanner = new Scanner(System.in);
     5         Stack<Integer> nums = new Stack<Integer>(); // 保存数字
     6         Stack<Character> opes = new Stack<Character>(); // 保存操作符
     7         String string = scanner.nextLine();
     8         int n = 0; // 保存每一个数字
     9         char[] cs = string.toCharArray();
    10         for (int i = 0; i < cs.length; i++) {
    11             char temp = cs[i];
    12             if (Character.isDigit(cs[i])) {
    13                 n = 10 * n + Integer.parseInt(String.valueOf(cs[i])); // 大于10的数字保存
    14             } else {
    15                 if (n != 0) {
    16                     nums.push(n);
    17                     n = 0;
    18                 }
    19                 if (temp == '(') {
    20                     opes.push(temp);
    21                 } else if (temp == ')') {
    22                     while (opes.peek() != '(') { // 括号里面运算完
    23                         int t = cal(nums.pop(), nums.pop(), opes.pop());
    24                         nums.push(t);
    25                     }
    26                     opes.pop();
    27                 } else if (isType(temp) > 0) {
    28                     if (opes.isEmpty()) { // 栈为空直接入栈
    29                         opes.push(temp);
    30                     } else {
    31                         // 若栈顶元素优先级大于或等于要入栈的元素,将栈顶元素弹出并计算,然后入栈
    32                         if (isType(opes.peek()) >= isType(temp)) {
    33                             int t = cal(nums.pop(), nums.pop(), opes.pop());
    34                             nums.push(t);
    35                         }
    36                         opes.push(temp);
    37                     }
    38                 }
    39             }
    40         }
    41         // 最后一个字符若是数字,未入栈
    42         if (n != 0) {
    43             nums.push(n);
    44         }
    45         while (!opes.isEmpty()) {
    46             int t = cal(nums.pop(), nums.pop(), opes.pop());
    47             nums.push(t);
    48         }
    49         System.out.println(nums.pop());
    50     }
    51 
    52     // 返回的是运算符的优先级,数字和()不需要考虑
    53     public static int isType(char c) {
    54         if (c == '+' || c == '-') {
    55             return 1;
    56         } else if (c == '*' || c == '/') {
    57             return 2;
    58         } else {
    59             return 0;
    60         }
    61     }
    62 
    63     // 运算次序是反的,跟入栈出栈次序有关
    64     public static int cal(int m, int n, char c) {
    65         int sum = -987654321;
    66         if (c == '+') {
    67             sum = n + m;
    68         } else if (c == '-') {
    69             sum = n - m;
    70         } else if (c == '*') {
    71             sum = n * m;
    72         } else if (c == '/') {
    73             sum = n / m;
    74         }
    75         return sum;
    76     }
    77 }

     

    转载于:https://www.cnblogs.com/16crow/p/6545126.html

    展开全文
  • import java.math.BigDecimal;.../*** 利用栈实现中缀表达式转后缀表达式,并提供对后缀表达式计算* Created by jockiller on 2016/3/4.*/public class BiaoDaShi {public static void main(String[] args...
  • 数学计算的加减乘除人脑算很简单,但是放到计算中却需要进行一些转换,在正式写Java计算数学表达式前,我们需要先来介绍两个概念:前缀表达式、中缀表达式和后缀表达式;(这里的某缀指的是符号的位置) 中缀表达式...
  • /*中缀表达式转成后缀表达式 "12+((22+31)*4)-5" ==> 12 22 31 + 4 * + 5 -第一步,将中缀表达式转成中缀字符串list,方便遍历 [12, +, (, (, 22, +, 31, ), *, 4, ), -, 5]第二步,将中缀字符串list转成后缀...
  • package ...import java.util.ArrayList;import java.util.Stack;import javax.management.RuntimeErrorException;public class CalculatTest {public static void main(String[] args) {ArrayLis...
  • java中缀表达式转后缀表达式计算结果(可以处理多位数
  • 我们用后缀表达式,利用数据结构中的栈,进行结果的计算如果是操作数,则压栈如果是操作符,则出栈两个元素,根据操作符进行计算之后再压栈#includeusing namespace std;#include"Stack.h"enum Type...
  • 后缀表达式:把中缀表达表达式“”转化“”这样的形式,就是后缀表达式。这种记法叫做后缀(postfix)或逆波兰(reverse Polish)记法。计算这个问题最容易的方法就是使用一个栈。转换方法:按次序读取中缀表达式的...
  • 后缀表达式:把中缀表达表达式“5+2*(3*(3-1*2+1))”转化“523312*-1+**+”这样的形式,就是后缀表达式。这种记法叫做后缀(postfix)或逆波兰(reverse Polish)记法。计算这个问题最容易的方法就是使用一个...
  • /*中缀表达式转成后缀表达式 "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转成后缀...
  • 表达式一般有前缀表达式、中缀表达式和后缀表达式3种...而后缀表达式(逆波兰表达式)区别于中缀表达式,是将运算符放在两个操作数之后,无运算符优先和无括号约束问题,很适合计算机进行计算。 因此,我们常常需要...
  • java中缀表达式转后缀表达式 转自尚硅谷韩顺平老师课堂内容 public class Calculator { public static void main(String[] args) { //先定义一个逆波兰表达式(3+4)*5-6 =》 3 4 + 5 * 6 —- String ...
  • 最近在做一个关于计算器的小demo,其中在计算环节需要把待计算的中缀表达式转换成计算机识别的后缀表达式。所以就想系统的整理一下关于中缀表达式转换的问题。一、介绍关于中缀表达式转换后缀表达式的理解,可以参考...
  • package ...import java.util.Scanner;import java.util.Stack;/** @author XueWeiWei* @date 2019/7/7 9:02*/public class PostfixEvaluator {private final static char ...
  • 后缀表达式计算

    2014-07-05 15:02:51
    Java语言实现普通算式的加减乘除运算,先将中缀表达式转换成后缀表达式,同时计算后缀表达式的值,最后得到最终结果!
  • 将扫描到的拼成一个数字,在后缀字符串post中以#号分割 中缀转化为后缀: package text_6; public class Queue { private Object[] original; private int startLength=20; private int f...
  • 思路: ...3.通过后缀表达式计算结果:思路见注释(详细) package stack; import java.util.ArrayList; import java.util.List; import java.util.Stack; public class PolandNotation { p...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 693
精华内容 277
关键字:

java后缀表达式计算

java 订阅