栈的学习笔记

三，栈

1，问题引入

请输入一个表达式
计算式:722-5+1-5+3-3 点击计算【如下图】

问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算,因为我们看这个算式 7 * 2 * 2 - 5, 但是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，我们讨论的是这个问题。-> 栈

2，栈的介绍

• 栈的英文为(stack)
• 栈是一个先入后出(FILO-First In Last Out)的有序列表。
• 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
• 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
• 其实栈就等同于我们小时候玩的玩具手枪，第一个上进去的子弹最后一个打出去。这就是栈的原理，前进后出。

3，栈的应用场景

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

4，栈的快速入门

• 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来储存栈的数据内容，下面我们就用数组模拟栈的出栈，入栈等操作。

• 思维图如下：

  

• 代码实现：

  package com.zhao;
  
  import java.util.Scanner;
  
  /**
   * @version v1.0
   * @ProjectName: 数据结构
   * @ClassName: ArrayStackDemo
   * @Description: 栈的功能实现代码
   * @Author: 赵先生
   * @Date: 2021/12/6 17:23
   */
  
  public class ArrayStackDemo {
      public static void main(String[] args) {
          //测试一下ArrayStack 是否正确
          //先创建一个ArrayStack对象->表示栈
          ArrayStack stack = new ArrayStack(4);
          String key = "";
          //控制是否退出菜单
          boolean loop = true;
          Scanner scanner = new Scanner(System.in);
  
          while(loop) {
              System.out.println("show: 表示显示栈");
              System.out.println("exit: 退出程序");
              System.out.println("push: 表示添加数据到栈(入栈)");
              System.out.println("pop: 表示从栈取出数据(出栈)");
              System.out.println("请输入你的选择");
              key = scanner.next();
              switch (key) {
                  case "show":
                      stack.list();
                      break;
                  case "push":
                      System.out.println("请输入一个数");
                      int value = scanner.nextInt();
                      stack.push(value);
                      break;
                  case "pop":
                      try {
                          int res = stack.pop();
                          System.out.printf("出栈的数据是 %d\n", res);
                      } catch (Exception e) {
                          // TODO: handle exception
                          System.out.println(e.getMessage());
                      }
                      break;
                  case "exit":
                      scanner.close();
                      loop = false;
                      break;
                  default:
                      break;
              }
          }
  
          System.out.println("程序退出~~~");
      }
  }
  
  /**
   * 定义一个ArrayStack表示栈
   */
  class ArrayStack {
      /**
       * maxSize 栈的大小
       * stack 数组，数组模拟栈，数据就放在该数组
       * top top表示栈顶，初始化为-1
       */
      private int maxSize;
      private int[] stack;
      private int top = -1;
  
      //构造器
      public ArrayStack(int maxSize) {
          this.maxSize = maxSize;
          stack = new int[this.maxSize];
      }
  
      /**
       * 栈满
       * @return 判断栈是否满
       */
      public boolean isFull() {
          return top == maxSize - 1;
      }
  
      /**
       * 栈空
       */
      public boolean isEmpty() {
          return top == -1;
      }
  
      /**
       * 入栈-push
       * @param value 入栈的值
       */
      public void push(int value) {
          if (isFull()) {
              System.out.println("栈已经满了");
              return;
          }
          top++;
          stack[top] = value;
      }
  
      /**
       * 出栈-pop, 将栈顶的数据返回
       * @return 出栈的值
       */
      public int pop() {
          //判断栈是否为空
          if (isEmpty()) {
              //抛出异常
              throw new RuntimeException("栈空，没有数据~");
          }
          int value = stack[top];
          top--;
          return value;
      }
  
      /**
       * 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
       */
      public void list() {
          if (isEmpty()) {
              throw new RuntimeException("栈空，没有数据~");
          }
          for (int i = 0; i < top;i++) {
              System.out.printf("stack[%d]=%d\n", i, stack[i]);
          }
      }
  }
  

5，栈实现总和计算器（中缀表达式）

思路分析：

程序流图如下：

代码如下：

package com.zhao;

