OJ-0918**

已于 2024-10-01 16:15:39 修改
阅读量367 收藏 4
点赞数 6
文章标签： java 算法
于 2024-09-18 13:35:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsd_ontheroad/article/details/142330467
版权

题目

在这里插入图片描述
示例1

输入：
1 + 5 * 7 / 8
输出：
43/8

示例2

输入：
1 / (0 - 5)
输出：
-1/5

说明：负号需要提到最前面

示例3

输入：
1 * (3 * 4 / (8 - (7 + 0)))
输出：
12

说明：注意括号可以多重嵌套

解题思路

1.处理空格：首先，去除输入表达式中的空格。
2.转换为逆波兰表达式：利用栈来将中缀表达式转换为逆波兰表达式。这可以通过遍历输入表达式的每个元素来实现。遇到数字直接输出，遇到运算符则比较其优先级与栈顶运算符的优先级，按照一定规则进行出栈和入栈操作。具体规则可以参考算法导论中关于中缀表达式转换为逆波兰表达式的算法。
3.计算逆波兰表达式：利用栈来计算逆波兰表达式。
遍历逆波兰表达式的每个元素，遇到数字则入栈，遇到运算符则从栈中弹出足够的操作数进行运算，再将结果入栈。重复此过程直到表达式结束。
4. 处理分数：在计算过程中，需要考虑分数的表示和简化。可以使用一个结构体或类来表示分数，其中包含分子和分母两个整数。每次运算后，检查结果是否为整数，如果是整数则直接输出，如果是分数则对分数进行化简。
5.异常处理：在计算过程中，需要检查除数是否为0。如果遇到除数为0的情况，直接输出"ERROR"

题解

优化之后：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

/**
 * @Author: 
 * @Create: 2024-10-01 13:51
 * @Description:
 */
