逆波兰问题&计算器实现_学习记录

最新推荐文章于 2024-10-11 19:36:07 发布
最新推荐文章于 2024-10-11 19:36:07 发布
阅读量247 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_37770023/article/details/81433524
本文介绍了一种实现逆波兰表达式解析和计算的方法，包括如何将中序表达式转换为逆波兰表达式，以及如何对逆波兰表达式进行求值。提供了详细的算法步骤和Java实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

逆波兰问题

package p19;

import java.util.ArrayList;
import java.util.List;

/**
 * 逆波兰表达式求值
 * @author Guozhu Zhu
 * @date 2018/8/5
 * @version 1.0
 *
 */
public class NBL {
	
    private static MyStack ms1 = new MyStack();//生成逆波兰表达式的栈
    private static MyStack ms2 = new MyStack();//运算栈

    // 将字符串转换为中序表达式
    public static List<String> zb(String s) {
        List<String> ls = new ArrayList<String>();//存储中序表达式
        int i = 0;
        String str;
        char c;
        while (i < s.length()){
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                i++;
            } else {
                str = "";
                while (i < s.length() && (c = s.charAt(i)) >= 48
                        && (c = s.charAt(i)) <= 57) {
                    str += c;
                    i++;
                }
                ls.add(str);
            }
        }
        return ls;
    }
    
    //将中序表达式转换为逆波兰表达式
    /**
	1、从左至右扫描中缀表达式。
	2、若读取的是操作数，则判断该操作数的类型，并将该操作数存入操作数堆栈
	3、若读取的是运算符
	  (1) 该运算符为左括号"("，则直接存入运算符堆栈。
	  (2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止。
	  (3) 该运算符为非括号运算符：
	      (a) 若运算符堆栈栈顶的运算符为括号，则直接存入运算符堆栈。
	      (b) 若比运算符堆栈栈顶的运算符优先级高，则直接存入运算符堆栈。
	      (c) 若比运算符堆栈栈顶的运算符优先级低或相等，则输出栈顶运算符到操作数堆栈，并将当前运算符压入运算符堆栈。
	4、当表达式读取完成后运算符堆栈中尚有运算符时，则依序取出运算符到操作数堆栈，直到运算符堆栈为空。
     */
    public static List<String> parse(List<String> ls) {
        List<String> lss = new ArrayList<String>();
        for (String ss : ls) {
            if (ss.matches("\\d+") || (ss.charAt(0) == '-' && ss.length() > 1)) {        //数字
                lss.add(ss);
            } else if (ss.equals("(")) {     //(
                ms1.push(ss);
            } else if (ss.equals(")")) {     //)
                while (!ms1.top.equals("(")) {
                    lss.add(ms1.pop());
                }
                ms1.pop();       
            } else {
                while (ms1.size() != 0 && getValue(ms1.top) >= getValue(ss)) {
                    lss.add(ms1.pop());
                }
                ms1.push(ss);
            }
        }
        while (ms1.size() != 0) {
            lss.add(ms1.pop());
        }
        return lss;
    }
    
    //对逆波兰表达式进行求值
    public static int jisuan(List<String> ls) {
        for (String s : ls) {
        	//自然数和负数时
            if (s.matches("\\d+") || (s.length() > 1 && s.charAt(0) == 0)) { 
                ms2.push(s);
            } else {
                int b = Integer.parseInt(ms2.pop());
                int a = Integer.parseInt(ms2.pop());
                if (s.equals("+")) {
                    a = a + b;
                } else if (s.equals("-")) {
                    a = a - b;
                } else if (s.equals("*")) {
                    a = a * b;
                } else if (s.equals("\\")) {
                    a = a / b;
                }
                ms2.push("" + a);
            }
        }
        return Integer.parseInt(ms2.pop());
    }
    
    //获取运算符优先级 +,-为1 *,/为2 ()为0
    public static int getValue(String s) {
        if (s.equals("+")) {
        	return 1;
        } else if (s.equals("-")) {
        	return 1;
        } else if (s.equals("*")) {
        	return 2;
        } else if (s.equals("\\")) {
        	return 2;
        }
        return 0;
    }
    
    //========Test========
    public static void main(String[] args) {
        System.out.println(jisuan(parse(zb("1+((2+3)*4)-5"))));
    }

}

