栈
栈是一个 先入后出 (FILO-First In Last Out
)的 有序 列表
栈(stack)是限制线性表中元素的插入和删除,只能在线性表的同一端进行的一种特殊线性表。
允许插入和删除的一端,为变化的一端,称为栈顶(Top),另一端为固定的一端,称为栈底(Bottom)。
根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素刚好相反,最后放入的元素最先删除,最先放入的元素最后删除
栈的应用场景
- 子程序的调用:在跳往子程序前,会先将下个指令的地址存到堆栈中,直到子程序执行完后再将地址取出,以回到原来的程序中;
- 处理递归调用:和子程序的调用类似,只是除了储存下一个指令的地址外,也将参数、区域变量等数据存入堆栈中;
- 表达式的转换:[中缀表达式转后缀表达式]与求值(实际解决);
- 二叉树的遍历;
- 图形的深度优先(
depth first search
)搜索法。
数组模拟栈
实现栈的思路分析:
- 使用数组来模拟栈
- 定义一个
top
来表示栈顶,初始化为 − 1 -1 −1 - 入栈的操作,当有数据加入到栈时,
top++;
、stack[top] = data;
- 出栈的操作,
int value = stack[top];
、top--;
、return value;
代码实现
package data.structure.stack;
import java.util.Scanner;
public class ArrayStackDemo {
public static void main(String[] args) {
ArrayStack arrayStack = 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":
arrayStack.show();
break;
case "push":
System.out.println("请输入数据: ");
int value = scanner.nextInt();
arrayStack.push(value);
break;
case "pop":
try {
int res = arrayStack.pop();
System.out.println("栈顶元素为 : " + res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case "exit":
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出");
}
}
// 定义一个 ArrayStack 表示栈
class ArrayStack {
private int maxSize; // 栈的大小
private int[] stack; // 数组模拟栈,数据放到数组中
private int top = -1; // top 表示栈顶,初始化为 -1
// 构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
// 栈满
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 += 1;
stack[top] = value;
}
// 出栈
public int pop() {
if (isEmpty()) {
// 抛出异常带有返回,不需要 return
throw new RuntimeException("栈空");
}
int value = stack[top];
top -= 1;
return value;
}
// 遍历栈
public void show() {
// 从栈顶开始显示数据
if (isEmpty()) {
System.out.println("栈空");
return;
}
for (int i = top; i >= 0 ; i--) {
System.out.println("stack[" + i + "] = " + stack[i]);
}
}
}
栈实现综合计算器
对于一位数的运算
使用栈完成表达式的计算思路:
-
通过一个
index
值(索引),来遍历表达式 -
如果发现是一个数字, 就直接入数栈
-
如果发现扫描到是一个符号, 就分如下情况
- 如果发现 当前的符号栈为空,就直接入栈
- 如果 符号栈有操作符,就进行比较
- 如果当前的操作符的优先级 小于或者等于 栈中的操作符, 就需要从数栈中
pop
出两个数,在从符号栈中pop
出一个符号,进行运算,将得到结果,入数栈,然后将当前的操作符入符号栈; - 如果当前的操作符的优先级 大于 栈中的操作符, 就直接入符号栈
-
当表达式扫描完毕,就顺序的从数栈和符号栈中
pop
出相应的数和符号,并运行
(对于-
,用后面弹出的数减去先弹出的数;/
同理) -
最后在数栈只有一个数字,就是表达式的结果
验证: 3+2*6-2 = 13
从左向右扫描表达式,遇到数字 3 、 2 、 6 3、2、6 3、2、6 和符号 + 、 ∗ +、* +、∗ 都直接入栈即可
遇到符号
−
-
−,需要 pop
6
、
2
、
∗
6、2、*
6、2、∗ 进行运算,其结果再次压入数栈,然后将符号
−
-
− 也压入符号栈
因为表达式扫描结束,开始逐渐 pop
数字和符号进行运算,其结果再次压入数栈,直到符号栈中没有符号
代码示例
package data.structure.stack;
public class Calculator {
public static void main(String[] args) {
// 使用栈计算表达式 3 + 6 * 2 - 2 =
String expression = "9+6*2-2";
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
while (true) {
ch = expression.substring(index, index + 1).charAt(0);
if (operStack.isOper(ch)) { // 如果是运算符
if (!operStack.isEmpty()) { // 如果符号栈不为空
if (operStack.priority(ch) <= operStack.priority(operStack.head())) {
// 且当前操作符优先级 ≤ 栈顶操作符
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 { // 如果是数字 ASCII 码表,0=48
numStack.push(ch - 48);
}
index += 1;
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);
}
System.out.println("结果是 " + expression + " = " + numStack.pop());
}
}
// 定义一个 ArrayStack2 表示栈
class ArrayStack2 {
private int maxSize; // 栈的大小
private int[] stack; // 数组模拟栈,数据放到数组中
private int top = -1; // top 表示栈顶,初始化为 -1
// 构造器
public ArrayStack2(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
// 栈满
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 += 1;
stack[top] = value;
}
// 出栈
public int pop() {
if (isEmpty()) {
// 抛出异常带有返回,不需要 return
throw new RuntimeException("栈空");
}
int value = stack[top];
top -= 1;
return value;
}
// 遍历栈
public void show() {
// 从栈顶开始显示数据
if (isEmpty()) {
System.out.println("栈空");
return;
}
for (int i = top; i >= 0 ; i--) {
System.out.println("stack[" + i + "] = " + stack[i]);
}
}
// 获取栈顶的值,但是不出栈
public int head() {
return stack[top];
}
// 返回运算符的优先级(自己定义,使用数字表示,数字越大,优先级越高)
public int priority(int oper) {
if (oper == '*' || oper == '/') {
return 1;
} else if (oper == '+' || oper == '-') {
return 0;
} else { // 假定没有其他的运算符
return -1;
}
}
// 判断是否是运算符
public boolean isOper(char val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
// 计算方法
public int cal(int num1, int num2, int oper) {
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;
}
}
对于多位数的运算
当处理多位数时,不可以发现是数就入栈
需要向后继续查看,是否是数字
需要定义一个字符串变量,用于拼接多位数
代码示例
package data.structure.stack;
public class Calculator {
public static void main(String[] args) {
// 使用栈计算表达式 3 + 6 * 2 - 2 =
String expression = "90000+6000*2-200";
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 (true) {
ch = expression.substring(index, index + 1).charAt(0);
if (operStack.isOper(ch)) { // 如果是运算符
if (!operStack.isEmpty()) { // 如果符号栈不为空
if (operStack.priority(ch) <= operStack.priority(operStack.head())) {
// 且当前操作符优先级 ≤ 栈顶操作符
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);
// 当处理多位数时,不可以发现是数就入栈
// 需要向后继续查看,是否是数字
// 需要定义一个字符串变量,用于拼接多位数
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 += 1;
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);
}
System.out.println("结果是 " + expression + " = " + numStack.pop());
}
}
// 定义一个 ArrayStack2 表示栈
class ArrayStack2 {
private int maxSize; // 栈的大小
private int[] stack; // 数组模拟栈,数据放到数组中
private int top = -1; // top 表示栈顶,初始化为 -1
// 构造器
public ArrayStack2(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
// 栈满
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 += 1;
stack[top] = value;
}
// 出栈
public int pop() {
if (isEmpty()) {
// 抛出异常带有返回,不需要 return
throw new RuntimeException("栈空");
}
int value = stack[top];
top -= 1;
return value;
}
// 遍历栈
public void show() {
// 从栈顶开始显示数据
if (isEmpty()) {
System.out.println("栈空");
return;
}
for (int i = top; i >= 0 ; i--) {
System.out.println("stack[" + i + "] = " + stack[i]);
}
}
// 获取栈顶的值,但是不出栈
public int head() {
return stack[top];
}
// 返回运算符的优先级(自己定义,使用数字表示,数字越大,优先级越高)
public int priority(int oper) {
if (oper == '*' || oper == '/') {
return 1;
} else if (oper == '+' || oper == '-') {
return 0;
} else { // 假定没有其他的运算符
return -1;
}
}
// 判断是否是运算符
public boolean isOper(char val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
// 计算方法
public int cal(int num1, int num2, int oper) {
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;
}
}
前缀、中缀、后缀表达式
前缀表达式(波兰表达式)
前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前
举例说明:
(
3
+
4
)
×
5
−
6
(3+4)×5-6
(3+4)×5−6 对应的前缀表达式就是 - × + 3 4 5 6
前缀表达式的计算机求值
从 右至左扫描表达式,
遇到数字时,将数字压入堆栈;
遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 和 次顶元素),并将结果入栈;
重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果
例如:
(
3
+
4
)
×
5
−
6
(3+4)×5-6
(3+4)×5−6 对应的前缀表达式就是 - × + 3 4 5 6
, 针对前缀表达式求值步骤如下:
- 从右至左扫描,将 6 、 5 、 4 、 3 6、5、4、3 6、5、4、3 压入堆栈
- 遇到
+
运算符,因此弹出 3 3 3 和 4 4 4( 3 3 3 为栈顶元素, 4 4 4 为次顶元素),计算出 3 + 4 3+4 3+4 的值,得 7 7 7 ,再将 7 7 7 入栈 - 接下来是 × × × 运算符,因此弹出 7 7 7 和 5 5 5,计算出 7 × 5 = 35 7×5=35 7×5=35,将 35 35 35 入栈
- 最后是 − - − 运算符,计算出 35 − 6 35-6 35−6 的值,即 29 29 29,由此得出最终结果
中缀表达式
中缀表达式就是常见的运算表达式,如 ( 3 + 4 ) × 5 − 6 (3+4)×5-6 (3+4)×5−6
中缀表达式的求值是我们人最熟悉的,但是对计算机来说却不好操作
因此,在计算结果时,往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式.)
后缀表达式
后缀表达式又称逆波兰表达式,与前缀表达式相似,只是运算符位于操作数之后
中举例说明:
(
3
+
4
)
×
5
−
6
(3+4)×5-6
(3+4)×5−6 对应的后缀表达式就是 3 4 + 5 × 6 –
再比如:
后缀表达式的计算机求值
从 左至右扫描表达式,
遇到数字时,将数字压入堆栈,
遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 和 栈顶元素),并将结果入栈;
重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果
例如:
(
3
+
4
)
×
5
−
6
(3+4)×5-6
(3+4)×5−6 对应的后缀表达式就是 3 4 + 5 × 6 -
, 针对后缀表达式求值步骤如下:
- 从左至右扫描,将 3 3 3 和 4 4 4 压入堆栈;
- 遇到 + + + 运算符,因此弹出 4 4 4 和 3 3 3( 4 4 4 为栈顶元素, 3 3 3 为次顶元素),计算出 3 + 4 3+4 3+4 的值,得 7 7 7,再将 7 7 7 入栈;
- 将 5 5 5 入栈;
- 接下来是 × × × 运算符,因此弹出 5 5 5 和 7 7 7,计算出 7 × 5 = 35 7×5=35 7×5=35,将 35 35 35 入栈;
- 将 6 6 6 入栈;
- 最后是 − - − 运算符,计算出 35 − 6 35-6 35−6 的值,即 29 29 29,由此得出最终结果
逆波兰计算器
输入一个逆波兰表达式(后缀表达式),使用栈(stack
),计算其结果;要求支持小括号和多位数整数
代码示例
package data.structure.stack;
import java.util.*;
public class PolandNotation {
public static void main(String[] args) {
// 定义逆波兰表达式 (30+4)*5-6 => 30 4 + 5 * 6 -
// 使用空格把数字和符号隔开(可以不分割)
String suffixExpression = "30 4 + 5 * 6 -";
// 将 “3 4 + 5 * 6 -" 放到 ArrayList 中
// 将 ArrayList 传递给一个方法,遍历 ArrayList 配合栈,完成计算
List<String> rpnList = getListString(suffixExpression);
int res = calculate(rpnList);
System.out.println("计算结果是 = " + res);
}
public static List<String> getListString(String suffixExpression) {
String[] split = suffixExpression.split(" ");
List<String> list = new ArrayList<String>();
for (String ele: split) {
list.add(ele);
}
return list;
}
public static int calculate(List<String> ls) {
// 创建栈
Deque<String> stack = new ArrayDeque<String>();
// 遍历 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 = num1 / num2;
} else {
throw new RuntimeException("运算符有误");
}
stack.push(res + "");
}
}
// stack 中最后的数据就是运算结果
return Integer.parseInt(stack.pop());
}
}
中缀表达式转后缀表达式
后缀表达式适合计算式进行运算,但是人却不太容易写出来,尤其是表达式很长的情况下,因此在开发中,需要将 中缀表达式转成后缀表达式。
具体步骤如下:
- 初始化两个栈:运算符栈
s1
和 储存中间结果的栈s2
; - 从 左至右 扫描中缀表达式;
- 遇到 操作数 时,将其压
s2
; - 遇到 运算符 时,比较其与
s1
栈顶运算符的优先级:- 如果
s1
为空,或栈顶运算符为左括号“(
”,则直接将此运算符入栈; - 若优先级比栈顶运算符的高,也将运算符压入
s1
; - 否则,将
s1
栈顶的运算符弹出并压入到s2
中,再次转到 (4.1) 与s1
中新的栈顶运算符相比较;
- 如果
- 遇到括号时:
- 如果是左括号“
(
”,则直接压入s1
- 如果是右括号“
)
”,则依次弹出s1
栈顶的运算符,并压入s2
,直到遇到左括号为止,此时将这一对括号丢弃
- 如果是左括号“
- 重复步骤 2 至 5,直到表达式的最右边
- 将
s1
中剩余的运算符依次弹出并压入s2
- 依次弹出
s2
中的元素并输出,结果的逆序 即为中缀表达式对应的后缀表达式
示例:
中缀表达式:
1
+
(
(
2
+
3
)
×
4
)
−
5
1 + ( ( 2 + 3 )× 4) - 5
1+((2+3)×4)−5
后缀表达式:1 2 3 + 4 * + 5 -
代码示例
package data.structure.stack;
import org.w3c.dom.ls.LSInput;
import java.util.*;
import java.util.spi.AbstractResourceBundleProvider;
public class PolandNotation {
public static void main(String[] args) {
// 完成将一个中缀表达式转成后缀表达式的功能
// 1+((2+3)*4)-5 => 1 2 3 + 4 * + 5 -
String expression = "1+((2+3)*4)-5";
List<String> ListString = toInfixExpressionList(expression);
System.out.println(ListString);
List<String> ListString2 = parseSuffixExpressionList(ListString);
System.out.println(ListString2);
int result = calculate(ListString2);
System.out.println(result);
// 定义逆波兰表达式 (30+4)*5-6 => 30 4 + 5 * 6 -
// 使用空格把数字和符号隔开(可以不分割)
String suffixExpression = "30 4 + 5 * 6 -";
// 将 “3 4 + 5 * 6 -" 放到 ArrayList 中
// 将 ArrayList 传递给一个方法,遍历 ArrayList 配合栈,完成计算
List<String> rpnList = getListString(suffixExpression);
int res = calculate(rpnList);
System.out.println("计算结果是 = " + res);
}
// 将中缀表达式转成对应的 list
public static List<String> toInfixExpressionList(String s) {
List<String> ls = new ArrayList<String>();
int i = 0; // 指针,遍历中缀表达式
String str; // 对多位数的拼接
char c; // 每遍历一个字符,就放到 c
do {
// 如果 c 是一个 非数字,则放到 ls 中
if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
ls.add("" + c);
i += 1;
} else { // 如果是一个数,则需要考虑是否是一个多位数
str = "";
while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
str += c;
i += 1;
}
ls.add(str);
}
} while (i < s.length());
return ls;
}
// 将中缀表达式的 list 转成 后缀表达式的 list
public static List<String> parseSuffixExpressionList(List<String> ls) {
// 定义一个符号栈
Deque<String> s1 = new ArrayDeque<String>();
// s2 在实际中,并不需要pop数据,并且需要逆序输出,所以可以用 list 代替
List<String> s2 = new ArrayList<String>();
// 遍历 ls
for (String item: ls) {
// 如果是一个数,加入 s2
if (item.matches("\\d+")) { // 匹配多位数
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.pop(); // 将 左括号( 弹出,消除小括号
} else { // 对于 item 是运算符的情况
// 当 item 优先级 ≤ s1 栈顶运算符,弹出 s1 栈顶运算符,并加入到 s2
// 再次与 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());
}
// 因为 s2 是 list,所以不需要逆序输出就是后缀表达式
return s2;
}
// 分割后缀表达式,从 String 到 List<String>
public static List<String> getListString(String suffixExpression) {
String[] split = suffixExpression.split(" ");
List<String> list = new ArrayList<String>();
for (String ele: split) {
list.add(ele);
}
return list;
}
// 计算后缀表达式
public static int calculate(List<String> ls) {
// 创建栈
Deque<String> stack = new ArrayDeque<String>();
// 遍历 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());
}
}
// 编写一个类 Operation,可以返回一个运算符对应的优先级
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) {
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("不存在该运算符");
break;
}
return result;
}
}
其他代码
中缀转后缀代码2
package com.atguigu.reversepolishcal;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class ReversePolishCalCase {
public static void main(String[] args) {
//举例1: 2 + (3-4) => 2 3 4 - +
//举例2: 4 * 5 - 8 + 60 + 8 / 2 = 4 5 * 8 - 60 + 8 2 / +
//举例3: (3+4)×5-6 => 3 4 + 5 * 6 -
//String suffixExperss = "4 5 * 8 - 60 + 8 2 / +";
//String suffixExperss = "2 3 4 - +";
//String suffixExperss = "3 4 + 5 * 6 -";
//
ReversePolishCal reversePolishCal = new ReversePolishCal();
//
//List <String> suffixExpressionList = reversePolishCal.getListBySuffixExpression(suffixExperss);
//
// System.out.println("计算结果:"+ reversePolishCal.calculate(suffixExpressionList));
//测试输入中缀表达式是否能计算成功
String infixExpression = "4*5-8+60+8/2";
List<String> infixExpressionList = reversePolishCal.toInfixExpression(infixExpression);
List<String> suffixExpressionList2 = reversePolishCal.parseSuffixExpression(infixExpressionList);
//输出后缀表达式
for(String ele : suffixExpressionList2) {
System.out.print(ele + " ");
}
System.out.println();
//输出结果
System.out.println("计算结果:"+ reversePolishCal.calculate(suffixExpressionList2));
}
}
class ReversePolishCal {
/**
* 把字符串转换成中序表达式 : 比如 2+(3-4), 并放入到 List 中
* @param s
* @return
*/
public List<String> toInfixExpression(String infixExpression) {
List<String> ls = new ArrayList<String>();//存储中序表达式
int i = 0;
String str;
char c;
do {
//如果c 在 < 48 或者 > 57 说明是符号, 这里没有判断是 + , - , * , / 等等
if ((c = infixExpression.charAt(i)) < 48 || (c = infixExpression.charAt(i)) > 57) {
ls.add("" + c);
i++;
} else { // 说明是数字,要进行拼接处理
str = "";
while (i < infixExpression.length() && (c = infixExpression.charAt(i)) >= 48
&& (c = infixExpression.charAt(i)) <= 57) {
str += c;
i++;
}
ls.add(str);
}
} while (i < infixExpression.length());
return ls;
}
/**
* 将一个中缀表达式对应的 List 转成 转换成逆波兰表达式, 放入到 List 中
* @param ls
* @return
*/
public List<String> parseSuffixExpression(List<String> ls) {
Stack<String> s1=new Stack<String>();
Stack<String> s2=new Stack<String>();
List<String> lss = new ArrayList<String>();
for (String ss : ls) {
if (ss.matches("\\d+")) {
lss.add(ss);
} else if (ss.equals("(")) {
s1.push(ss);
} else if (ss.equals(")")) {
while (!s1.peek().equals("(")) {
lss.add(s1.pop());
}
s1.pop();
} else {
while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(ss)) {
lss.add(s1.pop());
}
s1.push(ss);
}
}
while (s1.size() != 0) {
lss.add(s1.pop());
}
return lss;
}
//将一个后缀表达式,依次放入到 List<String> 中
public List<String> getListBySuffixExpression(String suffixExpression) {
String[] split = suffixExpression.split(" ");
List<String> list = new ArrayList<String>();
for (String element : split) {
list.add(element);
}
return list;
}
/**
* @param ls 是一个按照逆波兰表达式得到 List
* @return
*/
public int calculate(List<String> ls) {
Stack<String> s=new Stack<String>();
for (String str : ls) {
if (str.matches("\\d+")) {
s.push(str);
} else {
int b = Integer.parseInt(s.pop());
int a = Integer.parseInt(s.pop());
int result=0;
if (str.equals("+")) {
result = a + b;
} else if (str.equals("-")) {
result = a - b;
} else if (str.equals("*")) {
result = a * b;
} else if (str.equals("/")) {
result = a / b;
} else {
throw new RuntimeException("符号错误");
}
s.push("" + result);
}
}
//System.out.println(s.peek());
return Integer.parseInt(s.pop());
}
}
class Operation {
private static int ADDITION=1;
private static int SUBTRACTION=1;
private static int MULTIPLICATION=2;
private static int DIVISION=2;
public static int getValue(String operation){
int result;
switch (operation){
case "+":
result=ADDITION;
break;
case "-":
result=SUBTRACTION;
break;
case "*":
result=MULTIPLICATION;
break;
case "/":
result=DIVISION;
break;
default:
// System.out.println("不存在该运算符");
result=0;
}
return result;
}
}
逆波兰计算器增强版
完整版的逆波兰计算器,功能包括
支持 + - * / ( )
多位数,支持小数,
兼容处理, 过滤任何空白字符,包括空格、制表符、换页符
package com.atguigu.reversepolishcal;
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();
}
}
}