public class 给定一个表达式2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String infix = in.nextLine().replace(" ", "");
        List<String> suffix = changeToSuffix(infix);
        try {
            Num num = calculateSuffix(suffix);
            System.out.println(num.getResult(num));
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }

    private static Num calculateSuffix(List<String> suffix) {
        Stack<Num> nums = new Stack<>();
        Num res = new Num(0, 1);
        for (String s : suffix) {
            if (s.matches("\\d+")) {
                nums.push(new Num(Integer.parseInt(s), 1));
            } else {
                Num num1 = nums.pop();
                Num num2 = nums.pop();
                if ("*".equals(s)) {
                    res = num2.mul(num1);
                } else if ("/".equals(s)) {
                    res = num2.div(num1);
                } else if ("+".equals(s)) {
                    res = num2.add(num1);
                } else if ("-".equals(s)) {
                    res = num2.sub(num1);
                } else {
                    throw new ArithmeticException("运算符有误");
                }
                nums.push(res);
            }
        }
        return res;
    }

    private static List<String> changeToSuffix(String infix) {
        Stack<String> oper = new Stack<>();
        ArrayList<String> res = new ArrayList<>();

        int len = infix.length();
        for (int i = 0; i < len; i++) {
            char c = infix.charAt(i);
            if (Character.isDigit(c)) {
                int j = i;
                while (j < len && Character.isDigit(infix.charAt(j))) {
                    j++;
                }
                res.add(infix.substring(i, j));
                i = --j;
            } else if (c == '(') {
                oper.push(c + "");
            } else if (c == ')') {
                while (!oper.isEmpty() && !"(".equals(oper.peek())) {
                    res.add(oper.pop());
                }
                oper.pop();
            } else {
                while (!oper.isEmpty() && getPriority(c + "") <= getPriority(oper.peek())) {
                    res.add(oper.pop());
                }
                oper.push(c + "");
            }
        }
        while (!oper.isEmpty()) {
            res.add(oper.pop());
        }
        return res;
    }

    private static int getPriority(String operator) {
        if ("*".equals(operator) || "/".equals(operator)) return 2;
        else if ("+".equals(operator) || "-".equals(operator)) return 1;
        else return 0;
    }

    static class Num {
        int x;
        int y;

        public Num(int x, int y) {
            this.x = x;
            this.y = y;
        }

        private Num mul(Num num) {
            return new Num(this.x * num.x, this.y * num.y);
        }

        private Num div(Num num) {
            if (num.x == 0) {
                throw new ArithmeticException("ERROR");
            }
            return new Num(this.x * num.y, this.y * num.x);
        }

        private Num add(Num num) {
            return new Num(this.x * num.y + this.y * num.x, this.y * num.y);
        }

        private Num sub(Num num) {
            return new Num(this.x * num.y - this.y * num.x, this.y * num.y);
        }

        private int gcd(int a, int b) {
            return a % b == 0 ? b : gcd(b, a % b);
        }

        private String getResult(Num num) {
            int xy_gcd = gcd(num.x, num.y);
            int x = num.x / xy_gcd;
            int y = num.y / xy_gcd;
            if (x * y < 0) {
                x = -Math.abs(x);
                y = Math.abs(y);
            }
            return x % y == 0 ? x / y + "" : x + "/" + y;
        }
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String expression = in.nextLine();
        List<String> infixExpressList = toInfixExpressList(expression);
        List<String> suffixExpressionList = parseSuffixExpressionList(infixExpressList);
        try {
            System.out.println(calculate(suffixExpressionList));
        } catch (Exception e) {
            System.out.println("ERROR");
        }
    }

    private static String calculate(List<String> list) {
        Stack<Num> stack = new Stack<>();
        for (String item : list) {
            if (item.matches("\\d+")) {
                stack.push(new Num(Integer.parseInt(item)));
            } else {
                Num num2 = stack.pop();
                Num num1 = stack.pop();
                Num res = new Num(0);
                switch (item) {
                    case "+":
                        add(res, num1, num2);
                        break;
                    case "-":
                        sub(res, num1, num2);
                        break;
                    case "*":
                        multi(res, num1, num2);
                        break;
                    case "/":
                        div(res, num1, num2);
                        break;
                    default:
                        break;
                }
                stack.push(res);
            }
        }
        return getRes(stack.pop());
    }

    private static String getRes(Num res) {
        int x = res.x;
        int y = res.y;
        if (x * y < 0) {
            x = -Math.abs(x);
            y = Math.abs(y);
        }
        return x % y == 0 ? x / y + "" : x + "/" + y;
    }

    private static void div(Num res, Num num1, Num num2) {
        if (num2.x == 0) {
            throw new RuntimeException();
        }
        res.x = num1.x * num2.y;
        res.y = num1.y * num2.x;
        simplify(res);
    }

    private static void multi(Num res, Num num1, Num num2) {
        res.x = num1.x * num2.x;
        res.y = num1.y * num2.y;
        simplify(res);
    }

    private static void add(Num res, Num num1, Num num2) {
        res.x = num1.x * num2.y + num1.y * num2.x;
        res.y = num1.y * num2.y;
        simplify(res);
    }

    private static void sub(Num res, Num num1, Num num2) {
        res.x = num1.x * num2.y - num1.y * num2.x;
        res.y = num1.y * num2.y;
        simplify(res);
    }

    private static void simplify(Num res) {
        int xyGcd = gcd(res.x, res.y);
        res.x /= xyGcd;
        res.y /= xyGcd;
    }

    private static List<String> parseSuffixExpressionList(List<String> list) {
        Stack<String> s1 = new Stack<>();
        List<String> s2 = new ArrayList<>();
        for (String item : list) {
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();
            } else { // 运算符
                while (!s1.isEmpty() && getPriority(item) <= getPriority(s1.peek())) {
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
        }
        // s1剩余-->s2
        while (!s1.isEmpty()) {
            s2.add(s1.pop());
        }
        return s2;
    }

    private static List<String> toInfixExpressList(String s) {
        List<String> res = new ArrayList<>();
        int i = 0;
        while (i < s.length()) {
            if (' ' == s.charAt(i)) {
                i++;
            } else if (!Character.isDigit(s.charAt(i))) {
                res.add(s.charAt(i) + "");
                i++;
            } else {
                StringBuilder str = new StringBuilder();
                while (i < s.length() && Character.isDigit(s.charAt(i))) {
                    str.append(s.charAt(i));
                    i++;
                }
                res.add(str.toString());
            }
        }
        return res;
    }

    // 最大公约数
    public static int gcd(int a, int b) {
        return (a % b == 0) ? b : gcd(b, a % b);
    }

    public static int getPriority(String input) {
        if (input.equals("*") || input.equals("/")) {
            return 2;
        } else if (input.equals("+") || input.equals("-")) {
            return 1;
        } else {
            return 0;
        }
    }

    static class Num {
        int x;
        int y = 1;

        public Num(int x) {
            this.x = x;
        }
    }
}

