咸鱼学数据结构和算法——中缀表达式计算机求值

目录

一、中缀表达式计算机求值算法介绍

二、中缀表达式计算机求值代码实现

---

一、中缀表达式计算机求值算法介绍

1. 通过一个 index  值（索引），来遍历我们的表达式

2. 如果我们发现是一个数字, 就直接入数栈

3. 如果发现扫描到是一个符号,  就分如下情况

3.1 如果发现当前的符号栈为 空，就直接入栈

3.2 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数,在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈， 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.

4. 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.

5. 最后在数栈只有一个数字，就是表达式的结果

二、中缀表达式计算机求值代码实现

public class Calculator {
    public static void main(String[] args){
//      计算表达式
        String experssion ="56-8*7-2";
//      字符串的索引
        int index=0;
//      截取的字符
        char ch;
//      用于拼接数字
        String joint;
//      用于储存数字
        ArrayStack numStack = new ArrayStack(10);
//      用于储存操作符
        ArrayStack operStack = new ArrayStack(10);
        int num1;
        int num2;
        char oper;
        int res;
//  读取计算表达式
        while (true){
            ch=experssion.substring(index,index+1).charAt(0);
//            System.out.println(ch);
//          取出的是运算符
            if(operStack.isOper(ch)){
//              如果运算符栈为空栈，直接将运算符存入
                if (operStack.isEmpty()){
                    operStack.push(ch);
                }
//              当取出的运算符的优先级小于等于运算符栈中运算符的优先级
                else if(operStack.Priority(ch)<=operStack.Priority((char)operStack.getStackTop())){
//              当有优先级小的运算符入栈时，要将优先级大的运算符先运算完
                    num1=numStack.pop();
                    num2=numStack.pop();
                    oper=(char)operStack.pop();
                    res=numStack.Calculate(num1,num2,oper);
//              将运算结果入栈
                    numStack.push(res);
//              将优先级小的运算符入栈
                    operStack.push(ch);

                }else {
//              当取出的运算符的优先级大于运算符栈中运算符的优先级
//                  直接将运算符入运算符栈
                    operStack.push(ch);
                }

            }else {
//          取出的是数字
                joint=String.valueOf(ch);
//                System.out.println("测试1:"+joint);
//              判断是否在索引范围内
                while (index<experssion.length()-1){
//                  读取下一个索引
                    ch=experssion.substring(index+1,index+2).charAt(0);
    //              如果是运算符，直接退出循环
                    if(numStack.isOper(ch)){
                        break;
                    }else {
//                      System.out.println("测试2:"+ch);
    //                  如果是数字，将数字拼接到一起
                        joint=joint+ch;
//                      将索引值加一
                        index++;
                    }
                }
//                System.out.println("测试3:"+joint);
//              将取出的数字加入栈中
                numStack.push(new Integer(joint));
                joint="";
            }
            index++;
            if(index>=experssion.length()){
                break;
            }
        }
        System.out.println("——————----————运算符栈————————————————");
        operStack.showStack();
        System.out.println("—----—----——————数栈———————------—————");
        numStack.showStack();
        while (!operStack.isEmpty()){
            num1=numStack.pop();
            num2=numStack.pop();
            oper=(char)operStack.pop();
            res=numStack.Calculate(num1,num2,oper);
            numStack.push(res);
        }
        System.out.println("表达式的结果为："+numStack.pop());

    }
}