数据结构与算法——栈实现计算器

最新推荐文章于 2022-07-07 10:08:31 发布
最新推荐文章于 2022-07-07 10:08:31 发布
阅读量270 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 中缀表达式 后缀表达式 运算符优先级 栈 计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Envy___/article/details/118931192
版权

中缀表达式计算器

在这里插入图片描述

public class Calculator {

    @Test
    public void testCalculator() {

        String expression = "30+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 = ' ';  //将每次扫描得到的char保存到ch
        String keepNum = ""; //用于拼接多位数

        //while循环扫描expression
        while (true) {

            //依次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);

            //判断ch是什么
            if (operStack.isOper(ch)) {   //是运算符
                //判断符号栈是否为空
                if (!operStack.isEmpty()) {   //不为空
                    //比较优先级，若当前操作符优先级小于等于栈中操作符
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        //数栈pop两个数，符号栈pop一个符号，运算
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        //运算结果入数栈a
                        numStack.push(res);
                        //当前操作符入符号栈
                        operStack.push(ch);
                    } else {
                        //如果当前操作符的优先级大于栈中的操作符，就直接入符号栈
                        operStack.push(ch);
                    }
                } else { //符号栈为空
                    operStack.push(ch);
                }
            } else { //是数字
                //numStack.push(ch - '0');
                //处理多位数
                keepNum += ch;

                //如果ch是最后一位，直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else {

                    //判断下一个字符是不是数字，是数字继续扫描，是运算符则入栈
                    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 = numStack.cal(num1, num2, oper);
            numStack.push(res);
        }

        System.out.println("表达式" + expression + "的结果为：" + numStack.pop());

    }

}

//创建栈
class ArrayStack2 {

    private int maxSize;    //栈的大小
    private int[] stack;    //数组模拟栈，数据存放在该数组中
    private int top = -1;   //top表示栈顶，初始化为-1

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

    //查看栈顶的值
    public int peek() {
        return stack[top];
    }

    //判断栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈-push
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        stack[++top] = value;
    }

    //出栈-pop
    public int pop() {
        if (isEmpty())
            throw new RuntimeException("栈空，没有数据");
        return stack[top--];
    }

    //显示栈(遍历)，需要从栈顶开始显示数据
    public void list() {

        if (isEmpty()) {
            System.out.println("栈空");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }

    }

    /**
     * 返回运算符的优先级，数字越大，优先级越高
     *
     * @param oper 运算符
     * @return 优先级
     */
    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;
        }

        return res;

    }

}

逆波兰计算器

输入一个中缀表达式，转换为后缀表达式后进行运算。

中缀表达式转为相应的List形式

    public static List<String> toInfixExpressionList(String s) {

        //定义一个List存放中缀表达式的内容
        List<String> ls = new ArrayList<>();
        int i = 0;  //指针，用于遍历中缀表达式字符串
        String str; //用于拼接多位数
        char c;     //每遍历到一个字符就放入到c

        do {
            //如果c是非数字，就加入到ls中
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                i++;
            } else { //如果是数字，考虑多位数
                str = "";    //str置空
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;   //  拼接
                    i++;
                }
                ls.add(str);
            }

        } while (i < s.length());

        return ls;

    }

中缀表达式转换为后缀表达式

  • 中缀表达式转换为后缀表达式的步骤
  1. 初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；
  2. 从左至右扫描中缀表达式；
  3. 遇到操作数时，将其压 s2；
  4. 遇到运算符时，比较其与 s1 栈顶运算符的优先级：
    (1).如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
    (2).否则，若优先级比栈顶运算符的高，也将运算符压入 s1；
    (3).否则，将 s1 栈顶的运算符弹出并压入到 s2 中，再次转到4.1与 s1 中新的栈顶运算符相比较；
  5. 遇到括号时：
    (1) 如果是左括号“(”，则直接压入 s1
    (2) 如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃
  6. 重复步骤 2 至 5，直到表达式的最右边
  7. 将 s1 中剩余的运算符依次弹出并压入 s2
  8. 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
    在这里插入图片描述
    //中缀表达式的List转换为后缀表达式的List
    public static List<String> parseSuffixExpressionList(List<String> ls) {

        //定义两个栈
        Stack<String> s1 = new Stack<>();   //符号栈
        //s2无pop操作，用List即可
        List<String> s2 = new ArrayList<>();    //存储中间结果的List

        //遍历ls
        for (String item : ls) {

            //如果是数，加入s2
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                //如果是右括号，则一次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将括号丢弃
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();   //将(弹出
            } else {
                //当item的优先级小于等于s1栈顶的运算符的优先级，将s1栈顶的运算符弹出压入s2内，再次与s1新的栈顶运算符比较
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //item入栈
                s1.push(item);
            }

        }

        //s1中剩余的运算符依次弹出并加入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }

        return s2;  //因为是存放到List，因此按顺序输出就是对应后缀表达式的List

    }

运算后缀表达式