参考

存在问题

import java.util.Scanner;
import java.util.Stack;

public class 给定一个表达式 {
    public static Stack<Integer[]> nums;
    public static Stack<Character> operations;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String input_str1 = in.nextLine();
        nums = new Stack<>();
        operations = new Stack<>();
        int length = input_str1.length();
        char[] input_str = input_str1.toCharArray();

        String current = "";
        int i = 0;
        while (i < length) {
            if (Character.isDigit(input_str[i])) {
                while (true) {
                    if (!Character.isDigit(input_str[i])) {
                        break;
                    }
                    current += input_str[i];
                    if (i + 1 >= length) {
                        break;
                    }
                    i += 1;
                }
                nums.push(new Integer[]{1, Integer.parseInt(current)});
                current = "";
            } else if (input_str[i] == '(') {
                operations.push(input_str[i]);
            } else if (input_str[i] == ')') {
                while (operations.peek() != '(') {
                    eval();
                }
                operations.pop();
            } else if (input_str[i] == ' ') {
                i += 1;
                continue;
            } else {
                while (!operations.isEmpty() && operations.peek() != '('
                        && get_priority(input_str[i]) <= get_priority(operations.peek())) {
                    eval();
                }
                operations.push(input_str[i]);
            }

            i++;
        }

        while (true) {
            if (nums.size() <= 1) {
                break;
            } else {
                eval();
            }
        }