/**
 * @version v1.0
 * @ProjectName: 数据结构
 * @ClassName: Calculator
 * @Description: 请描述该类的功能
 * @Author: 赵先生
 * @Date: 2021/12/6 23:23
 */

public class Calculator {
    public static void main(String[] args) {
        //根据前面老师思路，完成表达式的运算
        String expression = "7*2*2-5+1-5+3-4";
        //创建两个栈，数栈，一个符号栈
        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) {
            //依次得到每个数字
            ch = expression.substring(index, index+1).charAt(0);
            //判断ch是什么，然后做相应的处理
            //如果当前是运算符
            if (operStack.isOper(ch)) {
                //判断当前的符号栈是否为空
                if (!operStack.isEmpty()) {
                    //如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
                    //在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                    if(operStack.priority(ch) <= operStack.priority(operStack.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 {
                //如果是数，则直接入数栈

                //numStack.push(ch - 48); //? "1+3" '1' => 1
                //分析思路
                //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                //2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
                //3. 因此我们需要定义一个变量 字符串，用于拼接

                //处理多位数
                keepNum += ch;

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

                    //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
                    //注意是看后一位，不是index++
                    if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) {
                        //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
                        numStack.push(Integer.parseInt(keepNum));
                        //重要的!!!!!!, keepNum清空
                        keepNum = "";

                    }
                }
            }
            //让index + 1, 并判断是否扫描到expression最后.
            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);//入栈
        }
        //将数栈的最后数，pop出，就是结果
        int res2 = numStack.pop();
        System.out.printf("表达式 %s = %d", expression, res2);
    }
}

/**
 * 先创建一个栈,直接使用前面创建好
 * 定义一个 ArrayStack2 表示栈, 需要扩展功能
 */
class ArrayStack2 {
    /**
     * maxSize 栈的大小
     * stack 数组，数组模拟栈，数据就放在该数组
     * top top表示栈顶，初始化为-1
     */
    private int maxSize;
    private int[] stack;
    private int top = -1;

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

    /**
     * 增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
     * @return
     */
    public int peek() {
        return stack[top];
    }

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

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

    /**
     * 入栈-push
     * @param value 入栈的值
     */
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈已经满了");
            return;
        }
        top++;
        stack[top] = value;
    }

    /**
     * 出栈-pop, 将栈顶的数据返回
     * @return 出栈的值
     */
    public int pop() {
        //判断栈是否为空
        if (isEmpty()) {
            //抛出异常
            throw new RuntimeException("栈空，没有数据~");
        }
        int value = stack[top];
        top--;
        return value;
    }

    /**
     * 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
     */
    public void list() {
        if (isEmpty()) {
            throw new RuntimeException("栈空，没有数据~");
        }
        for (int i = 0; i < top;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;
        }
    }

    /**
     * 判断是不是一个运算符
     * @param val 传入的值
     * @return boolean
     */
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }
    //计算方法
    public int cal(int num1, int num2, int oper) {
        // res 用于存放计算的结果
        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;
            default:
                break;
        }
        return res;
    }

}

6，逆波兰计算器

我们完成一个逆波兰计算器，要求完成如下任务:

• 输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果

• 支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。

• 思路分析

  

