计算表达式【学习算法】

简介: 计算表达式【学习算法】

前言

2023-9-24 23:02:07

以下内容源自《【学习算法】》

仅供学习交流使用


推荐

计算表达式

逆波兰表达式求值

150. 逆波兰表达式求值

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<String> stack=new Stack();
        for(String s:tokens){
            if(s.equals("+")){
                int b=Integer.parseInt(stack.pop());
                int a=Integer.parseInt(stack.pop());
                int c=a+b;
                stack.push(Integer.toString(c));
            }else if(s.equals("-")){
                int b=Integer.parseInt(stack.pop());
                int a=Integer.parseInt(stack.pop());
                int c=a-b;
                stack.push(Integer.toString(c));
            }else if(s.equals("*")){
                int b=Integer.parseInt(stack.pop());
                int a=Integer.parseInt(stack.pop());
                int c=a*b;
                stack.push(Integer.toString(c));
            }else if(s.equals("/")){
                int b=Integer.parseInt(stack.pop());
                int a=Integer.parseInt(stack.pop());
                int c=a/b;
                stack.push(Integer.toString(c));
            }else{
                stack.push(s);
            }
        }
        return Integer.parseInt(stack.pop());
    }
}

中缀表达式求值

面试题 16.26. 计算器

LeetCode

class Solution {
    public int calculate(String s) {
        Deque<Integer> stack = new ArrayDeque<Integer>();
        char preSign = '+';
        int num = 0;
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            if (Character.isDigit(s.charAt(i))) {
                num = num * 10 + s.charAt(i) - '0';
            }
            if (!Character.isDigit(s.charAt(i)) && s.charAt(i) != ' ' || i == n - 1) {
                switch (preSign) {
                case '+':
                    stack.push(num);
                    break;
                case '-':
                    stack.push(-num);
                    break;
                case '*':
                    stack.push(stack.pop() * num);
                    break;
                default:
                    stack.push(stack.pop() / num);
                }
                preSign = s.charAt(i);
                num = 0;
            }
        }
        int ans = 0;
        while (!stack.isEmpty()) {
            ans += stack.pop();
        }
        return ans;
    }
}

算法优先分析法

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
public class Solution {
    public static void main(String[] args) {
        String token="3/2";
        int res=calculate(token);
        System.out.println(res);
    }
    static HashSet<Character> opSet =new HashSet<>();
    static {
        opSet.add('#');
        opSet.add('+');
        opSet.add('-');
        opSet.add('*');
        opSet.add('/');
        opSet.add('(');
        opSet.add(')');
    }
    static HashMap<Character,HashMap<Character,Character>> relation=new HashMap<>();
    static {
        HashMap<Character,Character> map=new HashMap<>();
        map.put('+','>');
        map.put('-','>');
        map.put('*','<');
        map.put('/','<');
        map.put('(','<');
        map.put(')','>');
        map.put('#','>');
        relation.put('+',map);
        relation.put('-',map);
        map=new HashMap<>();
        map.put('+','>');
        map.put('-','>');
        map.put('*','>');
        map.put('/','>');
        map.put('(','<');
        map.put(')','>');
        map.put('#','>');
        relation.put('*',map);
        relation.put('/',map);
        map=new HashMap<>();
        map.put('+','<');
        map.put('-','<');
        map.put('*','<');
        map.put('/','<');
        map.put('(','<');
        map.put(')','=');
        relation.put('(',map);
        map=new HashMap<>();
        map.put('+','>');
        map.put('-','>');
        map.put('*','>');
        map.put('/','>');
        map.put(')','>');
        map.put('#','>');
        relation.put(')',map);
        map=new HashMap<>();
        map.put('+','<');
        map.put('-','<');
        map.put('*','<');
        map.put('/','<');
        map.put('(','<');
        map.put('#','=');
        relation.put('#',map);
    }
    public static int calculate(String s) {
        s = s.replaceAll("\\s+","");
        s += '#';
        Deque<Integer> numStack = new ArrayDeque<>();
        Deque<Character> opStack = new ArrayDeque<>();
        opStack.push('#');
        int i = 0;
        char ch = s.charAt(i);
        while (ch != '#' || opStack.peek() != '#') {
            if (!opSet.contains(ch)) {
                while (ch == ' ') {
                    ch = s.charAt(++i);
                }
                int data = 0;
                data = ch - '0';
                ch = s.charAt(++i);
                while (!opSet.contains(ch)) {
                    data = data * 10 + ch - '0';
                    ch = s.charAt(++i);
                }
                numStack.push(data);
            } else {
                switch (compare(opStack.peek(), ch)) {
                    case '<':
                        opStack.push(ch);
                        ch = s.charAt(++i);
                        break;
                    case '=':
                        char x = opStack.pop();
                        ch = s.charAt(++i);
                        break;
                    case '>':
                        char op = opStack.pop();
                        Integer data2 = numStack.pop();
                        Integer data1 = numStack.pop();
                        int val = cal(data1, op, data2);
                        numStack.push(val);
                        break;
                }
            }
        }
        int val = numStack.pop();
        return val;
    }
    private static int cal(Integer data1, char op, Integer data2) {
        switch (op){
            case '+': return data1+data2;
            case '-': return data1-data2;
            case '*': return data1*data2;
            case '/': return data1/data2;
            default: return 0;
        }
    }
    private static char compare(char op1, char op2) {
        return relation.get(op1).get(op2);
    }
}