        Integer[] result = nums.peek();
        if (result[0] == 0) {
            System.out.println("ERROR");
        } else {
            int up = gcd(result[0], result[1]);
            result[0] /= up;
            result[1] /= up;
            if (result[0] * result[1] < 0) {
                System.out.print("-");
            }
            if (Math.abs(result[0]) == 1) {
                System.out.println(result[1]);
            } else {
                System.out.println(Math.abs(result[1]) + "/" + Math.abs(result[0]));
            }
        }
    }

    // 最大公约数
    public static int gcd(int a, int b) {
        return (a % b == 0) ? b : gcd(b, a % b);
    }

    public static void eval() {
        Integer[] nums1 = nums.pop();
        Integer[] nums2 = nums.pop();
        char x = operations.pop();
        Integer[] result = new Integer[2];

        if (x == '*' || x == '+' || x == '-') {
            result[0] = nums2[0] * nums1[0];
        } else {
            result[0] = nums2[0] * nums1[1];
        }

        int sum_a = nums2[1] * nums1[0];
        int sum_b = nums1[1] * nums2[0];
        if (x == '*') {
            result[1] = nums2[1] * nums1[1];
        } else if (x == '+') {
            result[1] = sum_a + sum_b;
        } else if (x == '-') {
            result[1] = sum_a - sum_b;
        } else {
            result[1] = nums2[1] * nums1[0];
        }
        nums.push(result);
    }

    public static int[] split(String input_str, String chars) {
        String[] tmp2 = input_str.split(chars);
        int[] results = new int[tmp2.length];
        for (int i = 0; i < tmp2.length; i++) {
            results[i] = Integer.parseInt(tmp2[i]);
        }
        return results;
    }

    public static int get_priority(Character input) {
        if (input == '+' || input == '-') {
            return 0;
        } else {
            return 1;
        }
    }
}
代码改变世界888
关注
oj-ACM资源oj-ACM资源
09-05
PowerOJ is a online judge for ACM/ICPC or OI.
波兰表达式
guagua290290的博客
05-03 648
波兰表达式AC代码
波兰表达式问题
weixin_41828221的博客
09-10 1882
波兰表达式是一种把运算符前置的算术表达式，例如普通的表达式2 + 3 的波兰表示法为+ 2 3。波兰表达式的优点是运算符之间不必有优先级关系，也不必用括号改变运算次序，例如(2 + 3) * 4 的波兰表示法为* + 2 3 4。本题求解波兰表达式的值，其中运算符包括 + - * / 四个。 思路： 这个问题是一个比较常见的问题，有很多变形。如果不细细分析的话，会觉得这个问题非常的复杂。但是如...
波兰表达式 c++
wangminghao12345的博客
03-26 2575
波兰表达式 c++ 不会的小伙伴来看
NOI 1696:波兰表达式
qq_67473550的博客
06-24 458
波兰表达式是一种把运算符前置的算术表达式，例如普通的表达式2 + 3的波兰表示法为+ 2 3。波兰表达式的优点是运算符之间不必有优先级关系，也不必用括号改变运算次序，例如(2 + 3) * 4的波兰表示法为* + 2 3 4。本题求解波兰表达式的值，其中运算符包括+ - * /四个。可使用atof(str)把字符串转换为一个double类型的浮点数。输入为一行，其中运算符和运算数之间都用空格分隔，运算数是浮点数。可直接用printf("%f\n", v)输出表达式的值v。输出为一行，表达式的值。
波兰表达式求解
weixin_42370876的博客
04-19 4148
逆波兰表达式 逆波兰表达式是一种把运算符前置的算术表达式。 例如普通的表达式2+3的逆波兰表示法为+ 2 3。 逆波兰表达式的优点是运算符之间不必有优先级关系, 也不必用括号改变运算次序。 例如(2+3)4的逆波兰表达法为 + 2 3 4。 本题求解逆波兰表达式的值, 其中运算符包括+、-、*、/四个. 输入格式: 1行, 其中运算符和运算数之间都用空格分隔, 运算数是浮点数。 输出格式: 1行,...
a2oj-源码.rar
10-10
《A2OJ 源码解析》 A2OJ，全称为 "Algorithms and Online Judges"，是一个在线编程竞赛平台，旨在帮助程序员提升算法技能并进行实战演练。源码rar文件"A2OJ-源码.zip"包含了这个平台的部分或全部后端和前端代码，为...
leetcode和oj-oj-solutions:oj-解决方案
06-30
leetcode 和 oj 我的 OJ 解决方案 这个存储库包含了我的问题解决方案，来自 ，和望岛书。 目前无法访问。 使用 GCC 7.2.0。
OJ-problem-solving:关键词：OJ解题思路
04-01
在编程世界中，Online Judge（简称OJ）是一种用于在线测试和评估编程解决方案的系统。它们通常被用于教育目的，特别是在计算机科学课程中，帮助学生练习和提高编程技能。本资源"OJ-problem-solving"显然是针对OJ解题...
sduoj-sandbox.zip
04-03
sduoj-sandbox.zip
C语言波兰表达式求值
星空千代
04-14 4717
利用一个操作数栈，从表达式末尾遍历，遇到数字则入栈，遇到运算符则依次出栈两个数进行运算，然后将结果入栈。这样扫描完整个表达式之后，栈中剩下的即为表达式的值。
解题报告2
weixin_50982418的博客
07-20 228
寻找因式时要避免因式顺序颠倒而导致因式重复的情况，比如6的因式为1和6,2和3两组，3和2与2和3所表示的是一种情况。该题比较简单，其核心就是定义一个缓存将某些数据先保存下来，再进行数据的传递，以此来达到与斐波那契数列相同的计算过程，大致过程为定义f,f1,f2三个整数，先将f1与f2的和赋值给f,再将f2赋值给f1,将f赋值给f2，以此来达到目的。写一个程序，找到无法匹配的左括号和右括号，输出原来字符串，并在下一行标出不能匹配的括号。（1，20），（2,10），（4,5），（2,2,5）四组。...
简单的询问--差分数组
大帅的博客
12-11 508
Problem A: 简单的询问 Time Limit: 1 Sec Memory Limit: 64 MB Description 给你N个区间[Li,Ri]，有Q个询问。 每个询问问，num这个数是否在给出的某个区间内。 Input 输入第一行有一个正整数T(T&amp;amp;lt;=10)，表示组数； 每组数据第一行有两个正整数N,Q(N,Q&amp;amp;lt;=1e5)，意义如题； 接下来行每行包含两个正整数Li...
代码随想录算法训练营Day12 | 150. 逆波兰表达式求值 | 239. 滑动窗口最大值 | 347. 前 K 个高频元素
最新发布
wonderlandlja的博客
07-02 1289
根据 逆波兰表示法，求表达式的值。有效的运算符包括 + , - , * , /。每个运算对象可以是整数，也可以是另一个逆波兰表达式。说明：整数除法只保留整数部分。给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
蓝桥杯---算法训练
qq_41857047的博客
12-21 441
1、区间K大数查询 问题描述 给定一个序列，每次询问序列中第l个数到第r个数中第K大的数是哪个。 输入格式 第一行包含一个数n，表示序列长度。 第二行包含n个正整数，表示给定的序列。 第三个包含一个正整数m，表示询问个数。 接下来m行，每行三个数l,r,K，表示询问序列从左往右第l个数到第r个数中，从大往小第K大的数是哪个。序列元素从1开始标号。 输出格式 总共输出m行，每行一个数，表...
2023年3月青少年软件编程（C语言）等级考试试卷（六级）
No0d1es的博客
04-24 520
波兰表达式是一种把运算符前置的算术表达式，例如普通的表达式2 + 3的波兰表示法为+ 2 3。波兰表达式的优点是运算符之间不必有优先级关系，也不必用括号改变运算次序，例如(2 + 3) * 4的波兰表示法为* + 2 3 4。字符串中可能有三种成对的括号，"( )"、"[ ]"、"{ }"。括号交叉算不正确配对，例如"12{34[78}ab]"就不算正确配对。对每行字符串，如果括号配对，输出"YES"，否则输出"NO"。可直接用printf("%f\n", v)输出表达式的值v。输出为一行，表达式的值。
150. 逆波兰表达式求值
qq_63819197的博客
09-13 45
思路：因为题目告诉了用栈，所有思路不难。但是我不了解stoll函数，导致强制转换时，用c知识写的很麻烦且有问题。该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6。该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9。返回一个表示表达式值的整数。
sdut-oj-最小生成树c
06-17
SDUT-OJ（Software Development University of Tsinghua Online Judge）是一个在线编程平台，提供给清华大学软件学院的学生和爱好者练习和解决算法问题的环境，其中包括各种计算机科学题目，包括数据结构、算法、图形等。对于"最小生成树"（Minimum Spanning Tree, MST）问题，它是图论中的经典问题，目标是从一个加权无向图中找到一棵包含所有顶点的树，使得树的所有边的权重之和最小。 在C语言中，最常见的是使用Prim算法或Kruskal算法来求解最小生成树。Prim算法从一个顶点开始，逐步添加与当前生成树相连且权重最小的边，直到所有顶点都被包含；而Kruskal算法则是从小到大对所有边排序，每次选取没有形成环的新边加入到树中。 如果你想了解如何用C语言实现这些算法，这里简单概括一下： - 通常使用优先队列（堆）来存储边和它们的权重，以便快速查找最小值。 - 从任意一个顶点开始，遍历与其相邻的边，若新边不形成环，就更新树，并将新边加入优先队列。 - Kruskal算法： - 先将所有的边按照权重升序排序。 - 创建一个空的最小生成树，然后依次取出排序后的边，如果这条边连接的两个顶点不在同一个连通分量，则将其添加到树中。 如果你需要更详细的代码示例，或者有具体的问题想了解（比如如何处理环、如何实现优先队列等），请告诉我，我会为你提供相应的帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值