数据结构与算法——Java实现栈、逆波兰计算器（整数加减乘除）

最新推荐文章于 2024-04-24 12:46:56 发布

我爱布朗熊

最新推荐文章于 2024-04-24 12:46:56 发布

阅读量1.5k

点赞数 1

分类专栏： Java数据结构与算法文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_51351637/article/details/128312292

版权

Java数据结构与算法专栏收录该内容

11 篇文章 0 订阅

订阅专栏

三、栈的前缀（波兰）、中缀、后缀（逆波兰）表达式

一、栈

1.1 基本介绍

我们平时使用的计算器，其底层就是利用了栈这个概念对这个算式进行理解

栈的英文为(stack)

栈是一个先入后出(FILO-First In Last Out)的有序列表

(stack)是限制表素的插入和除只能在性的同一端进行的一种性表。允许插入和删除的

端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)

根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

图解方式说明出栈(pop)和入栈(push)的概念

应用场景

子程序的调用:在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以可到原来的程序中。
处理递归调用:和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。又树的遍历
图形的深度优先(depth 一 first)搜索法

1.2 栈的思路分析

我们使用数组模拟栈的使用，由于栈是一种有序列表，那必然可以使用数组的结构来存储栈的数据内容。

1.3 栈的代码实现



// 定义一个ArrayStack  表示栈
class ArrayStack{
    private int maxSize;  //栈的大小
    private int[] stack;  //数组，用数组模拟栈，数据放在数组中
    private int top = -1; //栈顶，初始化为-1

//  栈满
    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 pop(){
//        看看是不是空
        if(isEmpty()){
            throw  new RuntimeException("空了，没有数据");
        }
//       有数据   先运行  再--
        int value = stack[top];
        top--;
        return  value;

    }

//   遍历栈  从上往下遍历  只是展示并不出栈
    public void  list(){
        if (isEmpty()){
            System.out.println("栈空，没有数据");
        }

        for (int i =top; i>=0;i--){
            System.out.println(stack[i]);
        }
    }





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

二、栈实现综合计算器

2.1 思路分析

如果这个图看不明白我们直接分析一下就可以了。

我们分析一个3+2*6-2这个算式

① 首先创建一个数栈一个符号栈

② 我们使用index扫描我们的算式。当扫描到“3时”，“3”入栈的时候很显然是进入数栈，此时数栈中的指针指向“3”。

③ 然后index扫描到“+”号，入符号栈，因为前面没有符号可以比对，所以直接入栈，此时符号栈中的指针指向“+”

④ index扫描到“2”，入数栈，指针并且指向“2”

⑤ index扫描到“*”符号，由于“*”符号的运算级比我们栈中存在的“+”运算级要大，所以“*”直接入栈，并且指针指向“*”

⑥ index扫描到“6”，入数栈，指针指向“6”

⑦ index扫描到“-”，然后这个地方很重要，由于“-”的运算级小于或者等于栈中的操作符（“*”），所以此时要从数栈中pop出两个数据（此时指针指向第二个pop出来的底下的一个位置），然后再从符号栈中pop出一个数据（此时指针移动到符号栈pop位置的底下的位置），进行运算。

但是！！！我们从数栈中pop出来的两个数的先后顺序会影响我们的结果，所以应该是pop2*pop1。让此时的操作结果入数栈（此时指针移动到此结果处）。我们刚刚扫描到的“-”入符号栈（此时指针移动到此符号处）

运算完成下图

⑧ index扫描到“2”，直接入数栈

⑨ 此时我们也扫描完毕了，我们按顺序从数栈和符号栈pop出相应的数和符号，并运行

数栈弹出两个，符号栈弹出一个。但是注意，符号栈弹出的两个数一定是有先后顺序的。

对于此题，当数栈弹出“2”，“12”时，指针应该是指向“3”，等“10”结果入栈后，再指向“10”

pop2(12)-pop1(2)=10 这样计算才对，此时10应该再入栈

当下面两个弹出的时候，数栈中没有东西了，然后计算出结果后，结果入栈，此时数据栈中只有一个元素，便是结果，并且符号栈中没有元素，全部弹出了

pop2(3)+pop1(10)=13

⑩ 最后数栈只有一个数字，便是表达式的结果

2.2 代码实现（中缀表达式实现）

public class Calculator {
    public static void main(String[] args) {
//     完成表达式运算
        String expression ="70-3-3";
//     创建两个栈，数栈和
        ArrayStack numStack = new ArrayStack(10);
        ArrayStack operStack = new ArrayStack(10);

//     定义扫描的相关变量  index
        int index=0;
        int num1=0;
        int num2=0;
        int oper=0;
        int res=0;
        char  ch=' '; //每次扫描得到的char保存到ch中
       String keepNum =""; //拼接多位数用的


//      开始循环扫描
        while (true){
//          依次得到expression的每一个字符
//          截取字符串
            ch = expression.substring(index,index+1).charAt(0);

//          判断是不是符号，如果是符号的话进入符号栈
            if(operStack.isOper(ch)){
//               如果是运算符的话进入到这里
                if(!operStack.isEmpty()){
//               如果符号栈不是空的话，就进行比较，如果当前的操作符的优先级小于或者等于栈中的优先级
//               就进行从数栈中pop两个，从符号栈pop一个运算，将算处的结果入栈，然后此时index指向的符号入栈
                 if(operStack.priority(ch) <= operStack.priority(operStack.peek())){
//                   看看谁的优先级高，运行到这里说明我们的ch优先级小于等于符号栈顶部元素的优先级
//                   从数栈中pop两个，从符号栈pop一个运算，将算处的结果入栈
                     num1 = numStack.pop();
                     num2 = numStack.pop();
                     oper = operStack.pop();
                     res = numStack.cal(num1,num2,oper);
//                   运算结果入栈
                     numStack.push(res);
//                   当前index指向的符号入栈
                     operStack.push(ch);
                 }else {
//                    这种情况就是ch的运算符比,直接入栈
                     operStack.push(ch);
                 }
                }else {
//                  如果符号栈是空的话，直接放入符号栈
                    operStack.push(ch);
                }
            }else {
//              这种情况是ch是数字，直接放入符号栈
//                numStack.push(ch); 这样写是错的 我们扫描的到数字其实不是数字，是字符，比如‘3’
//                  numStack.push(ch-48);  这样写只能算十以内的加减法

//                改进：我们不能发现一个数就入栈，因为可能会有多位数
//                处理多位数
                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
                        keepNum = "";
                    }
                }



            }
//          index指针移动
            index++;
//           index是从0开始的
            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("结果："+numStack.pop());
        numStack.list();
        operStack.list();
    }
}


