栈-实现综合计算器（中缀表达式）

最新推荐文章于 2024-07-02 20:37:27 发布
最新推荐文章于 2024-07-02 20:37:27 发布
阅读量86 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 stack 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46558851/article/details/112461754
版权

综合计算器怎么搞？

思路

在这里插入图片描述

Demo1

package datastructres.stack;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/11 9:41
 * @description：
 */
public class Calculator {
    public static void main(String[] args) {
        String expression = "3+2*6-2";
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;    
        char ch = ' ';
        while (true){
            ch = expression.substring(index,index+1).charAt(0);
            //首先判断ch是什么，然后进行操作
            if (operStack.isOper(ch)){
                if (!operStack.isEmpty()){
                    //如果该元素优先级小于等于栈顶的优先级
                    if (operStack.priority(ch)<=operStack.priority(operStack.peek())){
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = operStack.cal(num1, num2, oper);
                        numStack.push(res);
                        operStack.push(ch);
                    }else {
                        //入栈
                        operStack.push(ch);
                    }
                }else {
                    //如果为空，直接入栈
                    operStack.push(ch);
                }
            }else{
                //因为numStack里面存放的是int类型的，这里存放值的时候需要对照ASCII码表进行对照
                //但是int类型可以与char类型直接进行比较
                numStack.push(ch-48);
            }
            index++;
            if (index>=expression.length()){
                break;
            }
        }
        //现在扫描已经结束，需要继续处理完两个栈中的元素
        while (true){
            if (operStack.isEmpty()){
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = operStack.cal(num1, num2, oper);
            numStack.push(res);
        }
        //最后存放在numStack里面的元素就是结果了
        System.out.printf("表达式%s = %d",expression,numStack.pop());
    }
}

class ArrayStack2 {
    private int maxSize;
    private int[] stack;
    private int top = -1;

    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    public boolean isFull() {
        return top == maxSize - 1;
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满，无法添加~");
            return;
        }
        top++;
        stack[top] = value;
    }

    public int peek(){
        return stack[top];
    }

    public int pop() {
        if (isEmpty()) {
            //throw相当于已经停止了代码，所以不用return
            //当存在返回值的时候(不为void)的时候，我们尽量可以抛出一个异常来代替return
            throw new RuntimeException("栈空，无法取出数据~");
        }
        int value = stack[top];
        top--;
        return value;
    }

