能够支持多位数

分析思路

  1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
  2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
  3. 因此我们需要定义一个变量 字符串，用于拼接 ``` package com.atguigu.stack;

/**

  • ClassName:
  • Description:
  • Date: 2021-02-20 14:02
  • @project data_algorithm
  • @package com.atguigu.stack */ public class Calculator {
  1. public static void main(String[] args) {
  2.     //根据前面老师思路，完成表达式的运算
  3.     String expression = "7*2*2-5+1-5+3-4"; // 15//如何处理多位数的问题？
  4.     //创建两个栈，数栈，一个符号栈
  5.     ArrayStack2 numStack = new ArrayStack2(10);
  6.     ArrayStack2 operStack = new ArrayStack2(10);
  7.     //定义需要的相关变量
  8.     int index = 0;//用于扫描
  9.     int num1 = 0;
  10.     int num2 = 0;
  11.     int oper = 0;
  12.     int res = 0;
  13.     char ch = ' '; //将每次扫描得到char保存到ch
  14.     String keepNum = ""; //用于拼接 多位数
  15.     //开始while循环的扫描expression
  16.     while(true) {
  17.         //依次得到expression 的每一个字符
  18.         ch = expression.substring(index, index+1).charAt(0);
  19.         //判断ch是什么，然后做相应的处理
  20.         if(operStack.isOper(ch)) {//如果是运算符
  21.             //判断当前的符号栈是否为空
  22.             if(!operStack.isEmpty()) {
  23.                 //如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
  24.                 //在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
  25.                 if(operStack.priority(ch) <= operStack.priority(operStack.peek())) {
  26.                     num1 = numStack.pop();
  27.                     num2 = numStack.pop();
  28.                     oper = operStack.pop();
  29.                     res = numStack.cal(num1, num2, oper);
  30.                     //把运算的结果如数栈
  31.                     numStack.push(res);
  32.                     //然后将当前的操作符入符号栈
  33.                     operStack.push(ch);
  34.                 } else {
  35.                     //如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
  36.                     operStack.push(ch);
  37.                 }
  38.             }else {
  39.                 //如果为空直接入符号栈..
  40.                 operStack.push(ch); // 1 + 3
  41.             }
  42.         } else { //如果是数，则直接入数栈
  44.             //numStack.push(ch - 48); //? "1+3" '1' => 1
  45.             //分析思路
  46.             //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
  47.             //2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
  48.             //3. 因此我们需要定义一个变量 字符串，用于拼接
  50.             //处理多位数
  51.             keepNum += ch;
  53.             //如果ch已经是expression的最后一位，就直接入栈
  54.             if (index == expression.length() - 1) {
  55.                 numStack.push(Integer.parseInt(keepNum));
  56.             }else{
  58.                 //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
  59.                 //注意是看后一位，不是index++
  60.                 if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) {
  61.                     //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
  62.                     numStack.push(Integer.parseInt(keepNum));
  63.                     //重要的!!!!!!, keepNum清空
  64.                     keepNum = "";
  66.                 }
  67.             }
  68.         }
  69.         //让index + 1, 并判断是否扫描到expression最后.
  70.         index++;
  71.         if (index >= expression.length()) {
  72.             break;
  73.         }
  74.     }
  76.     //当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
  77.     while(true) {
  78.         //如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
  79.         if(operStack.isEmpty()) {
  80.             break;
  81.         }
  82.         num1 = numStack.pop();
  83.         num2 = numStack.pop();
  84.         oper = operStack.pop();
  85.         res = numStack.cal(num1, num2, oper);
  86.         numStack.push(res);//入栈
  87.     }
  88.     //将数栈的最后数，pop出，就是结果
  89.     int res2 = numStack.pop();
  90.     System.out.printf("表达式 %s = %d", expression, res2);
  91. }

}

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

  1. //构造器
  2. public ArrayStack2(int maxSize) {
  3.     this.maxSize = maxSize;
  4.     stack = new int[this.maxSize];
  5. }
  7. //增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
  8. public int peek() {
  9.     return stack[top];
  10. }
  12. //栈满
  13. public boolean isFull() {
  14.     return top == maxSize - 1;
  15. }
  16. //栈空
  17. public boolean isEmpty() {
  18.     return top == -1;
  19. }
  20. //入栈-push
  21. public void push(int value) {
  22.     //先判断栈是否满
  23.     if(isFull()) {
  24.         System.out.println("栈满");
  25.         return;
  26.     }
  27.     top++;
  28.     stack[top] = value;
  29. }
  30. //出栈-pop, 将栈顶的数据返回
  31. public int pop() {
  32.     //先判断栈是否空
  33.     if(isEmpty()) {
  34.         //抛出异常
  35.         throw new RuntimeException("栈空，没有数据~");
  36.     }
  37.     int value = stack[top];
  38.     top--;
  39.     return value;
  40. }
  41. //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  42. public void list() {
  43.     if(isEmpty()) {
  44.         System.out.println("栈空，没有数据~~");
  45.         return;
  46.     }
  47.     //需要从栈顶开始显示数据
  48.     for(int i = top; i >= 0 ; i--) {
  49.         System.out.printf("stack[%d]=%d\n", i, stack[i]);
  50.     }
  51. }
  52. //返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
  53. //数字越大，则优先级就越高.
  54. public int priority(int oper) {
  55.     if(oper == '*' || oper == '/'){
  56.         return 1;
  57.     } else if (oper == '+' || oper == '-') {
  58.         return 0;
  59.     } else {
  60.         return -1; // 假定目前的表达式只有 +, - , * , /
  61.     }
  62. }
  63. //判断是不是一个运算符
  64. public boolean isOper(char val) {
  65.     return val == '+' || val == '-' || val == '*' || val == '/';
  66. }
  67. //计算方法
  68. public int cal(int num1, int num2, int oper) {
  69.     int res = 0; // res 用于存放计算的结果
  70.     switch (oper) {
  71.     case '+':
  72.         res = num1 + num2;
  73.         break;
  74.     case '-':
  75.         res = num2 - num1;// 注意顺序
  76.         break;
  77.     case '*':
  78.         res = num1 * num2;
  79.         break;
  80.     case '/':
  81.         res = num2 / num1;
  82.         break;
  83.     default:
  84.         break;
  85.     }
  86.     return res;
  87. }

}

```