1、栈的基本介绍

1.1、栈的实际需求

  • 请计算表达式：[7_2_2-5+1-5+3-3] 的值
  • 请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算，因为我们看这个算式 7 2 2 - 5，但是计算机怎么理解这个算式的
  • 对计算机而言， 它接收到的就是一个字符串， 我们讨论的是这个问题：栈

image.png

1.2、栈的基本性质

1）栈的英文为(stack)
2）栈是一个先入后出(FILO-First In Last Out)的有序列表
3）栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 允许插入和删除的一端， 为变化的一端， 称为栈顶(Top)， 另一端为固定的一端， 称为栈底(Bottom)。
4）根据栈的定义可知， 最先放入栈中元素在栈底， 最后放入的元素在栈顶， 而删除元素刚好相反， 最后放入的元素最先删除， 最先放入的元素最后删除
图解方式说明出栈(pop)和入栈(push)的概念
[

](https://blog.csdn.net/oneby1314/article/details/107843972)
image.png

1.3、栈的应用场景

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

](https://blog.csdn.net/oneby1314/article/details/107843972)

2、数组模拟栈

2.1、代码思路

maxSize ：栈的大小（数组的大小）
arr ：用来模拟栈的数组
top ：指向当前栈顶元素，初始值为 -1 ，表示栈空
判断栈满：top == maxSize ，即已经到达数组最后一个位置
判断栈空：top == -1
入栈：arr[++top] = arr;
出栈：return arr[top–] ;
[

](https://blog.csdn.net/oneby1314/article/details/107843972)
image.png

2.2、代码实现

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

    // 构造器 public ArrayStack(int maxSize) {

    1.   this.maxSize = maxSize;
    2.   stack = new int[this.maxSize];

    }

    // 栈满 public boolean isFull() {

    1.   return top == maxSize - 1;

    }

    // 栈空 public boolean isEmpty() {

    1.   return top == -1;

    }

    // 入栈-push public void push(int value) {

    1.   // 先判断栈是否满
    2.   if (isFull()) {
    3.       System.out.println("栈满");
    4.       return;
    5.   }
    6.   top++;
    7.   stack[top] = value;

    }

    // 出栈-pop, 将栈顶的数据返回 public int pop() {

    1.   // 先判断栈是否空
    2.   if (isEmpty()) {
    3.       // 抛出异常
    4.       throw new RuntimeException("栈空，没有数据~");
    5.   }
    6.   int value = stack[top];
    7.   top--;
    8.   return value;

    }

    // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据 public void list() {

    1.   if (isEmpty()) {
    2.       System.out.println("栈空，没有数据~~");
    3.       return;
    4.   }
    5.   // 需要从栈顶开始显示数据
    6.   for (int i = top; i >= 0; i--) {
    7.       System.out.printf("stack[%d]=%d\n", i, stack[i]);
    8.   }

    }

}

  2. - 测试代码
  3. ```java
  4. public static void main(String[] args) {
  5.     // 测试一下ArrayStack 是否正确
  6.     // 先创建一个ArrayStack对象->表示栈
  7.     ArrayStack stack = new ArrayStack(4);
  8.     String key = "";
  9.     boolean loop = true; // 控制是否退出菜单
  10.     Scanner scanner = new Scanner(System.in);
  12.     while (loop) {
  13.         System.out.println("show: 表示显示栈");
  14.         System.out.println("exit: 退出程序");
  15.         System.out.println("push: 表示添加数据到栈(入栈)");
  16.         System.out.println("pop: 表示从栈取出数据(出栈)");
  17.         System.out.println();
  18.         System.out.println("请输入你的选择");
  19.         key = scanner.next();
  20.         switch (key) {
  21.             case "show":
  22.                 stack.list();
  23.                 break;
  24.             case "push":
  25.                 System.out.println("请输入一个数");
  26.                 int value = scanner.nextInt();
  27.                 stack.push(value);
  28.                 break;
  29.             case "pop":
  30.                 try {
  31.                     int res = stack.pop();
  32.                     System.out.printf("出栈的数据是 %d\n", res);
  33.                 } catch (Exception e) {
  34.                     // TODO: handle exception
  35.                     System.out.println(e.getMessage());
  36.                 }
  37.                 break;
  38.             case "exit":
  39.                 scanner.close();
  40.                 loop = false;
  41.                 break;
  42.             default:
  43.                 break;
  44.         }
  45.     }
  47.     System.out.println("程序退出~~~");
  48. }
  • 程序运行结果 ```java show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 push 请输入一个数 1 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 push 请输入一个数 2 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 push 请输入一个数 3 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 push 请输入一个数 4 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 push 请输入一个数 5 栈满 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 show stack[3]=4 stack[2]=3 stack[1]=2 stack[0]=1 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 pop 出栈的数据是 4 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 pop 出栈的数据是 3 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 pop 出栈的数据是 2 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 pop 出栈的数据是 1 show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择 pop 栈空，没有数据~ show: 表示显示栈 exit: 退出程序 push: 表示添加数据到栈(入栈) pop: 表示从栈取出数据(出栈)

