开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第33天，点击查看活动详情
前缀表达式
规则：
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们进行相应的计算（栈顶元素和次顶元素进行计算），并将结果入数栈；重复上述过程，直至表达式最左端，最后运算得出的值即为表达式的结果。
例如：(3 + 4) * 5 - 6 对应的前缀表达式是 - * + 3 4 5 6
针对前缀表达式求值步骤如下：
（1）从右至左进行扫描，将6、5、4、3压入堆栈。
（2）遇到 + 运算符时，弹出3和4（3为栈顶元素，4位次顶元素），计算出3 + 4 的值，再将得到的值7入栈（此时7位栈顶）。
（3）然后遇到 * 运算符，所以要弹出7和5（7为栈顶元素，5为次顶元素），计算出7 * 5的值，再将得到的值35如栈（此时35为栈顶）。
（4）最后遇到 - 运算符，弹出35和6（35为栈顶元素，6为次顶元素），计算出35 - 6 的值，得到最后结果为29。
中缀表达式
中缀表达式是最常见的运算表达式，如(3 + 4) * 5 - 6
中缀表达式的求值是我们最熟悉的，但是对计算机来说却不好操作。因此，在计算结果时，往往会将中缀表达式转换为其他表达式来操作（一般转换为后缀表达式）
后缀表达式
后缀表达式又称为逆波兰表达式，与前缀表达式相似，知识运算符位于操作数之后。
规则：
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们进行相应的计算（次顶元素和栈顶元素进行计算），并将结果入数栈；重复上述过程，直至表达式最右端，最后运算得出的值即为表达式的结果。
例如：(3 + 4) * 5 - 6 对应的后缀表达式是3 4 + 5 * 6 -
针对后缀表达式求值步骤如下：
（1）从左至右进行扫描，将3和4压入堆栈。
（2）遇到 + 运算符，因此弹出4和3（4位次顶元素，3为栈顶元素），计算出3 + 4 的值，再将得到的值7入栈（此时7位栈顶）。
（3）将5入栈。
（4）然后遇到 * 运算符，因此弹出5和7，计算7 * 5 的值，然后将值35入栈。
（5）将6入栈。
（6）最后遇到 - 运算符，计算出35 - 6 的值，得到最后结果为29。
栈实现综合计算器计算思路
（1）通过一个 index 值（索引），来遍历我们的表达式
（2）如果发现是一个数字，就直接入数栈
（3）如果发现扫描到是一个符号，就分如下情况
1）如果发现当前的符号栈为空，就直接入栈
2）如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈顶的操作符，
就需要从数栈中pop出两个数据，再从符号栈中pop出一个符号，进行计算，得到结果，入数栈，
然后将当前的操作符入符号栈，如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈。
（4）当表达式扫描完毕，就按顺序从数栈和符号栈中pop出相应的数和符号，并运行
（5）最后在数栈只有一个数字，就是表达式的结果
扩展学习
substring表示用来截取字符串
（1）substring(0 , 2)表示截取两个两个字符，第一个和第二个
（2）substring(2)表示截取掉前两个字符，获得后边的字符串
编写ArrayStack2类，表示栈
class ArrayStack2 {
private int maxSize;//栈的大小
private int[] stack;//用数组模拟栈，将数据放到数组中
private int top = -1;//表示栈顶，默认值为 -1
public ArrayStack2(int maxSize) {
this.maxSize = maxSize;
stack = new int[maxSize];
}
//栈满
public boolean isFull() {
return top == maxSize - 1;
}
//栈空
public boolean isEmpty() {
return top == -1;
}
//入栈-push
public void push(int value) {
//先判断栈是否为满
if(isFull()) {
System.out.println("栈满");
return;
}
stack[++top] = value;
}
//出栈-pop，将栈顶的数据返回
public int pop() {
//先判断栈是否为空
if(isEmpty()) {
// System.out.println("栈空");
// return;
// 因为有返回值，所以不能用这种返回的方式
throw new RuntimeException("栈空，没有数据");
}
int value = stack[top--];
return value;
}
//显示栈的情况（遍历栈），遍历时，需要从栈顶开始显示数据
public void list() {
//判断栈是否为空
if(isEmpty()) {
System.out.println("栈空");
return;
}
//从栈顶开始显示数据
for (int i = top; i >= 0; i--) {
System.out.printf("stack[%d] = %d\n",i,stack[i]);
}
}
//判断字符是否为加减乘除
public boolean isOperator(char val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
//返回运算符的优先级，优先级的表示是自定的，这里我们使用数字表示
public int priority(int operator) {
if(operator == '*' || operator == '/') {
return 1;
} else if(operator == '+' || operator == '-') {
return 0;
} else {
return -1;
}
}
//计算方法
public int calculation(int num1 , int num2 , int operator) {
int result = 0;
switch (operator) {
case '+':
result = num1 + num2;
break;
case '-':
result = num2 - num1;//注意顺序
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num2 / num1;
break;
default:
break;
}
return result;
}
//增加一个方法，用来查看当前栈顶的值，但不是真正的pop
public int peek() {
return stack[top];
}
}
编写Calculator类，进行演示
import java.util.Scanner;
public class Calculator {
public static void main(String[] args) {
//输入表达式
Scanner scanner = new Scanner(System.in);
System.out.println("请输入表达式：");
String expression = scanner.nextLine();
// String expression = "4+8-2";
//创建两个栈，分别存放数据和符号
ArrayStack2 numberStack = new ArrayStack2(10);
ArrayStack2 operatorStack = new ArrayStack2(10);
//定义相关变量
int num1 = 0;
int num2 = 0;
int index = 0;//用于扫描
int result = 0;
int operator = 0;
String keepNumber = "";
char ch = ' ';//每次扫描得到的字符存放到ch中
//开始while循环扫描expression
while(true) {
//依次得到expression的每一个字符
ch = expression.substring(index , index + 1).charAt(0);//截取
//判断ch是数字还是符号，并做出响应操作
if(operatorStack.isOperator(ch)) {
//先判断符号栈是否为空，然后进行操作
if(operatorStack.isEmpty()){
//如果此栈为空，就直接入符号栈
operatorStack.push(ch);
} else {
//如果此栈不为空，其中含有操作符，则要进行比较
/*
如果当前的操作符的优先级小于或者等于栈顶的操作符，
就需要从数栈中pop出两个数据，再从符号栈中pop出一个符号，
进行计算，得到结果，入数栈，然后将当前的操作符入符号栈
*/
if(operatorStack.priority(ch) <= operatorStack.priority(operatorStack.peek())) {
num1 = numberStack.pop();
num2 = numberStack.pop();
operator = operatorStack.pop();
result = numberStack.calculation(num1 , num2 , operator);
//将运算后的结果入栈
numberStack.push(result);
//将当前的操作符入符号栈
operatorStack.push(ch);
} else {
//如果当前的操作符的优先级大于栈中的操作符，就直接入栈
operatorStack.push(ch);
}
}
} else {
//如果是数，则直接入数栈
// numberStack.push(ch - 48);//因为ch此时是字符型
/*
当处理多位数时的思路：
1、当处理多位数时，不能发现是一个数就直接入栈，因为他可能是多位数
2、在处理数，需要向expression的表达式的 index 后再看一位，如果是数，就进行扫描
如果是符合才入栈
3、因此需要定义一 个变量字符串，用于拼接
*/
keepNumber += ch;//处理多位数的变量
//如果ch以及是expression的最后一位，就直接入栈
if(index == expression.length() - 1) {
numberStack.push(Integer.parseInt(keepNumber));
} else {
//判断下一位字符是不是数字，如果是数字，就要继续扫描，如果是运算符，就入栈
//是查看下一位，并不是index+++
if(operatorStack.isOperator(expression.substring(index + 1 , index + 2).charAt(0))) {
//如果最后一位是运算符，则入栈
//注意此时keepNumber等于"1"或者"123"，是字符串
numberStack.push(Integer.parseInt(keepNumber));
//注意！！！！！！！！！
//此时需要将keepNumber清空
keepNumber = "";
}
}
}
//让index + 1，并判断是否扫描到expression最后
if(++index >= expression.length()) {
break;
}
}
//当表达式扫描完毕后，就按顺序从数栈中pop出相应的数字和字符，进行运算
while(true) {
//如果符号栈为空，则代表计算到了最后的一个结果，数字栈中的栈顶就是结果
if(operatorStack.isEmpty()) {
break;
}
num1 = numberStack.pop();
num2 = numberStack.pop();
operator = operatorStack.pop();
result = numberStack.calculation(num1 , num2 , operator);
numberStack.push(result);//将计算结果入栈
}
System.out.printf("表达式%s = %d" , expression , numberStack.pop());
}
}