最后

我们都有光明的未来

祝大家考研上岸

祝大家工作顺利

祝大家得偿所愿

祝大家如愿以偿

点赞收藏关注哦

相关文章
|
2月前
|
存储 算法 安全
2024重生之回溯数据结构与算法系列学习之串(12)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丟脸好嘛?】
数据结构与算法系列学习之串的定义和基本操作、串的储存结构、基本操作的实现、朴素模式匹配算法、KMP算法等代码举例及图解说明;【含常见的报错问题及其对应的解决方法】你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
2024重生之回溯数据结构与算法系列学习之串(12)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丟脸好嘛?】
|
2月前
|
机器学习/深度学习 人工智能 自然语言处理
【EMNLP2024】基于多轮课程学习的大语言模型蒸馏算法 TAPIR
阿里云人工智能平台 PAI 与复旦大学王鹏教授团队合作,在自然语言处理顶级会议 EMNLP 2024 上发表论文《Distilling Instruction-following Abilities of Large Language Models with Task-aware Curriculum Planning》。
|
2月前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习(8)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
2月前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习之单双链表精题详解(9)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
2月前
|
存储 Web App开发 算法
2024重生之回溯数据结构与算法系列学习之单双链表【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构之单双链表按位、值查找;[前后]插入;删除指定节点;求表长、静态链表等代码及具体思路详解步骤;举例说明、注意点及常见报错问题所对应的解决方法
|
2月前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之栈和队列精题汇总(10)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第3章之IKUN和I原达人之数据结构与算法系列学习栈与队列精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
2月前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习之王道第2.3章节之线性表精题汇总二(5)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
IKU达人之数据结构与算法系列学习×单双链表精题详解、数据结构、C++、排序算法、java 、动态规划 你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
13天前
|
机器学习/深度学习 算法
基于改进遗传优化的BP神经网络金融序列预测算法matlab仿真
本项目基于改进遗传优化的BP神经网络进行金融序列预测,使用MATLAB2022A实现。通过对比BP神经网络、遗传优化BP神经网络及改进遗传优化BP神经网络,展示了三者的误差和预测曲线差异。核心程序结合遗传算法(GA)与BP神经网络,利用GA优化BP网络的初始权重和阈值,提高预测精度。GA通过选择、交叉、变异操作迭代优化,防止局部收敛,增强模型对金融市场复杂性和不确定性的适应能力。
146 80
|
1天前
|
机器学习/深度学习 数据采集 算法
基于GA遗传优化的CNN-GRU-SAM网络时间序列回归预测算法matlab仿真
本项目基于MATLAB2022a实现时间序列预测,采用CNN-GRU-SAM网络结构。卷积层提取局部特征,GRU层处理长期依赖,自注意力机制捕捉全局特征。完整代码含中文注释和操作视频,运行效果无水印展示。算法通过数据归一化、种群初始化、适应度计算、个体更新等步骤优化网络参数,最终输出预测结果。适用于金融市场、气象预报等领域。
基于GA遗传优化的CNN-GRU-SAM网络时间序列回归预测算法matlab仿真
|
1天前
|
算法
基于龙格库塔算法的锅炉单相受热管建模与matlab数值仿真
本设计基于龙格库塔算法对锅炉单相受热管进行建模与MATLAB数值仿真,简化为喷水减温器和末级过热器组合,考虑均匀传热及静态烟气处理。使用MATLAB2022A版本运行,展示自编与内置四阶龙格库塔法的精度对比及误差分析。模型涉及热传递和流体动力学原理,适用于优化锅炉效率。

热门文章

最新文章