例如: (3+4)×5-6 对应的后缀表达式就是 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，由此得出最终结果
    //运算逆波兰表达式
    public static int calculate(List<String> ls) {

        //创建一个栈
        Stack<String> stack = new Stack<>();

        //遍历ls
        for (String item : ls) {

            //使用正则表达式取出数
            if (item.matches("\\d+")) {   //匹配多位数
                //入栈
                stack.push(item);
            } else {
                //pop出两个数并运算
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                switch (item) {
                    case "+":
                        res = num1 + num2;
                        break;
                    case "-":
                        res = num1 - num2;
                        break;
                    case "*":
                        res = num1 * num2;
                        break;
                    case "/":
                        res = num1 / num2;
                        break;
                }
                //res入栈
                stack.push("" + res);
            }

        }

        //最后留在栈里的是运算结果
        return Integer.parseInt(stack.pop());

    }

整体代码

package stack;

import org.junit.Test;

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

public class PolandNotation {

    @Test
    public void testPolandNotation() {

        //中缀表达式转后缀表达式 1+((2+3)*4)-5 转成 1 2 3 + 4 * + 5 -
        //1. 将中缀表达式转换为List [1,+,(,(,2,+,3,),*,4,),-,5]
        //2. 中缀表达式的List转换为后缀表达式的List[1,2,3,+,4,*,+,5,-]
        //3. 运算后缀表达式
        String expression = "1+((2+3)*4)-5";
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式的List = " + infixExpressionList);
        List<String> suffixExpressionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式的List = " + suffixExpressionList);

        System.out.println("expression = " + calculate(suffixExpressionList));


        //定义逆波兰表达式 (3+4)*5-6
//        String suffixExpression = "3 4 + 5 * 6 -";
//        List<String> list = getListString(suffixExpression);
//        System.out.println(calculate(list));

    }


    //将中缀表达式转为List的方法
    public static List<String> toInfixExpressionList(String s) {

        //定义一个List存放中缀表达式的内容
        List<String> ls = new ArrayList<>();
        int i = 0;  //指针，用于遍历中缀表达式字符串
        String str; //用于拼接多位数
        char c;     //每遍历到一个字符就放入到c

        do {
            //如果c是非数字，就加入到ls中
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                i++;
            } else { //如果是数字，考虑多位数
                str = "";    //str置空
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;   //  拼接
                    i++;
                }
                ls.add(str);
            }

        } while (i < s.length());

        return ls;

    }


    //中缀表达式的List转换为后缀表达式的List
    public static List<String> parseSuffixExpressionList(List<String> ls) {

        //定义两个栈
        Stack<String> s1 = new Stack<>();   //符号栈
        //s2无pop操作，用List即可
        List<String> s2 = new ArrayList<>();    //存储中间结果的List

        //遍历ls
        for (String item : ls) {

            //如果是数，加入s2
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                //如果是右括号，则一次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将括号丢弃
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();   //将(弹出
            } else {
                //当item的优先级小于等于s1栈顶的运算符的优先级，将s1栈顶的运算符弹出压入s2内，再次与s1新的栈顶运算符比较
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //item入栈
                s1.push(item);
            }

        }

        //s1中剩余的运算符依次弹出并加入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }

        return s2;  //因为是存放到List，因此按顺序输出就是对应后缀表达式的List

    }


    //运算逆波兰表达式
    public static int calculate(List<String> ls) {

        //创建一个栈
        Stack<String> stack = new Stack<>();

        //遍历ls
        for (String item : ls) {

            //使用正则表达式取出数
            if (item.matches("\\d+")) {   //匹配多位数
                //入栈
                stack.push(item);
            } else {
                //pop出两个数并运算
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                switch (item) {
                    case "+":
                        res = num1 + num2;
                        break;
                    case "-":
                        res = num1 - num2;
                        break;
                    case "*":
                        res = num1 * num2;
                        break;
                    case "/":
                        res = num1 / num2;
                        break;
                }
                //res入栈
                stack.push("" + res);
            }

        }

        //最后留在栈里的是运算结果
        return Integer.parseInt(stack.pop());

    }


      //将一个逆波兰表达式的数据和运算符放入ArrayList中
//    public static List<String> getListString(String suffixExpression) {
//        //分割suffixExpression
//        String[] split = suffixExpression.split(" ");
//        List<String> list = new ArrayList<>();
//        for (String ele : split) {
//            list.add(ele);
//        }
//        return list;
//        //return new ArrayList<>(Arrays.asList(split));
//    }

}


