1 前缀表达式计算
从右到左扫描表达式，遇到数字，就把数字压入栈中，遇到运算符时，弹出栈顶的两个数，用于运算符对它们做相应的计算，并将结果入栈，重复上述操作直到表达式最左端，最后算出的值即为表达式的值（栈最后就剩一个元素，这个元素就是结果 ）
注意这是从右往左进行便利的，所以在运算时先弹出的数在前。
代码参照后面后缀表达式代码
2 后缀表达式计算
从左到右扫描表达式，遇到数字，就把数字压入栈中，遇到运算符时，弹出栈顶的两个数，用于运算符对它们做相应的计算，并将结果入栈，重复上述操作直到表达式最右端，最后算出的值即为表达式的值（栈最后就剩一个元素，这个元素就是结果 ）
注意这是从左往右进行便利的，所以在运算时后弹出的数在前
代码：一个后缀表达式计算器
package Stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
//逆序表达式计算器
public class PolandNotation {
public static void main(String[] args) {
//给出逆波兰表达式
String suffixExpression = "3 4 + 5 * 6 -";
//为了方便用空格隔开
// 1 先将suffixExpression 放入ArrayList
// 2 将ArrayList传递给一个方法，遍历ArrayList 配合栈完成计算
List<String> rpnList = getListString(suffixExpression);
int res = calculate(rpnList);
System.out.println(res);
}
//将一个逆波兰表达式，依次将数据和运算符放入ArrayList,方便后面的取数据
public static List<String> getListString(String suffixExpression) {
String[] split = suffixExpression.split(" ");
ArrayList<String> List = new ArrayList<>();
for (String ele : split) {
List.add(ele);
}
return List;
}
public static int calculate(List<String> ls) {
Stack<String> stack = new Stack<String>();
//遍历ls
for (String item : ls) {
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("符号错误");
}
//将res入栈
stack.push(res + "");
}
}
//最后留在栈中数据就是结果
return Integer.parseInt(stack.pop());
}
}
3 中缀表达式转后缀表达式
中缀表达式方便输入，后缀表达式方便计算机进行计算，所以需要一个转换的方法
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 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
代码：一个逆波兰表达式计算器，包含中缀表达式转后缀表达式功能
package Stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
//包含中缀表达式转为后缀表达式
//逆序表达式计算器
public class PolandNotation2 {
public static void main(String[] args) {
//给出逆波兰表达式
String Expression = "1+((2+3)*4)-5";
//为了方便用空格隔开
// 1 先将suffixExpression 放入ArrayList
// 2 将ArrayList传递给一个方法，遍历ArrayList 配合栈完成计算
List<String> List = getListString(Expression);
//3 将中缀表达式转换为后缀表达式
List<String> strings = parseSuffixExpressionList(List);
System.out.println(Expression+" 的后缀表达式为："+strings);
int calculate = calculate(strings);
System.out.println(Expression+"="+calculate);
}
//将一个逆波兰表达式，依次将数据和运算符放入ArrayList,方便后面的取数据
public static List<String> getListString(String suffixExpression) {
String[] split = suffixExpression.split("");
ArrayList<String> List = new ArrayList<>();
for (String ele : split) {
List.add(ele);
}
return List;
}
// 将中缀表达式转换为一个List 方便遍历
public static List<String> toInfixExpression(String s) {
List<String> ls = new ArrayList<>();
int i = 0;
String str;//做多位数拼接
char c;// 每
do {
//如果是一个非数字，加入ls
if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
ls.add("" + c);
i++;
}//如果是多位数，要进行拼接
else {
str = "";
while (i < s.length() && ((c = s.charAt(i)) >= 48 || (c = s.charAt(i)) <= 57)) {
str += c;
i++;
}
ls.add(str);
}
} while (i < s.length());
return ls;
}
// 中缀表达式转后缀表达式
public static List<String> parseSuffixExpressionList(List<String> ls) {
//定义两个栈
Stack<String> s1 = new Stack<>();//符号栈
//说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面还要逆序输出
//因此比较麻烦，所以直接用一个ArrayList<> 代替
/* Stack<String> s2= new Stack<>();*/
ArrayList<String> s2 = new ArrayList<>();
//遍历ls
for (String item : ls) {
//如果是一个数字，加入说
if (item.matches("\\d+")) {
s2.add(item);
} else if (item.equals("(")) {
s1.add(item);
} else if (item.equals(")")) {
//如果是右括号）， 则依次弹出s1栈顶的运算符，并压入s2,直到遇到左括号为止，则将这对括号舍弃了
while (!s1.peek().equals("(")) {
s2.add(s1.pop());
}
s1.pop();//将弹出
} else {
//item优先级小于或等于当s1栈顶优先级 ，将s1栈顶的运算符弹出并加入到s2中
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());
}
return s2;
}
public static int calculate(List<String> ls) {
Stack<String> stack = new Stack<String>();
//遍历ls
for (String item : ls) {
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("符号错误");
}
//将res入栈
stack.push(res + "");
}
}
//最后留在栈中数据就是结果
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:
break;
}
return result;
}
}
扫一扫
792
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