// 先创建一个栈

// 定义一个ArrayStack  表示栈
class ArrayStack {
    private int maxSize;  //栈的大小
    private int[] stack;  //数组，用数组模拟栈，数据放在数组中
    private int top = -1; //栈顶，初始化为-1

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

//  看栈顶元素,但不取出
    public int peek(){
        return  stack[top];
    }

    //  栈满
    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 pop() {
//        看看是不是空
        if (isEmpty()) {
            throw new RuntimeException("空了，没有数据");
        }
//       有数据   先运行  再--
        int value = stack[top];
        top--;
        return value;

    }

    //   遍历栈  从上往下遍历  只是展示并不出栈
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
        }

        for (int i = top; i >= 0; i--) {
            System.out.println(stack[i]);
        }
    }


    //返回运算符的优先级，此优先级由程序员来确定：我们在此规定，数字越大，优先级越高
//  char和int可以混用
    public int priority(int oper){
//      假定表达式中只有下面四种符号
        if(oper =='*' || oper == '/'){
            return 1;
        }else if(oper =='+' || oper =='-'){
            return 0;
        }else {
            return -1;
        }
    }

//  判断是不是一个运算符
    public boolean isOper(char var){
        return var=='+' || var =='-' ||var=='*' || var=='/';
    }

//  运算方法
    public int cal(int num1,int num2 , int oper){
        int res = 0;  //res  用于存放计算的结果
        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;
    }

}

三、栈的前缀（波兰）、中缀、后缀（逆波兰）表达式

3.1 表达式的介绍

首先说明：不论是哪个表达式，一定要分清出栈的时候是pop1-pop2还是pop2-pop1

前缀表达式是pop1-pop2

后缀表达式是pop2-pop1 分清减数和被减数在我们上面的二位数加减乘除代码中，也是pop2-pop1

描述

前缀表达式：波兰表达式，前缀表达式的运算符位于操作数之前

例如：（3+4）×5-6对应的前缀表达式就是 -×+3 4 5 6

中缀表达式：常见的运算表达式。我们小学学的就是中缀表达式

中缀表达式是我们最为熟悉的，但是对于计算机来说却很难操作，因此我们在计算结果的时候，往往会将中缀表达式转换成其他表达式来计算（一般转换成后缀表达式）

后缀表达式：逆波兰表达式，与前缀表达式相似，知识运算符位于操作数之后