    public void showStack() {
        if (isEmpty()) {
            System.out.println("栈已空~");
            return;
        }
        //循环的时候是从栈顶往下循环，也就是从数组的最后开始循环的~
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    public int cal(int num1, int num2, int oper) {
        int res = 0;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}

这里存在的问题就是只能进行一位数运算，无法计算大于10的数，而且只有加减乘除四个运算符~

下面是优化之后的代码，具体也就改了一个地方，有很多注释的地方，大家看看吧

Demo2

package datastructres.stack;

/**
 * @author ：Yan Guang
 * @date ：Created in 2021/1/11 9:41
 * @description：
 */
public class Calculator {
    public static void main(String[] args) {
        String expression = "70+2*6-4";
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';
        String keepNum="";
        while (true){
            ch = expression.substring(index,index+1).charAt(0);
            //首先判断ch是什么，然后进行操作
            if (operStack.isOper(ch)){
                if (!operStack.isEmpty()){
                    //如果该元素优先级小于等于栈顶的优先级
                    if (operStack.priority(ch)<=operStack.priority(operStack.peek())){
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = operStack.cal(num1, num2, oper);
                        numStack.push(res);
                        operStack.push(ch);
                    }else {
                        //入栈
                        operStack.push(ch);
                    }
                }else {
                    //如果为空，直接入栈
                    operStack.push(ch);
                }
            }else{
                //因为numStack里面存放的是int类型的，这里存放值的时候需要对照ASCII码表进行对照
                //但是int类型可以与char类型直接进行比较
                //1.
                //1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                //2.在处理数，需要向expression的表达式的index后再看-位，如果是数就进行扫描，如果是符号才入栈
                //3.因此我们需要定义一个变量字符串，用于拼接
                // numStack.push(ch-48);
                keepNum+=ch;
                //如果当此时的数为最后一个数字数，就直接入栈
                if (index==expression.length()-1){
                    numStack.push(Integer.parseInt(keepNum));
                }else {
                    //这里会存在一个越界问题，如果index到了最后一个，就没有index+1了
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {//判断是否是运算符
                        numStack.push(Integer.parseInt(keepNum));
                        keepNum = "";
                    }
                }
            }
            index++;
            if (index>=expression.length()){
                break;
            }
        }
        //现在扫描已经结束，需要继续处理完两个栈中的元素
        while (true){
            if (operStack.isEmpty()){
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = operStack.cal(num1, num2, oper);
            numStack.push(res);
        }
        //最后存放在numStack里面的元素就是结果了
        System.out.printf("表达式%s = %d",expression,numStack.pop());
    }
}

class ArrayStack2 {
    private int maxSize;
    private int[] stack;
    private int top = -1;

    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    public boolean isFull() {
        return top == maxSize - 1;
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满，无法添加~");
            return;
        }
        top++;
        stack[top] = value;
    }

    public int peek(){
        return stack[top];
    }

    public int pop() {
        if (isEmpty()) {
            //throw相当于已经停止了代码，所以不用return
            //当存在返回值的时候(不为void)的时候，我们尽量可以抛出一个异常来代替return
            throw new RuntimeException("栈空，无法取出数据~");
        }
        int value = stack[top];
        top--;
        return value;
    }

    public void showStack() {
        if (isEmpty()) {
            System.out.println("栈已空~");
            return;
        }
        //循环的时候是从栈顶往下循环，也就是从数组的最后开始循环的~
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;
        }
    }

    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    public int cal(int num1, int num2, int oper) {
        int res = 0;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}

欢迎大家在评论区讨论哟~

知道越多，知道越少
关注
专栏目录
【数据结构与算法】栈实现综合计算器（中缀表达式）
刘亚男
05-03 443
什么是栈？ 栈(stack)是一种线性结构 栈是一个先入后出的有序列表 展示限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许删除和插入的一端，为变化的一端，称为栈顶，另一端为固定的一端，称为栈底。 什么时候用栈？ 子程序的调用：在跳往子程序前，会先将下一个指令的地址存储到堆栈中，直到子程序执行完成后再将地址取出，以回到原来的程序中。 处理递归调用：和子程序的调用类似，...
栈-FILO、栈的基本介绍、数组模拟栈、栈实现综合计算器（中缀表达式）、前缀中缀后缀表达式、逆波兰计算器、中缀表达式转后缀表达式、完整版逆波兰计算器
qq_39497997的博客
11-20 4310
1 栈的基本介绍 1.1 stack性质 栈是一个先入后出（FILO）的有序列表 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 允许插入和删除的一端， 为变化的一端， 称为栈顶(Top)， 另一端为固定的一端， 称为栈底(Bottom)。 根据栈的定义可知， 最先放入栈中元素在栈底， 最后放入的元素在栈顶， 而删除元素刚好相反， 最后放入的元素最先删除， 最先放入的元素最后删除 1.2 栈的应用场景 子程序的调用：在跳往子程序前， 会先将下个指令的地址存到
return和throw到底怎么搞？
weixin_46558851的博客
01-10 2387
当存在返回值的时候（不为void的时候），我们尽量可以抛出一个异常来代替return 如下： public int pop() { if (isEmpty()) { //throw相当于已经停止了代码，所以不用return //当存在返回值的时候(不为void)的时候，我们尽量可以抛出一个异常来代替return throw new RuntimeException("栈空，无法取出数据~"); }
throw 和return的区别，A函数里面执行B函数 B函数异常后 不再执行A函数
最新发布
weixin_45776545的博客
07-02 265
returnreturn：用于从函数中返回一个值，并终止该函数的执行。：仅在函数内有效。：在需要从函数中返回一个值或提前退出函数时使用。：用于抛出一个异常，终止当前代码的执行，并将控制权交给最近的异常处理器（通常是语句）。：可以在任何地方使用，不局限于函数内部；会传播到调用堆栈的上层，直到找到一个catch块来处理它。：在遇到错误或异常情况时使用，需要停止执行并通知调用者有错误发生。
JavaScript中 throw和return有什么区别？
m0_57236802的博客
04-17 908
在 JavaScript 中都可以用于从函数中返回值，但它们的用途和行为有所不同。语句时，程序会立即停止当前执行路径，并尝试查找适当的错误处理程序（如。用于表示错误或异常情况，改变程序的控制流，并需要使用错误处理程序（如。语句会改变程序的控制流，使程序跳转到离它最近的错误处理程序（如。如果没有找到合适的错误处理程序，程序会终止执行。语句仅用于从函数中返回一个值，不会改变程序的控制流。语句只是简单地返回函数的结果，不涉及错误处理。语句用于从函数中返回一个值。用于简单地返回函数的结果，不涉及错误处理。
es6 next()、throw()、return() 的共同点
歪脖先生的博客
01-29 2536
next()、throw()、return() 的共同点 next()方法、throw()方法、return()方法这三个方法本质上是同一件事，可以放在一起理解。它们的作用都是让 Generator函数恢复执行，并且使用不同的语句替换yield表达式。 next()方法是将yield表达式替换成一个值。 const g = function* (x, y) { let resu
java throw return_java异常处理-finally中使用return和throw语句
weixin_32192681的博客
02-24 610
java异常语句中的finally块通常用来做资源释放操作，如关闭文件、关闭网络连接、关闭数据库连接等。正常情况下finally语句中不应该使用return语句也不应该抛出异常，以下讨论仅限于java语言设计本身，正常编码时应避免。finally块中使用return会覆盖method的返回值以下代码的返回值为：1public static intdiv(){try{return 3;}catch(...
java栈实现计算器中缀表达式
10-23
java数字栈和符号栈模拟计算器(中缀表达式) “计算中缀表达式”可以称得上是一个特别经典的关于栈的算法题，几乎在所有数据结构教材中都会涉及，而且很多公司面试或者笔试的时候都会把这道题作为一个考察点。可以说...
【数据结构】java栈实现简单计算器（中缀表达式）
DempseyLee的博客
03-14 1238
使用栈完成计算一个表达式的结果：将中缀表达式转换成后缀表达式 1.通过索引遍历表达式 2.建立两个栈： 数栈和符号栈 3.扫描到数字直接入栈（运算数相对顺序不变） 4. 扫描到运算符: 符号栈为空，则压栈 符号栈不为空，扫描到的符号与符号栈栈顶元素进行比较，如果当前符号优先级大于栈中符号，则压栈 小于栈顶符号优先级，则从数栈中pop两个数，符号栈中pop一个符号进行计算，计算结果入数栈，扫描到当前符号继续比较，如果大于则入栈 ...
数据结构与算法--Python栈 栈实现综合计算器和逆波兰计算器 前缀表达式 中缀表达式 后缀表达式 逆波兰表达式
storyfull
12-19 1082
Python栈 栈实现综合计算器和逆波兰计算器
java抛出异常后面的代码是否能执行？
骑士逸
12-01 1万+
今天在项目中遇到了一个问题，就是在java中抛出异常后，后面的代码是否能继续执？ 然后就写了几个Test案例测试了一下： 1.Test1 Test1的结果： 由Test1的结果可以知道：throw new RuntimeException("发生异常1")语句后面的代码都没有执行（包括return语句）； 2.Test2 Test2 的结果： 由T
第八章：自定义异常返回
胡汉三
06-01 932
在程序运行的过程中，没有人能保证我们可以百分之百的没有BUG、没有异常。在程序爆出异常的时候，我们往往需要拦截一下，进行特殊的友好提示处理。 那么这里我们将针对Spring Mvc跟Spring Security的异常做一些拦截。 @RestControllerAdvice 我们使用Spring mvc后，只需要在类上加上@RestControllerAdvice注解，就能够将程序大部分返回到客户端的异常进行处理 import com.hzw.code.common.utils.ActionExc
java 中 return 与 throw 异常的区别
taiguolaotu的博客
09-02 5314
先说throw，作用会一层一层往上抛出 最终抛向虚拟机 public class TestException { public static void main(String[] args){ System.out.println("main 1"); ma(2); System.out.println("main 2"); } static void ma(int i ){ System.out.println
实现js中的forEach方法中：中途跳出循环和throw new Error()
m0_62823653的博客
06-03 1829
方法一：使用return可以结束本次循环，但不是跳出循环（失败） 方法二：forEach跳出循环；方法： try catch （成功跳出forEach跳循环） 此案例容易出错点 终止for循环可以使用break,continue。在forEach中使用会报错;因为forEach是一个函数当Error像一个函数一样被使用时，也就是没有new，它将返回一个Error对象。因此，仅仅调用Error将产生与通过new关键字构造一个Error对象相同的输出。 通过Error的构造器可以创建一个错误对象。
Promise的Catch报错总结
大猪的博客
08-15 1594
先定义一个PromiseTest.html文件：}, 1000)}).then((res)=> { // 成功console.log("成功1"+res);//当我们需要在传参给后面的then时，可以使用return来返回值},(err) => { // 失败console.log("失败1"+err)throw new Error('抛出一个错1') //throw和return一样会返回后面的值，所以当我们需要在传参给后面的catch时，可以使用throw来返回值}...
java try catch 异常后还会继续执行吗
热门推荐
皮卡丘的博客
11-11 3万+
java try catch 异常后还会继续执行吗 catch 中如果你没有再抛出异常 , 那么catch之后的代码是可以继续执行的 , 1.但是try中 , 报错的那一行代码之后 一直到try结束为止的这一段代码 , 是不会再执行的。 //代码1 public static void test() throws Exception { try { throw n...
throw 和throws碰到runtimeException
墨尔本,晴
09-02 1393
1.throws 用于抛出方法层次的异常， 并且直接由些方法调用异常处理类来处理该异常， 所以它常用在方法的后面。比如 public static void main(String[] args) throws SQLException 2.throw 用于方法块里面的代码，比throws的层次要低，比如try...catch ....语句块，表示它抛出异常， 但它不会处理...
try-catch-finally中throw，return时的执行顺序
csdn_duanjiao2016的博客
11-13 2233
在我们使用try-catch-finally来捕获处理异常的时候，我们可能会存在一些疑惑，比如，什么时候执行catch中的程序模块，什么时候执行finally找那个的模块？ 首先，要肯定的时，catch的程序模块只会在当前的try中的代码出现异常的时，被catch所捕获后，此时就会执行catch中的代码块。而finally却是无论try模块是否出现了异常的情况下，都会执行的。
JAVA异常体系---不要在FINALLY块中使用RETURN、THROW
chengsen1的博客
03-10 1798
在finally块中使用return、throw，会导致编译告警：finally block does not complete normally。 情况一：finally块中没retrun、throw public static void method_1() { try { System.out.println("try block run"); throw new Exception("...
c语言用栈实现计算器（中缀表达式）
05-25
栈是实现计算器的核心数据结构，可以用来存储运算符和操作数。下面是使用栈实现中缀表达式计算器的C语言代码： ```c #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <ctype.h> #define MAX_SIZE 50 typedef struct { int top; int data[MAX_SIZE]; } Stack; void push(Stack *s, int value) { if (s->top == MAX_SIZE - 1) { printf("Stack Overflow\n"); return; } s->data[++(s->top)] = value; } int pop(Stack *s) { if (s->top == -1) { printf("Stack Underflow\n"); exit(1); } return s->data[(s->top)--]; } bool is_operator(char ch) { return ch == '+' || ch == '-' || ch == '*' || ch == '/'; } int get_priority(char op) { switch (op) { case '(': return 0; case '+': case '-': return 1; case '*': case '/': return 2; default: return -1; } } int calculate(int op1, int op2, char operator) { switch (operator) { case '+': return op1 + op2; case '-': return op1 - op2; case '*': return op1 * op2; case '/': return op1 / op2; default: return -1; } } int evaluate_expression(char *expression) { Stack operand_stack; Stack operator_stack; operand_stack.top = -1; operator_stack.top = -1; int i = 0; while (expression[i] != '\0') { if (isdigit(expression[i])) { int operand = 0; while (isdigit(expression[i])) { operand = operand * 10 + (expression[i] - '0'); i++; } push(&operand_stack, operand); } else if (is_operator(expression[i])) { while (operator_stack.top >= 0 && get_priority(expression[i]) <= get_priority(operator_stack.data[operator_stack.top])) { int op2 = pop(&operand_stack); int op1 = pop(&operand_stack); char op = pop(&operator_stack); int result = calculate(op1, op2, op); push(&operand_stack, result); } push(&operator_stack, expression[i]); i++; } else if (expression[i] == '(') { push(&operator_stack, expression[i]); i++; } else if (expression[i] == ')') { while (operator_stack.data[operator_stack.top] != '(') { int op2 = pop(&operand_stack); int op1 = pop(&operand_stack); char op = pop(&operator_stack); int result = calculate(op1, op2, op); push(&operand_stack, result); } pop(&operator_stack); i++; } else { i++; } } while (operator_stack.top >= 0) { int op2 = pop(&operand_stack); int op1 = pop(&operand_stack); char op = pop(&operator_stack); int result = calculate(op1, op2, op); push(&operand_stack, result); } return pop(&operand_stack); } int main() { char str[MAX_SIZE]; printf("Enter expression: "); scanf("%s", str); int result = evaluate_expression(str); printf("Result: %d\n", result); return 0; } ``` 这个程序支持加、减、乘、除和括号，可以计算包括负数在内的表达式。你可以在控制台中输入一个表达式，程序会输出计算结果。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值