package com.m.demo6;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
public class nPolandCounter {
public static void main(String[] args) {
// 中缀表达式转后缀表达式
// String str="1+((2+3)*4)-5";//1 2 3 + 4 × + 5 –
String str="8888*(234+12)-5";
// 将表达式转为List ->多位数字合并成String
List<String> li = numsMerge(str);
//如果有空元素则remove掉:使用迭代器删除,否则会发生并发异常
Iterator<String> iterator = li.iterator();
int i = 0;
while (iterator.hasNext()) {
if (iterator.next() == "") {
iterator.remove();
}
}
// System.out.println(li);
// 将中缀表达式转为后缀表达式
List<String> list = mid2Last(li);
// System.out.println(list);
// 使用后缀表达式计算:数字进栈,遇到操作符 弹出两个数字,将结果进栈
// 首先将后缀表达式的list 转为int 类型 方便后续计算,操作符char类型也可以直接当作int操作
List<Integer> list2 = String2Integer(list);
// System.out.println(list2);
System.out.printf("%s=%d\n",str,nPoland(list2));
}
public static int nPoland(List<Integer> list) {
// 使用后缀表达式计算:数字进栈,遇到操作符 弹出两个数字,将结果进栈
Stack<Integer> stack=new Stack<>();
for(int item:list) {
// 判断是否为操作符
if(isOption(item)&&stack.size()>0) {
int num1 = stack.pop();
int num2 = stack.pop();
int res=result(num1,num2,item);
stack.push(res);
}else {
stack.push(item);
}
}
return stack.pop();
}
/**
* 判断是否为操作符
* @param li
* @return
*/
public static boolean isOption(int li) {
return li=='+'||li=='-'||li=='*'||li=='/';
}
/**
* op运算
* @param num1
* @param num2
* @param op
* @return
*/
public static int result(int num1,int num2,int op) {
int res=0;
switch(op) {
case '+':res=num1+num2;break;
case '-':res=num2-num1;break;
case '*':res=num2*num1;break;
case '/':res=num2/num1;break;
default:break;
}
return res;
}
/**
* 遍历集合,将元素转为int 类型,java中int 类型和char类型可以混用
* @param list
* @return
*/
public static List<Integer> String2Integer(List<String> list){
List<Integer> list2=new ArrayList<>();
for(String li:list) {
int i=0;
if(li.equals("+")||li.equals("-")||li.equals("*")||li.equals("/")) {
i=li.charAt(0);
}else {
i=Integer.parseInt(li);
}
list2.add(i);
}
return list2;
}
/**
* 具体步骤如下: 初始化两个栈:运算符栈s1和储存中间结果的栈s2; 从左至右扫描中缀表达式; 遇到操作数时,将其压s2;
* 遇到运算符时,比较其与s1栈顶运算符的优先级: 如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
* 否则,若优先级比栈顶运算符的高,也将运算符压入s1; 否则,将s1栈顶的运算符弹出并压入到s2中,再次转到(4-1)与s1中新的栈顶运算符相比较;
* 遇到括号时: (1) 如果是左括号“(”,则直接压入s1 (2)
* 如果是右括号“)”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃 重复步骤2至5,直到表达式的最右边
* 将s1中剩余的运算符依次弹出并压入s2 依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式
*
* 由于最后需要逆序输出:这里S2直接用list代替
* @param li
* @return
*/
public static List<String> mid2Last(List<String> li){
Stack<String> stack=new Stack<>();
List<String> list=new ArrayList<>();
for(String item:li) {
// 遇到操作数时,将其压s2;
if(item.matches("\\d+")) {
list.add(item);
}else {
// 遇到运算符时,比较其与s1栈顶运算符的优先级
// 如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
// 否则,若优先级比栈顶运算符的高,也将运算符压入s1; 否则,将s1栈顶的运算符弹出并压入到s2中
if(stack.size()==0||item.equals("(")) {
stack.push(item);
}else if(item.equals(")")) {//遇到)时候:开始弹栈,直到遇到(,最后将(也弹出
while(!stack.peek().equals("(")) {
list.add(stack.pop());
}
stack.pop();
}else {//遇到运算符,开始比较运算符:如果 当前的运算符 大于 栈顶的运算符则 进栈,否则将栈中运算符弹出,再进栈
if(opPriperty(item)>opPriperty(stack.peek())) {
stack.push(item);
}else {
list.add(stack.pop());
stack.push(item);
}
}
}
}
// 将s1中剩余的运算符依次弹出并压入s2 依次弹出s2中的元素并输出
while(stack.size()>0) {
list.add(stack.pop());
}
return list;
}
/**
* 用来做运算符比较
* @param op
* @return
*/
public static int opPriperty(String op) {
if(op.equals("+")||op.equals("-")) {
return 0;
}else if(op.equals("*")||op.equals("/")) {
return 1;
}else {
return -1;
}
}
public static List<String> numsMerge(String str){
// String s="723+5*7890+123";
char[] chs=str.toCharArray();
List<String> list=new ArrayList<>();
String ss="";
for(int i=0;i<chs.length;i++) {
if(chs[i]>='0'&&chs[i]<='9') {
ss+=chs[i];
}
else {
list.add(ss);
// System.out.println(chs[i]);
list.add(String.valueOf(chs[i]));
ss="";
}
}
// System.out.println(ss);
list.add(ss);
// System.out.println(list);
return list;
}
}
01-11
829
![](https://csdnimg.cn/release/blogv2/dist/pc/img/readCountWhite.png)
07-17
536
![](https://csdnimg.cn/release/blogv2/dist/pc/img/readCountWhite.png)
02-21
287
![](https://csdnimg.cn/release/blogv2/dist/pc/img/readCountWhite.png)