• 代码完成

  package com.zhao;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Stack;
  
  /**
   * @version v1.0
   * @ProjectName: 数据结构
   * @ClassName: PolandNotation
   * @Description: 请描述该类的功能
   * @Author: 赵先生
   * @Date: 2021/12/7 10:39
   */
  
  public class PolandNotation {
      public static void main(String[] args) {
  
          //完成将一个中缀表达式转成后缀表达式的功能
          //说明
          //1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
          //2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
          //   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
          //3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
          //   即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
          //注意表达式
          String expression = "1+((2+3)*4)-5"; 
          List<String> infixExpressionList = toInfixExpressionList(expression);
          // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
          System.out.println("中缀表达式对应的List=" + infixExpressionList); 
          List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
          //ArrayList [1,2,3,+,4,*,+,5,–] 
          System.out.println("后缀表达式对应的List" + suffixExpreesionList);
          // ?
          System.out.printf("expression=%d", calculate(suffixExpreesionList)); 
          
          
          //先定义给逆波兰表达式
          //(30+4)×5-6  => 30 4 + 5 × 6 - => 164
          // 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / + 
          //测试 
          //说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
          //String suffixExpression = "30 4 + 5 * 6 -";\
          String suffixExpression = "4 5 * 8 - 60 + 8 2 / +";
          //思路
          //1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
          //2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算
  
          List<String> list = getListString(suffixExpression);
          System.out.println("rpnList=" + list);
          int res = calculate(list);
          System.out.println("计算的结果是=" + res);
      }
  
      
  
      /**
       * 将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList中
       * @param suffixExpression 自定义的表达式
       * @return
       */
      private static List<String> getListString(String suffixExpression) {
          //将 suffixExpression 分割
          String[] split = suffixExpression.split(" ");
          List<String> list = new ArrayList<String>();
          for(String ele: split) {
              list.add(ele);
          }
          return list;
      }
  
  
     /**
       * 完成对逆波兰表达式的运算
       *         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<String>();
          // 遍历 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;
                  if (item.equals("+")) {
                      res = num1 + num2;
                  } else if (item.equals("-")) {
                      res = num1 - num2;
                  } else if (item.equals("*")) {
                      res = num1 * num2;
                  } else if (item.equals("/")) {
                      res = num1 / num2;
                  } else {
                      throw new RuntimeException("运算符有误");
                  }
                  //把res 入栈
                  stack.push("" + res);
              }
  
          }
          //最后留在stack中的数据是运算结果
          return Integer.parseInt(stack.pop());
      }
  }
  

7，中缀表达式转后缀表达式

我们发现中缀表达式是比较适合于人的思考方式，电脑很难去实现。所以需要讲中缀表达式转变为后缀表达式。

• 具体流程如下：

  • 初始化两个栈：运算符栈s1和储存中间结果的栈s2；
  • 从左至右扫描中缀表达式；
  • 遇到操作数时，将其压s2；
  • 遇到运算符时，比较其与s1栈顶运算符的优先级：
    • 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
    • 否则，若优先级比栈顶运算符的高，也将运算符压入s1；
    • 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到刚开始与s1中新的栈顶运算符相比较；
  • 遇到括号时：
    • (1) 如果是左括号“(”，则直接压入s1
    • (2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
  • 重复步骤2至5，直到表达式的最右边
  • 将s1中剩余的运算符依次弹出并压入s2
  • 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

• 重复步骤2至5，直到表达式的最右边，将s1中剩余的运算符依次弹出并压入s2，依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

  

• 代码实现中缀表达式转为后缀表达式

  • 思路分析

    

  • 代码实现：

    package com.zhao;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Stack;
    
    /**
     * @version v1.0
     * @ProjectName: 数据结构
     * @ClassName: PolandNotation
     * @Description: 请描述该类的功能
     * @Author: 赵先生
     * @Date: 2021/12/7 10:39
     */
    
    public class PolandNotation {
        public static void main(String[] args) {
    
            //完成将一个中缀表达式转成后缀表达式的功能
            //说明
            //1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
            //2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
            //   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
            //3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
            //   即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
            //注意表达式
            String expression = "1+((2+3)*4)-5"; 
            List<String> infixExpressionList = toInfixExpressionList(expression);
            // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
            System.out.println("中缀表达式对应的List=" + infixExpressionList); 
            List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
            //ArrayList [1,2,3,+,4,*,+,5,–] 
            System.out.println("后缀表达式对应的List" + suffixExpreesionList);
            // ?
            System.out.printf("expression=%d", calculate(suffixExpreesionList)); 
            
           
        }
    
        /**
         * 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
         * 方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
         * @param ls
         * @return
         */
        public static List<String> parseSuffixExpreesionList(List<String> ls) {
            //定义两个栈
            // 符号栈
            Stack<String> s1 = new Stack<String>();
            //说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
            //因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
            //Stack<String> s2 = new Stack<String>();
            // 储存中间结果的栈s2
            List<String> s2 = new ArrayList<String>();
    
            //遍历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();//!!! 将 ( 弹出 s1栈， 消除小括号
                } else {
                    //当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到s2中，再次转到(4.1)与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());
            }
            //注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
            return s2;
    
        }
    
        /**
         * 方法：将 中缀表达式转成对应的List
         * @param s s="1+((2+3)×4)-5";
         * @return
         */
        public static List<String> toInfixExpressionList(String s) {
            //定义一个List,存放中缀表达式 对应的内容
            List<String> ls = new ArrayList<String>();
            //这时是一个指针，用于遍历 中缀表达式字符串
            int i = 0;
            // 对多位数的拼接
            String str;
            // 每遍历到一个字符，就放入到c
            char c;
            do {
                //如果c是一个非数字，我需要加入到ls
                if((c=s.charAt(i)) < 48 ||  (c=s.charAt(i)) > 57) {
                    ls.add("" + c);
                    //i需要后移
                    i++;
                } else {
                    //如果是一个数，需要考虑多位数
                    //先将str 置成"" '0'[48]->'9'[57]
                    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;
        }
    
        /**
         * 将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList中
         * @param suffixExpression 自定义的表达式
         * @return
         */
        private static List<String> getListString(String suffixExpression) {
            //将 suffixExpression 分割
            String[] split = suffixExpression.split(" ");
            List<String> list = new ArrayList<String>();
            for(String ele: split) {
                list.add(ele);
            }
            return list;
        }
    
    
    	/**
         * 完成对逆波兰表达式的运算
         * 	    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<String>();
            // 遍历 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;
                    if (item.equals("+")) {
                        res = num1 + num2;
                    } else if (item.equals("-")) {
                        res = num1 - num2;
                    } else if (item.equals("*")) {
                        res = num1 * num2;
                    } else if (item.equals("/")) {
                        res = num1 / num2;
                    } else {
                        throw new RuntimeException("运算符有误");
                    }
                    //把res 入栈
                    stack.push("" + res);
                }
    
            }
            //最后留在stack中的数据是运算结果
            return Integer.parseInt(stack.pop());
        }
    }
    
    /**
     * 编写一个类 Operation 可以返回一个运算符 对应的优先级
     */
    class Operation {
        private static int ADD = 1;
        private static int SUB = 1;
        private static int MUL = 2;
        private static int DIV = 2;
    
        /**
         * 写一个方法，返回对应的优先级数字
         * @param operation 传入的符号
         * @return
         */
        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("不存在该运算符" + operation);
                    break;
            }
            return result;
        }
    
    }
     
    

8，逆波兰表达式的完整版

完整版的逆波兰计算器，功能包括：

• 支持 + - * / ( )
• 多位数，支持小数,
• 兼容处理, 过滤任何空白字符，包括空格、制表符、换页符

逆波兰计算器完整版考虑的因素较多，下面给出完整版代码供同学们学习，其基本思路和前面一样，也是使用到：中缀表达式转后缀表达式。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;

public class ReversePolishMultiCalc {

	 /**
     * 匹配 + - * / ( ) 运算符
     */
    static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";

    static final String LEFT = "(";
    static final String RIGHT = ")";
    static final String ADD = "+";
    static final String MINUS= "-";
    static final String TIMES = "*";
    static final String DIVISION = "/";

    /**
     * 加減 + -
     */
    static final int LEVEL_01 = 1;
    /**
     * 乘除 * /
     */
    static final int LEVEL_02 = 2;

    /**
     * 括号
     */
    static final int LEVEL_HIGH = Integer.MAX_VALUE;


    static Stack<String> stack = new Stack<>();
    static List<String> data = Collections.synchronizedList(new ArrayList<String>());

    /**
     * 去除所有空白符
     * @param s
     * @return
     */
    public static String replaceAllBlank(String s ){
        // \\s+ 匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]
        return s.replaceAll("\\s+","");
    }

    /**
     * 判断是不是数字 int double long float
     * @param s
     * @return
     */
    public static boolean isNumber(String s){
        Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
        return pattern.matcher(s).matches();
    }

    /**
     * 判断是不是运算符
     * @param s
     * @return
     */
    public static boolean isSymbol(String s){
        return s.matches(SYMBOL);
    }

    /**
     * 匹配运算等级
     * @param s
     * @return
     */
    public static int calcLevel(String s){
        if("+".equals(s) || "-".equals(s)){
            return LEVEL_01;
        } else if("*".equals(s) || "/".equals(s)){
            return LEVEL_02;
        }
        return LEVEL_HIGH;
    }

    /**
     * 匹配
     * @param s
     * @throws Exception
     */
    public static List<String> doMatch (String s) throws Exception{
        if(s == null || "".equals(s.trim())) throw new RuntimeException("data is empty");
        if(!isNumber(s.charAt(0)+"")) throw new RuntimeException("data illeagle,start not with a number");

        s = replaceAllBlank(s);

        String each;
        int start = 0;

        for (int i = 0; i < s.length(); i++) {
            if(isSymbol(s.charAt(i)+"")){
                each = s.charAt(i)+"";
                //栈为空，(操作符，或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈
                if(stack.isEmpty() || LEFT.equals(each)
                        || ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)){
                    stack.push(each);
                }else if( !stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())){
                    //栈非空，操作符优先级小于等于栈顶优先级时出栈入列，直到栈为空，或者遇到了(，最后操作符入栈
                    while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek()) ){
                        if(calcLevel(stack.peek()) == LEVEL_HIGH){
                            break;
                        }
                        data.add(stack.pop());
                    }
                    stack.push(each);
                }else if(RIGHT.equals(each)){
                    // ) 操作符，依次出栈入列直到空栈或者遇到了第一个)操作符，此时)出栈
                    while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())){
                        if(LEVEL_HIGH == calcLevel(stack.peek())){
                            stack.pop();
                            break;
                        }
                        data.add(stack.pop());
                    }
                }
                start = i ;    //前一个运算符的位置
            }else if( i == s.length()-1 || isSymbol(s.charAt(i+1)+"") ){
                each = start == 0 ? s.substring(start,i+1) : s.substring(start+1,i+1);
                if(isNumber(each)) {
                    data.add(each);
                    continue;
                }
                throw new RuntimeException("data not match number");
            }
        }
        //如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为/，栈底为+，应该依次出栈入列，可以直接翻转整个stack 添加到队列
        Collections.reverse(stack);
        data.addAll(new ArrayList<>(stack));

        System.out.println(data);
        return data;
    }

    /**
     * 算出结果
     * @param list
     * @return
     */
    public static Double doCalc(List<String> list){
        Double d = 0d;
        if(list == null || list.isEmpty()){
            return null;
        }
        if (list.size() == 1){
            System.out.println(list);
            d = Double.valueOf(list.get(0));
            return d;
        }
        ArrayList<String> list1 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            list1.add(list.get(i));
            if(isSymbol(list.get(i))){
                Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));
                list1.remove(i);
                list1.remove(i-1);
                list1.set(i-2,d1+"");
                list1.addAll(list.subList(i+1,list.size()));
                break;
            }
        }
        doCalc(list1);
        return d;
    }

    /**
     * 运算
     * @param s1
     * @param s2
     * @param symbol
     * @return
     */
    public static Double doTheMath(String s1,String s2,String symbol){
        Double result ;
        switch (symbol){
            case ADD : result = Double.valueOf(s1) + Double.valueOf(s2); break;
            case MINUS : result = Double.valueOf(s1) - Double.valueOf(s2); break;
            case TIMES : result = Double.valueOf(s1) * Double.valueOf(s2); break;
            case DIVISION : result = Double.valueOf(s1) / Double.valueOf(s2); break;
            default : result = null;
        }
        return result;

    }

    public static void main(String[] args) {
        //String math = "9+(3-1)*3+10/2";
        String math = "12.8 + (2 - 3.55)*4+10/5.0";
        try {
            doCalc(doMatch(math));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}