请输入你的选择

  1. <a name="kVs0m"></a>
  2. ### 2.3、数组模拟栈全部代码
  3. ```java
  4. public class ArrayStackDemo {
  6.     public static void main(String[] args) {
  7.         // 测试一下ArrayStack 是否正确
  8.         // 先创建一个ArrayStack对象->表示栈
  9.         ArrayStack stack = new ArrayStack(4);
  10.         String key = "";
  11.         boolean loop = true; // 控制是否退出菜单
  12.         Scanner scanner = new Scanner(System.in);
  14.         while (loop) {
  15.             System.out.println("show: 表示显示栈");
  16.             System.out.println("exit: 退出程序");
  17.             System.out.println("push: 表示添加数据到栈(入栈)");
  18.             System.out.println("pop: 表示从栈取出数据(出栈)");
  19.             System.out.println();
  20.             System.out.println("请输入你的选择");
  21.             key = scanner.next();
  22.             switch (key) {
  23.             case "show":
  24.                 stack.list();
  25.                 break;
  26.             case "push":
  27.                 System.out.println("请输入一个数");
  28.                 int value = scanner.nextInt();
  29.                 stack.push(value);
  30.                 break;
  31.             case "pop":
  32.                 try {
  33.                     int res = stack.pop();
  34.                     System.out.printf("出栈的数据是 %d\n", res);
  35.                 } catch (Exception e) {
  36.                     // TODO: handle exception
  37.                     System.out.println(e.getMessage());
  38.                 }
  39.                 break;
  40.             case "exit":
  41.                 scanner.close();
  42.                 loop = false;
  43.                 break;
  44.             default:
  45.                 break;
  46.             }
  47.         }
  49.         System.out.println("程序退出~~~");
  50.     }
  52. }
  54. //定义一个 ArrayStack 表示栈
  55. class ArrayStack {
  56.     private int maxSize; // 栈的大小
  57.     private int[] stack; // 数组，数组模拟栈，数据就放在该数组
  58.     private int top = -1;// top表示栈顶，初始化为-1
  60.     // 构造器
  61.     public ArrayStack(int maxSize) {
  62.         this.maxSize = maxSize;
  63.         stack = new int[this.maxSize];
  64.     }
  66.     // 栈满
  67.     public boolean isFull() {
  68.         return top == maxSize - 1;
  69.     }
  71.     // 栈空
  72.     public boolean isEmpty() {
  73.         return top == -1;
  74.     }
  76.     // 入栈-push
  77.     public void push(int value) {
  78.         // 先判断栈是否满
  79.         if (isFull()) {
  80.             System.out.println("栈满");
  81.             return;
  82.         }
  83.         top++;
  84.         stack[top] = value;
  85.     }
  87.     // 出栈-pop, 将栈顶的数据返回
  88.     public int pop() {
  89.         // 先判断栈是否空
  90.         if (isEmpty()) {
  91.             // 抛出异常
  92.             throw new RuntimeException("栈空，没有数据~");
  93.         }
  94.         int value = stack[top];
  95.         top--;
  96.         return value;
  97.     }
  99.     // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  100.     public void list() {
  101.         if (isEmpty()) {
  102.             System.out.println("栈空，没有数据~~");
  103.             return;
  104.         }
  105.         // 需要从栈顶开始显示数据
  106.         for (int i = top; i >= 0; i--) {
  107.             System.out.printf("stack[%d]=%d\n", i, stack[i]);
  108.         }
  109.     }
  111. }

2.4、课后练习

  • 使用链表模拟栈

    3、栈实现综合计算器(中缀表达式)

    3.1、代码思路

  • 栈分为两个栈：

    • 数栈（numStack）：存储表达式中的数字
    • 符号栈（operStack）：存储表达式中的符号
  • 扫描表达式（这里并没有考虑括号）：
  • 对于数：扫描到数，则直接压入数栈
  • 对于运算符：扫描到运算符，分为如下几种情况：
    • 如果符号栈为空，则直接入栈
    • 如果符号栈不为空：
  • 如果当前扫描到的运算符的优先级 <= 符号栈栈顶的运算符的优先级，说明上次的运算符优先级较高，先执行优先级高的运算
    • 从数栈中弹出两个数，根据符号栈栈顶的运算符进行运算（优先级高，就先算出来）
    • 然后将计算的结果压入栈中
    • 再将当前运算符压入符号栈
  • 如果当前扫描到的运算符的优先级 > 符号栈栈顶的运算符的优先级，说明上次的运算符优先级较低，直接压入符号栈
  • 何时停止循环？
    • 处理完表达式，退出循环
    • 即表达式下标（index）的值大于表达式（expression）的长度
    • 代码：index >= expression.length()
  • 表达式扫描完成：
    • 此时符号栈中的运算符优先级都相同
    • 从数栈中弹出两个数，再从符号栈中弹出一个运算符，进行运算，计算结果放回数栈中
    • 何时停止循环？符号栈为空则停止：operStack.isEmpty()
    • 表达式的值？符号栈为空时，数栈栈顶还有一个元素，这个元素的值就是表达式的值

举例：3+2*6-2

  • 首先
    • 将 3 压入数栈
    • 将 + 压入符号栈
    • 将 2 压入数栈 ```java 2 3 + 数栈 符号栈
  2. - 由于 * 优先级大于 + ，所以将 * 压入 符号栈，然后将 6 压入数栈
  3. ```java
  4. 6
  5. 2      *
  6. 3      +
  7. 数栈    符号栈
  • 由于 - 优先级低于 ，所以从数栈中弹出两个数（6 和 2），从符号栈中弹出一个运算符（），进行运算，运算结果再压入数栈，然后将 - 压入符号栈 ```java 12 - 3 + 数栈 符号栈
  2. - 将 2 压入数栈，表达式处理完毕
  3. ```java
  4. 2
  5. 12      -
  6. 3      +
  7. 数栈    符号栈
  • 重复此过程，直至符号栈为空：从数栈中弹出两个数，再从符号栈中弹出一个运算符，进行运算，计算结果放回数栈中
    1. 10
    2. 3      +
    3. 数栈    符号栈
    ```java 13 数栈 符号栈
  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/2673847/1641795247544-d043a7c5-1e91-49ce-944e-2a21fa9e5310.png#clientId=u35fea09d-3b30-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=386&id=u24a38457&margin=%5Bobject%20Object%5D&name=image.png&originHeight=386&originWidth=935&originalType=binary&ratio=1&rotation=0&showTitle=false&size=43553&status=done&style=none&taskId=u6603bb92-cb0b-4aba-9341-355596ef945&title=&width=935)
  2. <a name="VdpCZ"></a>
  3. ### 3.2、代码实现
  5. - 栈的定义：专为计算器而生的栈
  6. - 对于乘除法特别说明：由于**栈先进后**出的特点，num1 是运算符后面的数（减数、除数），num2 是运算符前的数（被减数、被除数），**特别需要注意减法与除法的顺序**
  7. - **res = num2 - num1;**
  8. - **res = num2 / num1;**
  9. ```java
  10. //先创建一个栈,直接使用前面创建好
  11. //定义一个 CalcStack 表示栈, 需要扩展功能
  12. class CalcStack {
  13.     private int maxSize; // 栈的大小
  14.     private int[] stack; // 数组，数组模拟栈，数据就放在该数组
  15.     private int top = -1;// top表示栈顶，初始化为-1
  17.     // 构造器
  18.     public CalcStack(int maxSize) {
  19.         this.maxSize = maxSize;
  20.         stack = new int[this.maxSize];
  21.     }
  23.     // 增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
  24.     public int peek() {
  25.         return stack[top];
  26.     }
  28.     // 栈满
  29.     public boolean isFull() {
  30.         return top == maxSize - 1;
  31.     }
  33.     // 栈空
  34.     public boolean isEmpty() {
  35.         return top == -1;
  36.     }
  38.     // 入栈-push
  39.     public void push(int value) {
  40.         // 先判断栈是否满
  41.         if (isFull()) {
  42.             System.out.println("栈满");
  43.             return;
  44.         }
  45.         top++;
  46.         stack[top] = value;
  47.     }
  49.     // 出栈-pop, 将栈顶的数据返回
  50.     public int pop() {
  51.         // 先判断栈是否空
  52.         if (isEmpty()) {
  53.             // 抛出异常
  54.             throw new RuntimeException("栈空，没有数据~");
  55.         }
  56.         int value = stack[top];
  57.         top--;
  58.         return value;
  59.     }
  61.     // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  62.     public void list() {
  63.         if (isEmpty()) {
  64.             System.out.println("栈空，没有数据~~");
  65.             return;
  66.         }
  67.         // 需要从栈顶开始显示数据
  68.         for (int i = top; i >= 0; i--) {
  69.             System.out.printf("stack[%d]=%d\n", i, stack[i]);
  70.         }
  71.     }
  73.     // 返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
  74.     // 数字越大，则优先级就越高.
  75.     public int priority(int oper) {
  76.         if (oper == '*' || oper == '/') {
  77.             return 1;
  78.         } else if (oper == '+' || oper == '-') {
  79.             return 0;
  80.         } else {
  81.             return -1; // 假定目前的表达式只有 +, - , * , /
  82.         }
  83.     }
  85.     // 判断是不是一个运算符
  86.     public boolean isOper(char val) {
  87.         return val == '+' || val == '-' || val == '*' || val == '/';
  88.     }
  90.     // 计算方法
  91.     public int cal(int num1, int num2, int oper) {
  92.         int res = 0; // res 用于存放计算的结果
  93.         switch (oper) {
  94.         case '+':
  95.             res = num1 + num2;
  96.             break;
  97.         case '-':
  98.             res = num2 - num1;// 注意顺序
  99.             break;
  100.         case '*':
  101.             res = num1 * num2;
  102.             break;
  103.         case '/':
  104.             res = num2 / num1;
  105.             break;
  106.         default:
  107.             break;
  108.         }
  109.         return res;
  110.     }
  112. }

  • 综合计算器代码：对多位数进行了判断，使得程序可处理多位数的运算 ```java public static void main(String[] args) { // 根据前面老师思路，完成表达式的运算 String expression = “722-5+1-5+3-4”; // 如何处理多位数的问题？ // 创建两个栈，一个数栈，一个符号栈 CalcStack numStack = new CalcStack(10); CalcStack operStack = new CalcStack(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) {

    1.   // 依次得到expression 的每一个字符
    2.   ch = expression.substring(index, index + 1).charAt(0);
    3.   // 判断ch是什么，然后做相应的处理
    4.   if (operStack.isOper(ch)) {// 如果是运算符
    5.       // 判断当前的符号栈是否为空
    6.       if (!operStack.isEmpty()) {
    7.           // 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
    8.           // 在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
    9.           if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
    10.               num1 = numStack.pop();
    11.               num2 = numStack.pop();
    12.               oper = operStack.pop();
    13.               res = numStack.cal(num1, num2, oper);
    14.               // 把运算的结果如数栈
    15.               numStack.push(res);
    16.               // 然后将当前的操作符入符号栈
    17.               operStack.push(ch);
    18.           } else {
    19.               // 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
    20.               operStack.push(ch);
    21.           }
    22.       } else {
    23.           // 如果为空直接入符号栈..
    24.           operStack.push(ch); // 1 + 3
    25.       }
    26.   } else { // 如果是数，则直接入数栈
    28.       // numStack.push(ch - 48); //? "1+3" '1' => 1
    29.       // 分析思路
    30.       // 1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
    31.       // 2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
    32.       // 3. 因此我们需要定义一个变量 字符串，用于拼接
    34.       // 处理多位数
    35.       keepNum += ch;
    37.       // 如果ch已经是expression的最后一位，就直接入栈
    38.       if (index == expression.length() - 1) {
    39.           numStack.push(Integer.parseInt(keepNum));
    40.       } else {
    42.           // 判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
    43.           // 注意是看后一位，不是index++
    44.           if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
    45.               // 如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
    46.               numStack.push(Integer.parseInt(keepNum));
    47.               // 重要的!!!!!!, keepNum清空
    48.               keepNum = "";
    50.           }
    51.       }
    52.   }
    53.   // 让index + 1, 并判断是否扫描到expression最后.
    54.   index++;
    55.   if (index >= expression.length()) {
    56.       break;
    57.   }

    }

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

    1.   // 如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
    2.   if (operStack.isEmpty()) {
    3.       break;
    4.   }
    5.   num1 = numStack.pop();
    6.   num2 = numStack.pop();
    7.   oper = operStack.pop();
    8.   res = numStack.cal(num1, num2, oper);
    9.   numStack.push(res);// 入栈

    } // 将数栈的最后数，pop出，就是结果 res = numStack.pop(); System.out.printf(“表达式 %s = %d”, expression, res); }

  2. - 程序运行结果
  3. ```java
  4. 表达式 7*2*2-5+1-5+3-4 = 18

3.3、综合计算器全部代码

  1. public class Calculator {
  3.     public static void main(String[] args) {
  4.         // 根据前面老师思路，完成表达式的运算
  5.         String expression = "7*2*2-5+1-5+3-4"; // 如何处理多位数的问题？
  6.         // 创建两个栈，一个数栈，一个符号栈
  7.         CalcStack numStack = new CalcStack(10);
  8.         CalcStack operStack = new CalcStack(10);
  9.         // 定义需要的相关变量
  10.         int index = 0;// 用于扫描
  11.         int num1 = 0;
  12.         int num2 = 0;
  13.         int oper = 0;
  14.         int res = 0;
  15.         char ch = ' '; // 将每次扫描得到char保存到ch
  16.         String keepNum = ""; // 用于拼接 多位数
  17.         // 开始while循环的扫描expression
  18.         while (true) {
  19.             // 依次得到expression 的每一个字符
  20.             ch = expression.substring(index, index + 1).charAt(0);
  21.             // 判断ch是什么，然后做相应的处理
  22.             if (operStack.isOper(ch)) {// 如果是运算符
  23.                 // 判断当前的符号栈是否为空
  24.                 if (!operStack.isEmpty()) {
  25.                     // 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
  26.                     // 在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
  27.                     if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
  28.                         num1 = numStack.pop();
  29.                         num2 = numStack.pop();
  30.                         oper = operStack.pop();
  31.                         res = numStack.cal(num1, num2, oper);
  32.                         // 把运算的结果如数栈
  33.                         numStack.push(res);
  34.                         // 然后将当前的操作符入符号栈
  35.                         operStack.push(ch);
  36.                     } else {
  37.                         // 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
  38.                         operStack.push(ch);
  39.                     }
  40.                 } else {
  41.                     // 如果为空直接入符号栈..
  42.                     operStack.push(ch); // 1 + 3
  43.                 }
  44.             } else { // 如果是数，则直接入数栈
  46.                 // numStack.push(ch - 48); //? "1+3" '1' => 1
  47.                 // 分析思路
  48.                 // 1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
  49.                 // 2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
  50.                 // 3. 因此我们需要定义一个变量 字符串，用于拼接
  52.                 // 处理多位数
  53.                 keepNum += ch;
  55.                 // 如果ch已经是expression的最后一位，就直接入栈
  56.                 if (index == expression.length() - 1) {
  57.                     numStack.push(Integer.parseInt(keepNum));
  58.                 } else {
  60.                     // 判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
  61.                     // 注意是看后一位，不是index++
  62.                     if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
  63.                         // 如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
  64.                         numStack.push(Integer.parseInt(keepNum));
  65.                         // 重要的!!!!!!, keepNum清空
  66.                         keepNum = "";
  68.                     }
  69.                 }
  70.             }
  71.             // 让index + 1, 并判断是否扫描到expression最后.
  72.             index++;
  73.             if (index >= expression.length()) {
  74.                 break;
  75.             }
  76.         }
  78.         // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
  79.         while (true) {
  80.             // 如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
  81.             if (operStack.isEmpty()) {
  82.                 break;
  83.             }
  84.             num1 = numStack.pop();
  85.             num2 = numStack.pop();
  86.             oper = operStack.pop();
  87.             res = numStack.cal(num1, num2, oper);
  88.             numStack.push(res);// 入栈
  89.         }
  90.         // 将数栈的最后数，pop出，就是结果
  91.         res = numStack.pop();
  92.         System.out.printf("表达式 %s = %d", expression, res);
  93.     }
  95. }
  97. //先创建一个栈,直接使用前面创建好
  98. //定义一个 CalcStack 表示栈, 需要扩展功能
  99. class CalcStack {
  100.     private int maxSize; // 栈的大小
  101.     private int[] stack; // 数组，数组模拟栈，数据就放在该数组
  102.     private int top = -1;// top表示栈顶，初始化为-1
  104.     // 构造器
  105.     public CalcStack(int maxSize) {
  106.         this.maxSize = maxSize;
  107.         stack = new int[this.maxSize];
  108.     }
  110.     // 增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
  111.     public int peek() {
  112.         return stack[top];
  113.     }
  115.     // 栈满
  116.     public boolean isFull() {
  117.         return top == maxSize - 1;
  118.     }
  120.     // 栈空
  121.     public boolean isEmpty() {
  122.         return top == -1;
  123.     }
  125.     // 入栈-push
  126.     public void push(int value) {
  127.         // 先判断栈是否满
  128.         if (isFull()) {
  129.             System.out.println("栈满");
  130.             return;
  131.         }
  132.         top++;
  133.         stack[top] = value;
  134.     }
  136.     // 出栈-pop, 将栈顶的数据返回
  137.     public int pop() {
  138.         // 先判断栈是否空
  139.         if (isEmpty()) {
  140.             // 抛出异常
  141.             throw new RuntimeException("栈空，没有数据~");
  142.         }
  143.         int value = stack[top];
  144.         top--;
  145.         return value;
  146.     }
  148.     // 显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  149.     public void list() {
  150.         if (isEmpty()) {
  151.             System.out.println("栈空，没有数据~~");
  152.             return;
  153.         }
  154.         // 需要从栈顶开始显示数据
  155.         for (int i = top; i >= 0; i--) {
  156.             System.out.printf("stack[%d]=%d\n", i, stack[i]);
  157.         }
  158.     }
  160.     // 返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
  161.     // 数字越大，则优先级就越高.
  162.     public int priority(int oper) {
  163.         if (oper == '*' || oper == '/') {
  164.             return 1;
  165.         } else if (oper == '+' || oper == '-') {
  166.             return 0;
  167.         } else {
  168.             return -1; // 假定目前的表达式只有 +, - , * , /
  169.         }
  170.     }
  172.     // 判断是不是一个运算符
  173.     public boolean isOper(char val) {
  174.         return val == '+' || val == '-' || val == '*' || val == '/';
  175.     }
  177.     // 计算方法
  178.     public int cal(int num1, int num2, int oper) {
  179.         int res = 0; // res 用于存放计算的结果
  180.         switch (oper) {
  181.         case '+':
  182.             res = num1 + num2;
  183.             break;
  184.         case '-':
  185.             res = num2 - num1;// 注意顺序
  186.             break;
  187.         case '*':
  188.             res = num1 * num2;
  189.             break;
  190.         case '/':
  191.             res = num2 / num1;
  192.             break;
  193.         default:
  194.             break;
  195.         }
  196.         return res;
  197.     }
  199. }

3.4、课后练习

  • 加入小括号的判断：小括号内的运算需要优先执行，也即小括号的优先级最高

  • 我的代码思路如下:

    • 但凡遇到左括号，直接入符号栈，之后的操作和之前的一样
    • 直至遇到右括号，此时可以依次将符号栈中的符号弹出，与数栈中的数做运算
    • 直至符号栈弹出左括号为止，此时，括号内的运算已执行完毕

      4、前缀 中缀 后缀表达式

      4.1、前缀表达式(波兰表达式)

      4.1.1、前缀表达式

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

  • 举例说明： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6

    4.1.2、前缀表达式的计算机求值

  • 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果

  • 例如：(3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:

    • 从右至左扫描，将6、5、4、3压入堆栈
    • 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈
    • 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
    • 最后是-运算符，计算出35-6的值，即29，由此得出最终结果

      4.2、中缀表达式

  • 中缀表达式就是常见的运算表达式，如(3+4)×5-6

  • 中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(前面我们讲的案例就能看的这个问题，因为中缀表达式存在运算符优先级的问题)，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)

    4.3、后缀表达式

    4.3.1、后缀表达式

  • 后缀表达式又称逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后

  • 中缀表达式举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –
  • 再比如: | 正常的表达式 | 逆波兰表达式 | | —- | —- | | a+b | a b + | | a+(b-c) | a b c - + | | a+(b-c)d | a b c – d + | | a+d(b-c) | a d b c - + | | a=1+3 | a 1 3 + = |

4.3.2、后缀表达式的计算机求值

  • 从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

  • 从左至右扫描，将3和4压入堆栈；
  • 遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
  • 将5入栈；
  • 接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
  • 将6入栈；

  • 最后是-运算符，计算出35-6的值，即29，由此得出最终结果

    5、逆波兰计算器

    5.1、计算器说明

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

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

    5.2、代码思路

  • 计算后缀表达式无需考虑运算符优先级问题，所以只需要一个数栈即可

  • 分为两种情况：
    • 遇到数：压入数栈
    • 遇到运算符：从数栈中弹出两个数，进行计算，计算结果压入数栈

  • 何时计算完成？处理完表达式就代表计算完成

    5.3、代码实现

  • 出栈的两个数：num2 和 num1

    • num2 先出栈，所以 num2 是减数或除数

    • num1 后出栈，所以 num1 是被减数或被除数 ```java public class PolandNotation {

      public static void main(String[] args) {

      //先定义给逆波兰表达式 // 4 5 - 8 + 60 + 8 / 2 => 4 5 8 - 60 + 8 2 / + //说明为了方便，逆波兰表达式 的数字和符号使用空格隔开 String suffixExpression = “4 5 * 8 - 60 + 8 2 / +”; // 76 //思路 //1. 先将逆波兰表达式 => 放到ArrayList中 //2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算

      List list = getListString(suffixExpression); System.out.println(“rpnList=” + list); int res = calculate(list); System.out.println(“计算的结果是=” + res);

      }

      //将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList中 public static List getListString(String suffixExpression) { //将 suffixExpression 分割 String[] split = suffixExpression.split(“ “); List list = new ArrayList(); for(String ele: split) {

      1.    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 ls) { // 创建给栈, 只需要一个栈即可 Stack stack = new Stack(); // 遍历 ls for (String item : ls) {

      1.    // 这里使用正则表达式来取出数
      2.    if (item.matches("\\d+")) { // 匹配的是多位数
      3.        // 入栈
      4.        stack.push(item);
      5.    } else {
      6.        // pop出两个数，并运算， 再入栈
      7.        int num2 = Integer.parseInt(stack.pop());
      8.        int num1 = Integer.parseInt(stack.pop());
      9.        int res = 0;
      10.        if (item.equals("+")) {
      11.            res = num1 + num2;
      12.        } else if (item.equals("-")) {
      13.            res = num1 - num2;
      14.        } else if (item.equals("*")) {
      15.            res = num1 * num2;
      16.        } else if (item.equals("/")) {
      17.            res = num1 / num2;
      18.        } else {
      19.            throw new RuntimeException("运算符有误");
      20.        }
      21.        //把res 入栈
      22.        stack.push("" + res);
      23.    }

      } //最后留在stack中的数据是运算结果 return Integer.parseInt(stack.pop()); }

}

  2. - 程序运行结果
  3. ```java
  4. rpnList=[4, 5, *, 8, -, 60, +, 8, 2, /, +]
  5. 计算的结果是=76

6、中缀表达式转后缀表达式

6.1、代码思路

  • 大家看到，后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将中缀表达式转成后缀表达式。
  • 具体步骤如下:
  1. 初始化两个栈：运算符栈operStack和储存中间结果的栈tempStack；
  2. 从左至右扫描中缀表达式；
  3. 遇到操作数时，将其压tempStack；

  4. 遇到运算符时，比较其与operStack栈顶运算符的优先级：
    1.如果operStack为空，或栈顶运算符为左括号“(”，则直接将此运算符入tempStack栈（分如下两种情况）

    1.      1.operStack 栈顶为空：之前的优先级别高的运算已经处理完成，已经得到了              一个结果，将当前运算符直接压入 operStack 栈即可<br />            2.operStack 栈顶为左括号：我都挨着左括号了，我要和它同生共死！当把我             从operStack 出栈，用于运算后，这对括号中的表达式的值也就计算出来了<br />**         2.如果当前运算符优先级比栈顶运算符的高，也将运算符压入tempStack         （当前运算符优先级高，先执行运算）**<br />**         3.否则，当前运算符优先级 <= 栈顶运算符优先级，将operStack栈顶的            运算符弹出并压入到tempStack中（operStack 栈顶运算符优先级高，先          执行运算），再次转到(4.1)与operStack中新的栈顶运算符相比较**（分如          下两种情况）；<br />             1. 一直循环，将 tempStack 栈顶元素取出，直到在 operStack 栈中找到比当              前运算符优先级高的运算符，让其先执行运算<br />             如果在 tempStack 栈中找不到比当前运算符优先级高的运算符，则会直接将              2.operStack 栈掏空，然后将当前运算符压入 tempStack 栈中（放在栈底）

5.遇到括号时：
1.如果是左括号“(”，则直接压入operStack，等待与其配对的右括号，因为括号中的表达式需要优先运算
2.如果是右括号“)”，则依次弹出operStack栈顶的运算符，并压入tempStack，直到遇到左括号为止，此时将这一对括号丢弃（此时括号内的运算完成，并将结果压入了tempStack）
6.重复步骤2至5，直到表达式的最右边
7.将operStack中剩余的运算符依次弹出并压入tempStack（operStack 栈中剩下的运算都是优先级相同的运算符，按顺序执行即可）
8.依次弹出tempStack中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
image.png

6.2、举例说明

  • 举例说明：将中缀表达 式“1+((2+3)×4)-5”转换为后缀表达式的过程如下
  • 因此结果为：“1 2 3 + 4 × + 5 –”

扫描到的元素 tempStack(栈底->栈顶) operStack(栈底->栈顶) 说明

image.png
[

](https://blog.csdn.net/oneby1314/article/details/107843972)

6.3、代码实现

  • 将中缀表达式转为对应的 List ：将数字和运算符分开，存储在 List 对象中 ```java // 方法：将 中缀表达式转成对应的List // s=”1+((2+3)×4)-5”; public static List toInfixExpressionList(String s) { // 定义一个List,存放中缀表达式 对应的内容 List ls = new ArrayList(); int i = 0; // 这时是一个指针，用于遍历 中缀表达式字符串 String str; // 对多位数的拼接 char c; // 每遍历到一个字符，就放入到c do {
    1.   // 如果c是一个非数字，我需要加入到ls
    2.   if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
    3.       ls.add("" + c);
    4.       i++; // i需要后移
    5.   } else { // 如果是一个数，需要考虑多位数
    6.       str = ""; // 先将str 置成"" '0'[48]->'9'[57]
    7.       while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
    8.           str += c;// 拼接
    9.           i++;
    10.       }
    11.       ls.add(str);
    12.   }
    } while (i < s.length()); return ls;// 返回 }
  1. 将中缀表达式（List）转为后缀表达式（List）
  3. 如果是一个数，加入tempList<br />如果是 ( ，则直接入operStack（括号内的表达式优先计算）<br />如果是 ) ，则依次弹出 operStack 栈顶的运算符，并压入 tempList ，直到遇到左括号为止，此时将这一对括号丢弃（括号内的表达式优先计算）<br />否则比较当前运算符和栈顶运算符优先级
  5. - 当前运算符优先级 > 栈顶运算符，将当前运算符压入 operStack 栈中（当前运算符优先级较高，先进行运算）
  6. - 当前运算符优先级 <= 栈顶运算符，将 operStack 栈顶运算符取出，压入 tempList 中，再次对新的栈顶元素进行优先级判断（之前的运算符优先级较高，先进行运算）
  8. ```java
  9. // 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
  10. // 方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
  11. public static List<String> parseSuffixExpreesionList(List<String> ls) {
  12.     // 定义两个栈
  13.     Stack<String> operStack = new Stack<String>(); // 符号栈
  14.     // 说明：因为tempList 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
  15.     // 因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> tempList
  16.     // Stack<String> tempStack = new Stack<String>(); // 储存中间结果的栈tempStack
  17.     List<String> tempList = new ArrayList<String>(); // 储存中间结果的tempList
  19.     // 遍历ls
  20.     for (String item : ls) {
  21.         if (item.matches("\\d+")) { // 如果是一个数，加入tempList
  22.             tempList.add(item);
  23.         } else if (item.equals("(")) { // 如果是 ( ，则直接入operStack
  24.             operStack.push(item);
  25.         } else if (item.equals(")")) { // 如果是 ) ，则将括号内的值算出，并压入 tempList）
  26.             // 如果是右括号“)”，则依次弹出operStack栈顶的运算符，并压入tempList，直到遇到左括号为止，此时将这一对括号丢弃
  27.             while (!operStack.peek().equals("(")) {
  28.                 tempList.add(operStack.pop());
  29.             }
  30.             operStack.pop();// !!! 将 ( 弹出 s1栈， 消除小括号
  31.         } else { // 否则比较当前运算符和栈顶运算符优先级
  32.             // 当item的优先级小于等于operStack栈顶运算符,
  33.             // 将operStack栈顶的运算符弹出并加入到tempList中，再次转到(4.1)与operStack中新的栈顶运算符相比较
  34.             // 问题：我们缺少一个比较优先级高低的方法
  35.             while (operStack.size() != 0 && Operation.getValue(operStack.peek()) >= Operation.getValue(item)) {
  36.                 tempList.add(operStack.pop());
  37.             }
  38.             // 还需要将item压入栈
  39.             operStack.push(item);
  40.         }
  41.     }
  43.     // 将operStack中剩余的运算符依次弹出并加入tempList
  44.     while (operStack.size() != 0) {
  45.         tempList.add(operStack.pop());
  46.     }
  48.     return tempList; // 注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
  50. }

  • 测试代码：

    • 将中缀表达式转为对应的 List
    • 将中缀表达式 List 转为后缀表达式 List

    • 调用逆波兰计算器执行计算 ```java 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 infixExpressionList = toInfixExpressionList(expression); System.out.println(“中缀表达式对应的List=” + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),,4,),-,5] List suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList); System.out.println(“后缀表达式对应的List” + suffixExpreesionList); // ArrayList [1,2,3,+,4,*,+,5,–] System.out.printf(“expression=%d”, calculate(suffixExpreesionList)); // ?

}

  2. - 程序运行结果
  3. ```java
  4. 中缀表达式对应的List=[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
  5. 后缀表达式对应的List[1, 2, 3, +, 4, *, +, 5, -]
  6. expression=16

6.4、中缀表达式转后缀表达式完整代码

  1. public class PolandNotation {
  3.     public static void main(String[] args) {
  5.         // 完成将一个中缀表达式转成后缀表达式的功能
  7.         // 说明
  8.         // 1. 1+((2+3)×4)-5 => 转成 1 2 3 + 4 × + 5 –
  10.         // 2. 因为直接对str 进行操作，不方便，因此 先将 "1+((2+3)×4)-5" =》 中缀的表达式对应的List
  11.         // 即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
  13.         // 3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
  14.         // 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
  16.         String expression = "1+((2+3)*4)-5";// 注意表达式
  17.         List<String> infixExpressionList = toInfixExpressionList(expression);
  18.         System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
  19.         List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
  20.         System.out.println("后缀表达式对应的List" + suffixExpreesionList); // ArrayList [1,2,3,+,4,*,+,5,–]
  21.         System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?
  23.     }
  25.     // 方法：将 中缀表达式转成对应的List
  26.     // s="1+((2+3)×4)-5";
  27.     public static List<String> toInfixExpressionList(String s) {
  28.         // 定义一个List,存放中缀表达式 对应的内容
  29.         List<String> ls = new ArrayList<String>();
  30.         int i = 0; // 这时是一个指针，用于遍历 中缀表达式字符串
  31.         String str; // 对多位数的拼接
  32.         char c; // 每遍历到一个字符，就放入到c
  33.         do {
  34.             // 如果c是一个非数字，我需要加入到ls
  35.             if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
  36.                 ls.add("" + c);
  37.                 i++; // i需要后移
  38.             } else { // 如果是一个数，需要考虑多位数
  39.                 str = ""; // 先将str 置成"" '0'[48]->'9'[57]
  40.                 while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
  41.                     str += c;// 拼接
  42.                     i++;
  43.                 }
  44.                 ls.add(str);
  45.             }
  46.         } while (i < s.length());
  47.         return ls;// 返回
  48.     }
  50.     // 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
  51.     // 方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
  52.     public static List<String> parseSuffixExpreesionList(List<String> ls) {
  53.         // 定义两个栈
  54.         Stack<String> operStack = new Stack<String>(); // 符号栈
  55.         // 说明：因为tempList 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
  56.         // 因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> tempList
  57.         // Stack<String> tempStack = new Stack<String>(); // 储存中间结果的栈tempStack
  58.         List<String> tempList = new ArrayList<String>(); // 储存中间结果的tempList
  60.         // 遍历ls
  61.         for (String item : ls) {
  62.             if (item.matches("\\d+")) { // 如果是一个数，加入tempList
  63.                 tempList.add(item);
  64.             } else if (item.equals("(")) { // 如果是 ( ，则直接入operStack
  65.                 operStack.push(item);
  66.             } else if (item.equals(")")) { // 如果是 ) ，则将括号内的值算出，并压入 tempList）
  67.                 // 如果是右括号“)”，则依次弹出operStack栈顶的运算符，并压入tempList，直到遇到左括号为止，此时将这一对括号丢弃
  68.                 while (!operStack.peek().equals("(")) {
  69.                     tempList.add(operStack.pop());
  70.                 }
  71.                 operStack.pop();// !!! 将 ( 弹出 s1栈， 消除小括号
  72.             } else { // 否则比较当前运算符和栈顶运算符优先级
  73.                 // 当item的优先级小于等于operStack栈顶运算符,
  74.                 // 将operStack栈顶的运算符弹出并加入到tempList中，再次转到(4.1)与operStack中新的栈顶运算符相比较
  75.                 // 问题：我们缺少一个比较优先级高低的方法
  76.                 while (operStack.size() != 0 && Operation.getValue(operStack.peek()) >= Operation.getValue(item)) {
  77.                     tempList.add(operStack.pop());
  78.                 }
  79.                 // 还需要将item压入栈
  80.                 operStack.push(item);
  81.             }
  82.         }
  84.         // 将operStack中剩余的运算符依次弹出并加入tempList
  85.         while (operStack.size() != 0) {
  86.             tempList.add(operStack.pop());
  87.         }
  89.         return tempList; // 注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
  91.     }
  93.     // 完成对逆波兰表达式的运算
  94.     /*
  95.      * 1)从左至右扫描，将3和4压入堆栈； 2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈； 3)将5入栈；
  96.      * 4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈； 5)将6入栈； 6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
  97.      */
  99.     public static int calculate(List<String> ls) {
  100.         // 创建给栈, 只需要一个栈即可
  101.         Stack<String> stack = new Stack<String>();
  102.         // 遍历 ls
  103.         for (String item : ls) {
  104.             // 这里使用正则表达式来取出数
  105.             if (item.matches("\\d+")) { // 匹配的是多位数
  106.                 // 入栈
  107.                 stack.push(item);
  108.             } else {
  109.                 // pop出两个数，并运算， 再入栈
  110.                 int num2 = Integer.parseInt(stack.pop());
  111.                 int num1 = Integer.parseInt(stack.pop());
  112.                 int res = 0;
  113.                 if (item.equals("+")) {
  114.                     res = num1 + num2;
  115.                 } else if (item.equals("-")) {
  116.                     res = num1 - num2;
  117.                 } else if (item.equals("*")) {
  118.                     res = num1 * num2;
  119.                 } else if (item.equals("/")) {
  120.                     res = num1 / num2;
  121.                 } else {
  122.                     throw new RuntimeException("运算符有误");
  123.                 }
  124.                 // 把res 入栈
  125.                 stack.push("" + res);
  126.             }
  128.         }
  129.         // 最后留在stack中的数据是运算结果
  130.         return Integer.parseInt(stack.pop());
  131.     }
  133. }
  135. //编写一个类 Operation 可以返回一个运算符 对应的优先级
  136. class Operation {
  137.     private static int LEFT_BRACKET  = 0;
  138.     private static int ADD = 1;
  139.     private static int SUB = 1;
  140.     private static int MUL = 2;
  141.     private static int DIV = 2;
  143.     // 写一个方法，返回对应的优先级数字
  144.     public static int getValue(String operation) {
  145.         int result = 0;
  146.         switch (operation) {
  147.         case "(":
  148.             result = LEFT_BRACKET;
  149.             break;
  150.         case "+":
  151.             result = ADD;
  152.             break;
  153.         case "-":
  154.             result = SUB;
  155.             break;
  156.         case "*":
  157.             result = MUL;
  158.             break;
  159.         case "/":
  160.             result = DIV;
  161.             break;
  162.         default:
  163.             System.out.println("不存在该运算符" + operation);
  164.             break;
  165.         }
  166.         return result;
  167.     }
  169. }

7、完整版逆波兰计算器

  1. public class ReversePolishMultiCalc {
  3.      /**
  4.      * 匹配 + - * / ( ) 运算符
  5.      */
  6.     static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";
  8.     static final String LEFT = "(";
  9.     static final String RIGHT = ")";
  10.     static final String ADD = "+";
  11.     static final String MINUS= "-";
  12.     static final String TIMES = "*";
  13.     static final String DIVISION = "/";
  15.     /**
  16.      * 加減 + -
  17.      */
  18.     static final int LEVEL_01 = 1;
  19.     /**
  20.      * 乘除 * /
  21.      */
  22.     static final int LEVEL_02 = 2;
  24.     /**
  25.      * 括号
  26.      */
  27.     static final int LEVEL_HIGH = Integer.MAX_VALUE;
  30.     static Stack<String> stack = new Stack<>();
  31.     static List<String> data = Collections.synchronizedList(new ArrayList<String>());
  33.     /**
  34.      * 去除所有空白符
  35.      * @param s
  36.      * @return
  37.      */
  38.     public static String replaceAllBlank(String s ){
  39.         // \\s+ 匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]
  40.         return s.replaceAll("\\s+","");
  41.     }
  43.     /**
  44.      * 判断是不是数字 int double long float
  45.      * @param s
  46.      * @return
  47.      */
  48.     public static boolean isNumber(String s){
  49.         Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
  50.         return pattern.matcher(s).matches();
  51.     }
  53.     /**
  54.      * 判断是不是运算符
  55.      * @param s
  56.      * @return
  57.      */
  58.     public static boolean isSymbol(String s){
  59.         return s.matches(SYMBOL);
  60.     }
  62.     /**
  63.      * 匹配运算等级
  64.      * @param s
  65.      * @return
  66.      */
  67.     public static int calcLevel(String s){
  68.         if("+".equals(s) || "-".equals(s)){
  69.             return LEVEL_01;
  70.         } else if("*".equals(s) || "/".equals(s)){
  71.             return LEVEL_02;
  72.         }
  73.         return LEVEL_HIGH;
  74.     }
  76.     /**
  77.      * 匹配
  78.      * @param s
  79.      * @throws Exception
  80.      */
  81.     public static List<String> doMatch (String s) throws Exception{
  82.         if(s == null || "".equals(s.trim())) throw new RuntimeException("data is empty");
  83.         if(!isNumber(s.charAt(0)+"")) throw new RuntimeException("data illeagle,start not with a number");
  85.         s = replaceAllBlank(s);
  87.         String each;
  88.         int start = 0;
  90.         for (int i = 0; i < s.length(); i++) {
  91.             if(isSymbol(s.charAt(i)+"")){
  92.                 each = s.charAt(i)+"";
  93.                 //栈为空，(操作符，或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈
  94.                 if(stack.isEmpty() || LEFT.equals(each)
  95.                         || ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)){
  96.                     stack.push(each);
  97.                 }else if( !stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())){
  98.                     //栈非空，操作符优先级小于等于栈顶优先级时出栈入列，直到栈为空，或者遇到了(，最后操作符入栈
  99.                     while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek()) ){
  100.                         if(calcLevel(stack.peek()) == LEVEL_HIGH){
  101.                             break;
  102.                         }
  103.                         data.add(stack.pop());
  104.                     }
  105.                     stack.push(each);
  106.                 }else if(RIGHT.equals(each)){
  107.                     // ) 操作符，依次出栈入列直到空栈或者遇到了第一个)操作符，此时)出栈
  108.                     while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())){
  109.                         if(LEVEL_HIGH == calcLevel(stack.peek())){
  110.                             stack.pop();
  111.                             break;
  112.                         }
  113.                         data.add(stack.pop());
  114.                     }
  115.                 }
  116.                 start = i ;    //前一个运算符的位置
  117.             }else if( i == s.length()-1 || isSymbol(s.charAt(i+1)+"") ){
  118.                 each = start == 0 ? s.substring(start,i+1) : s.substring(start+1,i+1);
  119.                 if(isNumber(each)) {
  120.                     data.add(each);
  121.                     continue;
  122.                 }
  123.                 throw new RuntimeException("data not match number");
  124.             }
  125.         }
  126.         //如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为/，栈底为+，应该依次出栈入列，可以直接翻转整个stack 添加到队列
  127.         Collections.reverse(stack);
  128.         data.addAll(new ArrayList<>(stack));
  130.         System.out.println(data);
  131.         return data;
  132.     }
  134.     /**
  135.      * 算出结果
  136.      * @param list
  137.      * @return
  138.      */
  139.     public static Double doCalc(List<String> list){
  140.         Double d = 0d;
  141.         if(list == null || list.isEmpty()){
  142.             return null;
  143.         }
  144.         if (list.size() == 1){
  145.             System.out.println(list);
  146.             d = Double.valueOf(list.get(0));
  147.             return d;
  148.         }
  149.         ArrayList<String> list1 = new ArrayList<>();
  150.         for (int i = 0; i < list.size(); i++) {
  151.             list1.add(list.get(i));
  152.             if(isSymbol(list.get(i))){
  153.                 Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));
  154.                 list1.remove(i);
  155.                 list1.remove(i-1);
  156.                 list1.set(i-2,d1+"");
  157.                 list1.addAll(list.subList(i+1,list.size()));
  158.                 break;
  159.             }
  160.         }
  161.         doCalc(list1);
  162.         return d;
  163.     }
  165.     /**
  166.      * 运算
  167.      * @param s1
  168.      * @param s2
  169.      * @param symbol
  170.      * @return
  171.      */
  172.     public static Double doTheMath(String s1,String s2,String symbol){
  173.         Double result ;
  174.         switch (symbol){
  175.             case ADD : result = Double.valueOf(s1) + Double.valueOf(s2); break;
  176.             case MINUS : result = Double.valueOf(s1) - Double.valueOf(s2); break;
  177.             case TIMES : result = Double.valueOf(s1) * Double.valueOf(s2); break;
  178.             case DIVISION : result = Double.valueOf(s1) / Double.valueOf(s2); break;
  179.             default : result = null;
  180.         }
  181.         return result;
  183.     }
  185.     public static void main(String[] args) {
  186.         //String math = "9+(3-1)*3+10/2";
  187.         String math = "12.8 + (2 - 3.55)*4+10/5.0";
  188.         try {
  189.             doCalc(doMatch(math));
  190.         } catch (Exception e) {
  191.             e.printStackTrace();
  192.         }
  193.     }
  195. }