计算器的实现
计算器的实现基础是用栈的先进后出的特性的,将中缀表达式转换成后缀表达式后,对后缀表达式进行操作运算就会方便很多,而中缀表达式就是我们人类经常看到的表达式,例如(3+4)×5-6这就是中缀表达式,而后缀表达式就是相比于人来说,机器更容易看懂的表达式,例如(3+4)×5-6的后缀表达式是:3 4 + 5 * 6 -
可以参考:前缀,中缀和后缀表达式_Land-Cruise的博客-CSDN博客
后缀表达式实现计算器
步骤
1.初始化两个栈:运算符栈s1和储存中间结果的栈 s2(实际中可以用链表,后续栈还需要翻转,而链表不需要)
2.从左至右扫描中缀表达式
3.遇到操作数时,将其压s2
4.遇到运算符时,比较其与s1栈顶运算符的优先级:
1)如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈
2)否则,若优先级比栈顶运算符的高,也将运算符压入s1
3)否则,将s1栈顶的运算符弹出并压入到s2中,再次转到(4-1)与s1中新的栈顶运算符相比较
5.遇到括号时:
1) 如果是左括号“(”,则直接压入s1
2) 如果是右括号“)”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃
6.重复步骤2至5,直到表达式的最右边
7.将s1中剩余的运算符依次弹出并压入s2
8.依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式
例如:
将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下
代码实现
package com.datestructures.stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static void main(String[] args) {
//逆波兰计算器
//先定义给逆波兰表达式
//(3+4)×5-6 =>3 4 + 5 * 6 - =>29
/*String s1 = "30 4 + 5 * 6 -";//给定一个逆波兰表达式
String s = "4 5 * 8 - 60 + 8 2 / +";
List<String> list = getListString(s);
int res = calculat(list);
System.out.println("计算结果为"+res);*/
String s = "(3+4)*5-6";
List<String> list = stringTolist(s);
System.out.println(list);
List<String> list1 = midTorear(list);
System.out.println(list1);
int res = calculat(list1);
System.out.println("计算结果为"+res);
}
//将中缀的list转为后缀表达式
public static List<String> midTorear(List<String> list) {
/**
* 1.初始化两个栈:运算符栈s1和储存中间结果的栈s2;
* 2.从左至右扫描中缀表达式;
* 3.遇到操作数时,将其压s2;
* 4.遇到运算符时,比较其与s1栈顶运算符的优先级:
* 4.1如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
* 4.2否则,若优先级比栈顶运算符的高,也将运算符压入s1;
* 4.3否则,将s1栈顶的运算符弹出并压入到s2中,再次转到(4-1)与s1中新的栈顶运算符相比较
* 5.遇到括号时:
* (1) 如果是左括号“(”,则直接压入s1
* (2) 如果是右括号“)”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃
* 6.重复步骤2至5,直到表达式的最右边
* 7.将s1中剩余的运算符依次弹出并压入s2
* 8.依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式
*/
Stack<String> stack = new Stack<>();//符号栈
List<String> list1 = new ArrayList<>();//存储中间结果的list
for (String item : list) {
if (item.matches("\\d+")) {//如果是一个数,直接加入list1
list1.add(item);
} else if (item.equals("(")) {
stack.add(item);
} else if (item.equals(")")) {
while (!stack.peek().equals("(")) {
list1.add(stack.pop());
}
stack.pop();
} else {
while (stack.size() != 0 && priority(item) <= priority(stack.peek())) {
list1.add(stack.pop());
}
stack.push(item);
}
}
while (stack.size() != 0) {
list1.add(stack.pop());
}
return list1;
}
//判断符号的优先级
public static int priority(String oper) {
if (oper.equals("*") || oper.equals("/")) {
return 1;
} else if (oper.equals("-") || oper.equals("+")) {
return 0;
} else {
return -1;
}
}
//将中缀表达式转成相应的list
public static List<String> stringTolist(String s) {
List<String> list = new ArrayList<>();
int index = 0;//这是指针,用于字符串遍历
String str;//处理多位数
char c;//每遍历一个字符就存放在c中
do {
;//取一个字符
if (s.charAt(index) < 48 || s.charAt(index) > 57) {//非数字
list.add(s.charAt(index) + "");
index++;
} else {//数字
str = "";//将多位数置空
while (index < s.length() && 48 <= s.charAt(index) && s.charAt(index) <= 57) {//多位数
str += s.charAt(index);
index++;
}
list.add(str);
}
} while (index < s.length());
return list;
}
//将字符串转换为链表,方便增删
public static List<String> getListString(String s) {
//将逆波兰表达式分割
String[] strings = s.split(" ");
List<String> list = new ArrayList<>();
//再将字符串组放入链表中
for (String item : strings) {
list.add(item);
}
return list;
}
//用于计算的
public static int calculat(List<String> list) {
/**
* 从左至右扫描,将3和4压入堆栈;
* 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素),计算出3+4的值,得7,再将7入栈;
* 将5入栈;
* 接下来是×运算符,因此弹出5和7,计算出7×5=35,将35入栈;
* 将6入栈;
* 最后是-运算符,计算出35-6的值,即29,由此得出最终结果
*/
//创建一个栈,这里只需要一个栈就行了
Stack<String> stack = new Stack<>();
//遍历list
for (String item : list) {
//如果是数字 入栈
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();
}
stack.push(res + "");
}
}
return Integer.parseInt(stack.pop());
}
}