package cn.zhuguozhu.zgzfinal;

import java.math.BigDecimal;
import java.util.ArrayDeque;

public class Calculator {
	
    // 计算表达式的值
    public String caculate(String string) throws Exception {
        // 该部分用来验证中缀表达式是否合理
        // 若右括号数量大于左括号，则说明表达式不合理，抛出异常
        // 否则说明正常，继续进行运算
        int x = 0;
        for (int i = 0; i < string.length(); i++) {
            if (string.charAt(i) == '(') {
                x++;
            } else if (string.charAt(i) == ')') {
                x--;
            }
        }
        if (x < 0) {
            throw new Exception("错误，右括号数量大于左括号");
        }
        // 该集合用来存储操作数
        ArrayDeque<String> value = new ArrayDeque<>();
        // 该集合用来存储运算符
        ArrayDeque<String> operation = new ArrayDeque<>();
        // 该字符串用来临时存储转化后的后缀表达式
        StringBuilder stringBuilder = new StringBuilder();
        // 将中缀表达式的操作数和运算符分离并存放到字符串数组中
        String[] expression = formatInput(string);
        // 遍历字符串数组
        for (String s : expression) {
            // 若该字符串为空则跳过
            if (s.equals(" ") || s.length() == 0) {
                continue;
            } else if (s.charAt(0) == '-' && !s.equals("-")) {    // 若为是负数，则添加至后缀表达式末尾，并补上空格，方便后面将后缀表达式分离
                stringBuilder.append(s + " ");
            } else if (isDigital(s.charAt(0))) {    // 若为正数，添加至后缀表达式并补空格
                stringBuilder.append(s + " ");
            } else if (isOperater(s.charAt(0)) || s.charAt(0) == '(' || s.charAt(0) == ')') {    // 若为运算符，继续判断
                if (s.equals("(")) {//  若为左括号，则压入运算符栈中
                    operation.push(s);
                    continue;
                }
                // 若为右括号，则将运算符栈中第一个左括号以上全部弹出并添加至后缀表达式，左括号直接弹出，不用添加至后缀表达式
                if (s.equals(")")) {
                    while (!operation.getFirst().equals("(")) {
                        if (!operation.getFirst().equals("(")) {
                            stringBuilder.append(operation.poll() + " ");
                        }
                    }
                    if (operation.getFirst().equals("(")) {
                        operation.pop();
                        continue;
                    }
                }
                // 若运算符栈为空，则将运算符压入栈中
                if (operation.isEmpty()) {
                    operation.push(s);
                    continue;
                } else if (priorityIsBiggerOrTheSame(s, operation.getFirst())) {    // 若该运算符比栈顶运算符优先级高，则压入栈中
                    operation.push(s);
                    continue;
                } else {    // 否则弹出所有优先级不比它低的运算符并添加至后缀表达式
                    while (!operation.isEmpty() && !priorityIsBiggerOrTheSame(s, operation.getFirst())) {
                        stringBuilder.append(operation.poll() +" ");
                    }
                    operation.push(s);
                    continue;
                }
            }
        }
        // 弹出操作数栈中所有元素并添加至后缀表达式
        while (!operation.isEmpty()) {
            stringBuilder.append(operation.poll());
        }
        // 格式化后缀表达式(将操作数与运算符分离)
        expression = formatInfixExpression(stringBuilder.toString());
        // 清空后缀表达式
        stringBuilder.delete(0, stringBuilder.length());
        // 遍历字符串数组
        for (String s : expression) {
            // 若该字符串为空，则跳过
            if (s.equals(" ") || s.length() == 0) {
                continue;
            } else if (isDigital(s.charAt(0))) {    // 若为正数则压入操作数栈中
                value.push(s);
            } else if (s.charAt(0) == '-' && !s.equals("-")) {    // 若为负数，则压入操作数栈中
                value.push(s);
            } else if (isOperater(s.charAt(0))) {    // 若为运算符，则判断操作数个数大于2个，则进行弹出两个操作数进行操作，然后将结果压入操作数栈中
                if (value.size() >= 2) {
                    BigDecimal last = new BigDecimal(value.poll());
                    BigDecimal last_p = new BigDecimal(value.poll());
                    if (s.equals("-")) {
                        value.push(last_p.subtract(last).toString());
                    } else if (s.equals("+")) {
                        value.push(last_p.add(last).toString());
                    } else if (s.equals("*")) {
                        value.push(last_p.multiply(last).toString());
                    } else if (s.equals("/")) {
                        value.push(last_p.divide(last, 15, BigDecimal.ROUND_HALF_DOWN).toString());
                    }
                }
            }
        }
        // 弹出最终运算结果并返回
        return value.poll();
    }
    // 判断是否为运算符，若为运算符，则返回true，否则返回false
    public static boolean isOperater(int a) {
        if (a == '+' || a == '-' || a == '*' || a == '/')
            return true;
        return false;
    }
    // 判断是否为数字，若为数字，则返回true，否则返回false
    public static boolean isDigital(int a) {
        if (a >= '0' && a <= '9')
            return true;
        return false;
    }