class Operation {

    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    //返回优先级数字的方法
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }
        return result;
    }

}
Envy___
关注
专栏目录
golang数据结构与算法——栈
qq_39280718的博客
08-18 469
栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底
【笔记】数据结构与算法——栈
Gu_jiaguaren的博客
08-14 490
栈（stack） 1、栈的介绍 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表 允许插入和删除的一端为变化的一端，称为栈顶（top）；另一端为固定的一端，称为栈底（bottom） 特点：先进后出 入栈（push）和出栈（pop）示意图 2、栈的应用场景 1）子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。 2）处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中
数据结构（堆栈计算器）
05-13
堆栈计算器报告学会利用栈结构，按照算术运算优先级顺序，实现基本算术表达式的运算过程。
数据结构--栈实现计算器
qq_45283185的博客
12-04 875
计算器前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 只计算 + - * / 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings
（数据结构与算法）使用栈来实现综合计算器
我真的很不错的博客
07-01 657
1.栈实现综合计算器（中缀表达式） 1.1流程图 1.2 代码实现 public class Calculator { public static void main(String[] args) { String expression = "700*2*2-5+1-5+3-4"; //创建数栈和运算符栈 ArrayStackCal numStack = new ArrayStackCal(10); ArrayStackCal ope
数据结构与算法--利用栈结构实现计算器
qq_39592858的博客
07-15 300
对于计算一个表达式1+2*3/4,该如何处理,如何处理不同的操作符的优先级 栈的特点和队列相反,先进后出. 可以把队列类比于一个两头通透的通道,一端进入另一端拿出. 而栈是一个一头封闭的通道,从一端压入一端拿出. 下面是基于数组的实现, import java.util.List; /** * @Project: StackCalculator * @Description: 一个简单的基于数组的栈实现 * @Creator: sunwei * @CreatDate: 2020/7/4 * @Mo
数据结构之栈 实现简单计算器
u012977486的博客
02-04 432
package com.example.demo1.dataStructure.stack; public class Calculator { public static void main(String[] args) { String expression = "7*2*2-5+1-5+3-4"; // 15如何处理多位数的问题？ //创建两个栈，数栈，一个符号栈 ArrayStack2 numStack = new Array...
数据结构基础之计算器的实现
WUST_cws的博客
10-15 2860
对于数据结构初学者来说，带有优先级的计算器的实现是一个很头疼的问题，即使目前教材上上已经讲解得很详细，但依然难以难以形象的理解并通过编程实现计算器的功能。作者通过实践，运用栈，对带有‘*’、‘/’运的表达式和带有’)’、’)’的表达式进行化归，实现了此功能。
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 【基本要求】 以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。...
数据结构课设——计算器
m0_56144302的博客
07-07 2293
在实验-03、实验-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符&&、||、！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，能进行异常处理。
c++ QT 数据结构 栈计算器
04-09
数据结构栈作业，基于顺序栈的计算器，使用C++编写逻辑，QT制作ui
数据结构栈计算器
09-16
数据结构包括报告 源代码 注释 应有尽有 课程设计必备良器
《数据结构》栈的应用——基本计算器
冰冻三尺非一日之寒
07-11 425
写在前面：考研复习到栈，栈的一个经典应用例题就是《基本计算器》，这个算法手写过程我很熟悉，但是代码实现不是很熟手，因此复习阶段有必要把这个算法总结一下。 题目描述，输入一个字符串，包含 数字0-9，(,),+,-,*,/ 以及一些空格，保证输入的数据是合理的，不会出现语义错误，不会出现0作为除数。 算法实现 ......
【数据结构与算法 6】栈实现综合计算器
学Java，找哪吒
05-18 3528
一、栈 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 二、栈的应用场景 1、子程序的调用 在调往子程序前，会先将下个指令的地址存放到堆栈中，直到子程序执行完后再将地址抛出，以回到原来的程序。 2、处理递归调用 和子程序的调用
【数据结构】栈实现综合计算器
dengmsjava的博客
05-14 543
1.通过一个index值（索引）,来遍历表达式； 2.如果发现是一个数字,就直接入数栈； 3.如果发现扫描到是一个符号,就分如下情况： ①如果发现当前的符号栈为空,就直接入栈； ②如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数,在从符号栈中pop出一个符号，进行运算，将得到结果入数栈，然后将当前的操作符入符号栈；如果当前的操作符的优先级大于栈中的操作符,就直接入符号栈。 4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运
数据结构——栈（计算器实现原理）
zjcoming
09-28 463
实现一个最简单的计算器，规定： 只有+、-、*、/，没有小括号 数字只能是0-9之间的数字，不能有两位数。
【数据结构与算法(Java)】计算器（中缀表达式实现）
hoyyoung的博客
03-03 293
1. 中缀计算器 public class InfixCalculator { /** * @author - hoy * 计算器：计算所给出数学表达式字符串的结果，返回结果值（只计算个位数的数字输入，无括号） * @param expression - 表达式字符串 * @return - 返回计算结果 */ public static int infixCalculator(String expression) { //
数据结构——栈实现简易计算器
kuniqiw的博客
01-15 571
遍历表达式过程中，         元素入符号栈的条件： 符号栈为空（即此元素是第一个符号）； 此符号优先级  &gt; 栈顶符号； 前一个符号为  '('  且此符号不是  ')' ;         先进行阶段性计算的条件： 表达式已经全部遍历结束（无论有没有计算结束）； 遍历到符号时，此符号的优先级 &lt;= 栈顶元素； 遍历到符号时，此符号为  ')'  且前一个符号不是 ...
北京理工大：数据结构实验二——计算器程序设计
本实验文档是北京理工大学自动化学院06111001班的一份数据结构及算法设计实验报告，由学生宝竞宇完成。实验的主要目的是让学生深入理解并掌握栈的原理和应用，特别是栈的建立、输入、删除和出栈等基本操作。通过实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值