

// 定义一个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

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

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

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

3.2 逆波兰计算器（后缀表达计算器）

要求：支持小括号和多位整数，为了方便我们直接使用系统给我们的栈Stack

3.2.1 思路分析

我们刚刚看到的那个图就是我们的计算机求值思路

3.2.2 代码实现

public class PolandNotation {
    public static void main(String[] args) {
//      先定义一个逆波兰表达式，为了方便数字和符号都是用空格间隔开
//      (3+4)*5-6  后缀表达式就是下面
        String suffixExpression ="3 4 + 5 × 6 -";

//      思路：
//          1.先将"3 4 + 5 × 6 -"放到ArrayList中
//          2.将ArrayList传递给一个方法，遍历ArrayList配合栈完成计算
        List<String> rpnList = getListString(suffixExpression);
        System.out.println(calculate(rpnList));




    }
//    将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
    public static List<String> getListString (String suffixExpression){
//      分割
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
//      用这个api更快
        Collections.addAll(list, split);

        return 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 num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res=0;
                if(item.equals("+")){
                    res = num1 + num2;
                }else if(item.equals("-")){
                    res =num2-num1;
                }else if(item.equals("×")){
                    res =num1*num2;
                }else if(item.equals("/")){
                    res = num2/num1;
                }else {
                    throw new  RuntimeException("运算符有误");
                }
//              结果入栈
                stack.push(res+"");
            }
        }
//        最后留在stack中的数据是运算结果
        return Integer.parseInt(stack.pop());
        
    }

}

3.3 中缀表达式转后缀表达式

3.3.1 思路分析

小括号不是运算符，只是一个改变我们运算顺序的符号

3.3.2 代码实现

public class PolandNotation {
    public static void main(String[] args) {
//       完成一个中缀表达式转成后缀表达式的功能
//      1+((2+3))×4-5  -----> 1 2 3 + 4 × + 5 -
//      我们对字符串操作不方便，将中缀表达式放入List集合找那个
        String expression = "1+((2+3))×4-5";
//       转换成对应的list
        List<String>  InfixExpressionList  =toInfixExpressionList(expression);
        System.out.println("中缀表达式的List="+InfixExpressionList);
//      转换成后缀表达式的List
        List<String> suffixExpressionList  = parseSuffixExpressionList(InfixExpressionList);
        System.out.println("后缀表达式的List"+suffixExpressionList);
        System.out.println("结果:"+ calculate(suffixExpressionList));



    }
//  将中缀表达式转成对应的List
    public static  List<String> toInfixExpressionList(String s){
//       定义List存放中缀表达式对应内容
        List<String> ls = new ArrayList<>();
        int i =0;
        String str;  //多位数拼接  因为计算的时候不可能光有一位数
        char c;      // 没遍历一个字符，就放入c中
        do{
            if( (c=s.charAt(i))<48 || (c=s.charAt(i))>57){
//             运行到这里肯定说明char不是0....9
               ls.add(""+c);
               i++;
            }else {
//              这种情况就是数字了，但是我们需要考虑度多位数
//              保证是空串
                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;

    }

//  中缀表达式转换成后缀表达式
    public static List<String>  parseSuffixExpressionList(List<String> ls){
//      定义两个栈
        Stack<String> s1 = new Stack<>();  //符号栈
//      说明：我们s2栈只进栈，只有最后的时候倒序输出，所以我们选择List集合就可以了，方便
        List<String> s2 =new ArrayList<>();//储存中间结果的栈

        for(String item:ls){
//           如果是一个数就进栈s2
            if(item.matches("\\d+")){
//              遇到操作数时，将其压s2；
                s2.add(item);
            }else if(item.equals("(")){
//              如果是左括号“(”，则直接压入s1
                s1.push(item);
            }else if(item.equals(")")){
//               如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，
//               直到遇到左括号为止，此时将这一对括号丢弃
                 while (!s1.peek().equals("(")){
                     s2.add(s1.pop());
                 }
//               将s1栈的左括号丢掉
                s1.pop();

            }else {

//               这种情况是匹配到字符的时候
//               优先级比栈顶运算符的高，也将运算符压入s1；
//               否则（运算符的优先级小于等于），将s1栈顶的运算符弹出并压入到s2中，再与s1中新的栈顶运算符相比较，如果遇到空栈或者（，直接进栈
                while (s1.size() !=0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)){
                    s2.add(s1.pop());
                }
//               出循环的话，item的运算符肯定比顶部的高或者栈空了
//               优先级比栈顶运算符的高，也将运算符压入s1；
                s1.push(item);
//                if(s1.peek()==null || Operation.getValue(item)>Operation.getValue(s1.peek())){
//                    s1.push(item);
//                }
            }
        }

//       将s1中剩余的运算符依次弹出并压入s2
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
//      因为是存放到列表里面，就不需要逆序输出了，现在已经是逆序表达式
        return s2;

    }


//    将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
    public static List<String> getListString (String suffixExpression){
//      分割
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
//      用这个api更快
        Collections.addAll(list, split);

        return 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 num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res=0;
                if(item.equals("+")){
                    res = num1 + num2;
                }else if(item.equals("-")){
                    res =num2-num1;
                }else if(item.equals("×")){
                    res =num1*num2;
                }else if(item.equals("/")){
                    res = num2/num1;
                }else {
                    throw new  RuntimeException("运算符有误");
                }
//              结果入栈
                stack.push(res+"");
            }
        }
//        最后留在stack中的数据是运算结果
        return Integer.parseInt(stack.pop());

    }

}



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){
        operation= operation.trim();

        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(operation);
                System.out.println("不存在该运算符");
                break;
        }
        return result;
    }

}