    // 格式化中缀表达式输入，即在符号前后添加空格，便于后面的分隔操作
    public static String[] formatInput(String s) {
        String temp = "";
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (i == 0 && c == '-') {
                temp += c;
            } else if (isOperater(c) || c == '(' || c == ')') {
                if ((i - 1) >= 0 && (i + 1) < s.length()
                        && (isOperater(s.charAt(i - 1)) || s.charAt(i - 1) == '(' || s.charAt(i - 1) == ' ')
                        && c == '-' && isDigital(s.charAt(i + 1))) {
                    temp += " " + c;
                } else {
                    temp += " " + c + " ";
                }
            } else
                temp += c; // 数字不用加空格
        }
        return temp.split(" "); // 分割
    }
	
    // 格式化后缀表达式
    public static String[] formatInfixExpression(String s) {
        String temp = "";
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (isOperater(c)) {
                if (c == '-' && i + 1 < s.length() && isDigital(s.charAt(i + 1))) {
                    temp += " " + c;
                } else {
                    temp += " " + c + " ";
                }
            } else {
                temp += c; // 数字不用加空格
            }
        }
        return temp.split(" "); // 分割
    }

    // 优先级判断，a是否大于b
    public static boolean priorityIsBiggerOrTheSame(String a, String b) {
        String s = " +- */";
        return s.indexOf(a) - s.indexOf(b) >= 2;
    }
	
}

 

