后缀表达式转为后缀表达式
1.简介
将形如1 + ( ( 2 + 3 ) × \times × 4 ) -5 的后缀表达式转换成为形如1 2 3 + 4 × \times × + 5 - 的后缀表达式
jdk 1.8
这个只支持个位数以及整数的运算及转换
2.代码实现
import com.ethan.shangguigu.stack.suffixCalculator.SuffixCalculator;
import java.util.Stack;
public class MediumOrderCalculator {
public static void main(String[] args) {
//operatorStack用于存放运算符以及括号
Stack<Character> operatorStack=new Stack<>();
//NumberStack用于存放操作数以及运算符,最终的后缀表达式就是该栈的倒序
Stack<Character> NumberStack=new Stack<>();
//MediumExpression代表一个中缀的表达式
String MediumExpression = "1+((2+3)*4)-5";
for (int i = 0; i < MediumExpression.length(); i++) {
//从左到右一次取出给ch
char ch=MediumExpression.charAt(i);
//判断是否为数字
if(isNumber(ch)){
//是数字直接放入数字栈
NumberStack.push(ch);
}else {
if(isOperator(ch)){
//如果是操作符,则执行相应操作
operator(ch,operatorStack,NumberStack);
}else {
if (isOpParen(ch)){
//为‘(’时,直接压入operatorStack
operatorStack.push(ch);
}else if(isOutParen(ch)){
//如果是‘)’,则执行相应操作
OutParen(operatorStack,NumberStack);
}
}
}
}
//将operatorStack中剩余的操作符存放到NumberStack中
for(Character value: operatorStack){
NumberStack.push(value);
}
//因为最终的后缀表达式为NumberStack的倒序,所以直接将其取出重新放入一个新栈当中
String suffixExpression="";
for(Character value: NumberStack){
suffixExpression=suffixExpression+value+" ";
}
//打印输出
System.out.println(MediumExpression+"="+SuffixCalculator.main(suffixExpression));
}
//当ch为‘)’时的处理方法
public static void OutParen(Stack operatorStack,Stack NumberStack){
//将operatorStack栈顶的存入NumberStack中,直到operatorStack当前栈顶为‘(’,则直接将其弹出栈
if(isOpParen((char)operatorStack.peek())){
operatorStack.pop();
}else {
NumberStack.push(operatorStack.pop());
OutParen(operatorStack,NumberStack);
}
}
//当ch为操作符时的处理
public static void operator(char ch, Stack operatorStack,Stack NumberStack){
//当operatorStack为空或者operatorStack栈顶为‘(’时,直接将ch存入operatorStack
if(operatorStack.isEmpty()||isOpParen((char)operatorStack.peek())){
operatorStack.push(ch);
}else {
//当ch的优先级比operatorStack栈顶运算符优先级高时,直接将ch入operatorStack
if(Priority(ch)>Priority((char)operatorStack.peek())){
operatorStack.push(ch);
}else {
//当ch的优先级比operatorStack栈顶运算符的优先级低时,将栈顶的操作符取出放入NumberStack当中
//并一直循环,直到operatorStack为空或者operatorStack栈顶为‘(’再或者ch的优先级比operatorStack栈顶运算符优先级高
NumberStack.push(operatorStack.pop());
//递归调用
operator(ch,operatorStack,NumberStack);
}
}
}
//判断是否为数字
public static Boolean isNumber(char ch){
if(ch>='0' && ch <='9'){
return true;
}else {
return false;
}
}
//判断是否为前括号
public static Boolean isOpParen(char ch){
if(ch=='('){
return true;
}else {
return false;
}
}
//判断是否为后括号
public static Boolean isOutParen(char ch){
if(ch==')'){
return true;
}else {
return false;
}
}
//判断是否为运算符
public static Boolean isOperator(char ch){
if(ch=='+'||ch=='-'||ch=='*'||ch=='/'){
return true;
}else {
return false;
}
}
//判断是否为运算符
public static int Priority(char ch){
int result=0;
switch (ch){
case '+':
case '-': result=1;break;
case '*':
case '/':result=2;break;
}
return result;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class SuffixCalculator {
public static int main(String suffixExpression) {
//suffixExpression表示一个后缀表达式的字符串
//将suffixExpression转化成为suffixArrayList,以方便后续进行操作
List<String> suffixArrayList=getSuffixArrayList(suffixExpression);
int results = calculator(suffixArrayList);
return results;
}
//将suffixExpression转换成为suffixArrayList
public static List<String> getSuffixArrayList(String sue){
String[] split = sue.split(" ");
List<String> suffixArrayList = new ArrayList<>();
for(String value : split){
suffixArrayList.add(value);
}
return suffixArrayList;
}
//进行后缀表达式的运算
public static int calculator(List<String> suffixArrayList){
//创建一个栈,利用栈来实现后缀的表达式的运算,栈中只存贮操作数,最终栈中会保留一个数,该数为最终结果
Stack<Integer> suffixStack=new Stack<>();
for(String value : suffixArrayList){
//判断是否为操作符,是则从栈中取出两个操作数,根据本value的值进行运算
// 不是则直接入栈
if(isOperator(value)){
//从栈中取出第一个操作数
Integer s1 = suffixStack.pop();
//从栈中取出第二个操作数
Integer s2 = suffixStack.pop();
//对操作数进行相应的运算
Integer results = compute(s1,s2,value);
//将两数运算的结果入栈
suffixStack.add(results);
}else {
//入栈
suffixStack.add(Integer.parseInt(value));
}
}
return suffixStack.pop();
}
//判断字符串是否为操作符
public static Boolean isOperator(String value){
if(value.equals("+") || value.equals("-") ||value.equals("*") ||value.equals("/")){
return true;
}else {
return false;
}
}
//按照操作符进行相应的运算
public static Integer compute(Integer s1, Integer s2 , String operator){
Integer results=0;
switch (operator){
case "+": return s1+s2;
case "-": return s2-s1;
case "*": return s1*s2;
case "/": return s2/s1;
}
return results;
}
}
3.运行结果
1+((2+3)*4)-5=16