栈的应用——中缀表达式

1.思路：

1. 分为两个栈：
   数栈：numStack：存放数据
   符号栈：operStack

2.通过一个索引来遍历：

1. 如果发现是数字，直接入数栈；
2. 如果发现是符号，分情况：

2.1 如果当前栈空，直接入栈；
2.2 如果不为空： 
      2.2.1 如果当前操作符优先级小于或等于栈中的操作符，则需要从数栈中pop出两个数，再从符号栈中pop出一个，再将计算结果入数栈，再将当前操作符入符号栈。 【注意运算顺序：后面弹出来的 操作符 前面弹出的】
      2.2.2 如果当前符号优先级大于栈中的，直接入栈。
      

3.当表达式扫描完毕，就顺序从数栈和符号栈中pop出相应的数字和符号，并运行。
4.数栈只会存有一个结果，即时计算的值。

2.问题需要：
方法：添加，取出，判断优先级高低，判断是否为操作符，计算方法，
如何扫描

3.代码：

package com;

import javafx.scene.chart.NumberAxis;

import java.sql.SQLOutput;
import java.time.chrono.IsoEra;
import java.util.Scanner;

public class StackDemo {
    public static void main(String[] args) {
        //表达式运算
        String expression="7-1*2";

        //创建两个栈，数栈，符号栈
        StackDemo numStack=new StackDemo(10);
        StackDemo operStack=new StackDemo(10);
        //定义相关变量
        int index=0;  //用于扫描
        int num1=0;
        int num2=0;
        int oper=0;
        int res=0;
        char ch=' ';
        String keepNum="";   //用于拼接 多位数使用

        //开始循环扫描
        while(true)
        {
            //依次的到每一个字符
            //subString方法查看API：从（a,b）,即从a开始扫描到b-1结束，
            // 扫描的字符数为b-a个
            ch=expression.substring(index,index+1).charAt(0);

            //判断获取到的ch属于什么类型
            if(operStack.isOper(ch)) {
                //判断是否为空
                //若不为空，进行比较
                if (!operStack.isEmpty()) {
                    if (operStack.priority(ch)<operStack.priority(numStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();

                        oper = operStack.pop();

                        res = numStack.cal(num1, num2, oper);

                        //把运算的结果入数栈
                        numStack.push(res);

                        operStack.push(ch);

                    } else {
                        operStack.push(ch);

                    }
                }else{
                        //如果为空，直接入栈
                        operStack.push(ch);
                    }
                }

            else{
                //如果是数，直接入栈
                //如何处理多位数：
                //向后看一位，如果不是才入栈
                //因此需要定义一个变量字符串，用于拼接
                keepNum+=ch;

                //如果ch已经是expression的最后一位，就直接入栈
                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;

        }

        //表达式扫描完毕，pop出相应的数字和符号进行运算
        while (true)
        {
            if(operStack.isEmpty())
            {
                break;
            }
            num1=numStack.pop();
            num2=numStack.pop();


            oper=operStack.pop();
            res=numStack.cal(num1,num2,oper);

            numStack.push(res);

        }

        //将最后的数取出，即是结果
        int res2=numStack.pop();
        System.out.printf("最后的运算结果为：%d",res2);


    }
    private int[] stack;
    private int maxSize;
    private int top=-1;  //栈顶

    //构造器初始化
    public StackDemo(int maxSize){
        this.maxSize=maxSize;
        stack=new int[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;

        }
        else{
            top++;
            stack[top]=value;
        }
    }
    //出栈
    public int pop(){
        if(isEmpty())
        {

            throw new RuntimeException("栈为空");
        }
        else{
            int value=stack[top];
            top--;
            return value;
        }
    }

    //显示当前数据
    public void show(){
        if(isEmpty())
        {
            return;
        }
        else{
            for(int i=top;i>=0;i--)
                System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }

    //返回栈顶元素的值
    public int peek(){
        return stack[top];
    }
    //判断是不是一个运算符
    public boolean isOper(char val){
        return val=='+'||val=='-'||val=='*'||val=='/';
    }

    //比较优先级——数字越大，优先级越高
    public int priority(int oper){
        if(oper=='*'||oper=='/')
            return 1;
        else if(oper=='+'||oper=='-')
            return 0;
        else
            return -1;
    }

    //计算方法


    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;


    }


}