C语言 逆波兰算法实现计算器（源码）
weixin_46654029的博客
08-24 3555
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
逆波兰记法
码上看世界
12-06 530
逆波兰记法(Reverse Polish notation, RPN)是一种数学表达式表示方式，在逆波兰表达式中，所有的操作符位于操作数之后，也被称为`后缀表示法`。例如:`3+4`的逆波兰记法为`34+`。
C++实现 逆波兰表达式计算问题
weixin_34246551的博客
04-05 413
　　　　　　　　　　C++实现 逆波兰表达式计算问题   #include &amp;lt;iostream&amp;gt; #include &amp;lt;string&amp;gt; using namespace std; class Stack { private: int size; int top; float *listArray; public: St...
一个C的逆波兰式计算器的问题
dj_may的专栏
01-04 586
#include #include #define MAXOP 100 #define NUMBER '0' int getop(char []); void push(double); double pop(void); // 调试的时候输入 12 5 + 4 2 - * 中间用空格隔开，以回车结束 int main(int argc, char *argv[]) {
逆波兰表达式问题
Qngcken的博客
02-20 207
插眼：前缀表达式、中缀表达式、后缀表达式 =&gt; 二叉树前序遍历、中序遍历、后序遍历
问题 B: 逆波兰表达式
qq_47189506的博客
04-13 342
题目描述 逆波兰表达式是一种把运算符前置的算术表达式 ， 例如普通的表达式 2 + 3 的逆波兰表示法为＋ 2 3。逆波兰表达式的优点是运算符之间不必有优先级关系，也 不必用括号改变运算次序， 例如( 2 + 3 ) * 4 的逆波兰表示法为＊ ＋ 2 3 4。本题求解逆波兰表达式的 值， 其中运算符包括＋、－、＊、／四种。 输入 输入为一行，其中运算符和运算数之间都用空格分隔，运算数是浮点数。 输出 输出为一行，为表达式的值(长度 ≤100)。 输入输出样例 样例输入 #1 * + ..
逆波兰表达式求值问题
稚彦的博客
09-06 378
逆波兰表达式 逆波兰表达式又被称为后缀表达式。特点：运算符总是放在它相关数的后面 中缀表达式 中缀表达式就是平常生活中使用的表达式，特点：二元运算符总是置于两个操纵数中间 解题思路： 1.创建一个栈对象oprands存储操作数 2.从左到右遍历逆波兰表达式，得到每一个字符串 3.判断字符串是不是运算符，如果不是，则说明是操纵数，把操纵数压入栈中 4.如果是运算符，则从oprands中弹出两个操作数o1,o2 5.使用该运算符计算o1和o2，得到结果result 6.把该结果压入oprands栈中 7.遍历结
jisuanqi.zip_小数计算器_小数运算_计算器 小数_计算器+小数_计算器小数
09-24
这通常通过解析表达式或使用逆波兰表示法（RPN，Reverse Polish Notation）来实现。 5. **历史记录**：为了方便用户回顾之前的计算，计算器可以提供一个历史记录功能，保存和显示之前的运算和结果。 &quot;计算器.txt&quot; ...
JAVA_Calculator.zip_Java科学计算器_java calculator_java 计算器_科学计算器_计算器
09-24
例如，可以使用前缀、后缀或中缀表达式（即波兰表示法、逆波兰表示法和常规表达式）进行解析。 4. **数学运算**：科学计算器需要支持复杂数学运算，如对数、指数、平方根、三角函数等。Java的标准库`java.lang.Math...
逆波兰表达式计算器代码.zip
10-15
本压缩包&ldquo;逆波兰表达式计算器代码.zip&rdquo;包含了一个实现逆波兰表达式计算的代码实例，适用于网页开发，利用了jQuery特效、CSS特效来提升用户体验。 首先，我们要理解逆波兰表达式的计算原理。常规的数学表达式如 &quot;2...
Android 带滑动、抽屉效果的逆波兰式计算器
09-05
在Android开发中，创建一个带有滑动抽屉效果和逆波兰式计算器的App是一项具有挑战性的任务，它结合了UI设计和算法实现。这个项目主要涉及以下几个关键知识点： 1. **Android UI组件**：抽屉（Drawer）效果是Android...
算法通关村——逆波兰表达式问题
m0_74188776的博客
09-14 615
想想栈呢，栈的特性后进先出，我们将每个数字压入栈中，由于找到符号后，就将前两个数字计算，这样我们弹出两个数字，刚好是前两个数字，计算后再放入栈中，刚好又保存了新的数字，直到没有找到符号，我们的表达式也就算完了，最后栈里的数字就是想要的结果。如果用数组，我们找到符号后，前面两个数计算后的结果，保存在哪里呢，就算保存了，我们万一后面又出现数字，那么还要保存前面数组最后的数字位置，这样会很麻烦，所以数组pass。在数据结构里，这可以看成是一个二叉树，如下图，每个结点可能是个计算符，也可能是个数字。
逆波兰表达
chuihezan4315的博客
10-24 241
逆波兰表示法 逆波兰表示法（Reverse Polish notation，RPN，或逆波兰记法），是一种是由波兰数学家扬·武卡谢维奇1920年引入的数学表达式方式，在逆波兰记法中，所有操作符置于操作数的后面，因此也被称为后缀表示法。逆波兰记法不需要括号来标识操作符的优先级。 逆波兰结构由弗里...
简易的逆波兰标记法计算器
HATREDQAQ的博客
08-13 264
在所谓的逆波兰标记法中，操作符是在其作用的操作数之后被输入的。 如你如果想要计算8*4+6/3则需要按以下步骤输入： 8 enter 4 * 6 enter 3 / + 思路还是利用栈来保存数据以此来方便计算。 下面直接给出代码： import java.util.Scanner; import java.util.Stack; public class RPNCalculator { public void run() { Scanner sysin=new Scanner(System.in)
使用栈解决逆波兰表达式（后缀表达式）
m0_37723587的博客
05-23 1161
逆波兰表达式又称逆序表达式，即运算符号出现在数字的后面。 主要形式为：解决思路： 逆波兰表达式解决的主要思路是利用弹栈、入栈的思想，当遇到‘+、-、*、/’等运算符的时候，在栈中弹出栈顶的两个数据进行运算，然后将运算的结果压入栈。LeetCode上面的一道例题： 值得注意的问题是，在处理‘-、/’这两个操作的时候，顺序问题很重要，先出栈的元素做为被操作数在操作符的后面。实现代码如下：impor
实现一个链接存储的栈（数据结构与算法 - 栈）
韶言大雅
04-24 9260
相关知识 链接存储的栈 栈的存储也可以采用链接存储的方式来实现。下面给出了一种基于链接存储的栈的实现方案： 如图 1 所示：该栈存储了 3 个元素 {56,77,15} ，其中 56 是栈顶元素。 这种实现方案中与栈相关的两个属性元素top和len介绍如下： top: 指向栈顶结点的指针； len: 栈中结点的个数。 特别说明：链接存储方式下，链表头结点作为栈顶结点，用指针top指向栈顶结点，栈...
栈的链接存储——分析与实现
ILoveASN的博客
10-20 966
本文实现目标： 实现 step2/LnkStack.cpp 中的LS_IsEmpty、LS_Length、LS_Push、LS_Pop和LS_Top五个操作函数，以实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。 相关知识 链接存储的栈 栈的存储也可以采用链接存储的方式来实现。下面给出了一种基于链接存储的栈的实现方案： 如图 1 所示：该栈存储了 3 个元素 {56,77,15} ，其中 56 是栈顶元素。 这种实现方案中与栈相关的两个属性元素top和len介绍如下： t
educoder数据结构与算法 队列 第2关 实现一个链接存储的队列
qq_54008392的博客
12-11 8802
任务描述 本关任务：实现 step2/CLnkQueue.cpp 中的CLQ_IsEmpty、CLQ_Length、CLQ_In和CLQ_Out四个操作函数，以实现判断队列是否为空、求队列长度、队列元素入队和出队等功能。 相关知识 链式队列的定义 队列的存储除了顺序存储之外也可以采用链接存储方式来实现。图 1 描述了队列的一种链接存储实现方案。 该队列存储了 3 个元素 {56,77,15} ，其中 56 为队列头， 15 为队列尾。 这种实现方案中涉及到的两个属性元素如下： rear:
第2关：实现一个链接存储的栈
最新发布
dust_as_light的博客
10-11 612
本关任务是实现step2/LnkStack.cpp中的LS_IsEmpty、LS_Length、LS_Push、LS_Pop和LS_Top五个操作函数，以实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。输入多个操作：如果输入”push”，则后面跟一个数x，表示x进栈；LS_IsEmpty：判断栈是否为空，若栈为空，则返回true，否则返回false。LS_Pop：若出栈成功(栈不为空)，则返回true；LS_Push：将元素x进栈，若满栈则无法进栈，返回false，否则返回true。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值