package com.stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/*
* 前缀表达式基本介绍：
* 前缀表达式的计算求值：
* 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们
* 做相应的运算（栈顶元素和次顶元素），并将结果入栈；重复上述过程直至表达式最左端，最后运算得出的值即为
* 表达式的结果
*
* 举例：（3+4）先-6 对应的前缀表达式就是 -x+3456，针对前缀表达式求值步骤如下：
* 1）从右至左扫描，将6、5、4、3压入堆栈
* 2）遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7压入栈
* 3）接下来是x运算符，因此弹出7和5，计算7x5=34，将35压入栈
* 4）最后是-运算符，计算出35-6的值即29，由此得出最终结果
*
* 中缀表达式基本介绍
* 1、中缀表达式就是常见的运算表达式，入（3+4）x5-6
* 2、中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作，因此，在计算结果时，往往会将中缀表达式
* 转成其他表达式来操作（一般转换为后缀表达式）
*
* 后缀表达式基本介绍
* 后缀表达式又称逆波兰表达式，与前缀表达式类似，知识运算符处于操作数之后
* 从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符
* 对他们做相应的计算（次顶元素和栈顶元素），并将结果入栈：重复上述过程知道表达式最右端，最后运算
* 得出的值即为表达式的结果
*
* 举例：（3+4）x5-6对应的后缀表达式就是34+5x6-，针对后缀表达式求值步骤如下：
* 1）从左至右扫描，将3和4压入堆栈
* 2）遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7压入堆栈
* 3）将5入栈
* 4）接下来是x运算符，因此弹出5和7，计算出7x5=35，将35入栈
* 5）将6入栈
* 6）最后是-运算符，计算出35-6的值，得29，由此得出最终结果
*
*
* 逆波兰计算器基本介绍：
* 1、逆波兰计算器即用后缀表达式实现的计算器
* 2、支持小括号和多为整数
*
* 逆波兰计算器基本思路
* 举例：（3+4）x5-6对应的后缀表达式就是34+5x6-，针对后缀表达式求值步骤如下：
* 1）从左至右扫描，将3和4压入堆栈
* 2）遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7压入堆栈
* 3）将5入栈
* 4）接下来是x运算符，因此弹出5和7，计算出7x5=35，将35入栈
* 5）将6入栈
* 6）最后是-运算符，计算出35-6的值，得29，由此得出最终结果
*
* 中缀表达式转换为后缀表达式思路：
* 1、初始化两个栈，运算符栈s1和储存中间结果的栈s2
* 2、从左至右扫描中缀表达式
* 3、遇到操作数时，将其压入栈s2
* 4、遇到运算符时，比较其与s1栈顶运算符的优先级
* 1）如果s1为空，或栈顶运算符为左括号“（”，则直接将次运算符入栈
* 2）否则，若优先级比栈顶运算符的高，也将运算符压入s1
* 3）否则，将s1栈顶的运算符弹出并压入到栈s2中，再次转到（4-1）与s1中心得栈顶运算符相比较
* 4）否则，若s1栈顶不是运算符，比如括号，则运算符直接入栈
* 5、遇到括号时：
* 1）如果是左括号“（”，则直接压入s1
* 2）如果是右括号“）”，则一次弹出s1栈顶的运算符，并压入s2，知道遇到左括号为止，此时将这一对括号丢掉
* 6、重复步骤2到5，知道表达式的最右边
* 7、将s1中剩余的运算符一次弹出并压入s2；
* 8、一次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表示
*
* 举例：
* 中缀表达式 1+（（2+3）x4）-5 装换为后缀表达式
*
* 扫描到的元素 s2栈底->栈顶 s1栈底->栈顶 说明
* 1 1 空 数字，直接入栈
* + 1 + s1为空，运算符直接入栈s1
* （ 1 +（ 左括号，直接入栈s1
* （ 1 +（（ 同上
* 2 12 +（（ 数字
* + 12 +（（+ s1栈顶为左括号，不示运算符，运算符直接入栈
* 3 123 +（（+ 数字
* ） 123+ +（ 右括号，弹出元素安抚直至遇到左括号
* x 123+ +（x s1栈顶为左括号，不示运算符，运算符直接入栈
* 4 123+4 +（x 数字
* ） 123+4x + 右括号，弹出元素安抚直至遇到左括号
* - 123+4x+ - -与+优先级相同，因此弹出，再压入
* 5 123+4x+5 - 数字
* 达到最右端 123+4x+5- 空 s1剩余的云算法
*
* 后缀表达式为：123+4x+5-
*/
public class PolandNotationDemo {
public static void main(String[] args) {
// 先定义一个逆波兰表达式
// （3+4）x5-6对应的后缀表达式就是3 4 + 5 x 6
// 为了方便，逆波兰表达式的数字和符号使用空格隔开
String suffixExpr="3 4 + 5 * 6 -";
polandNotationCalculator(suffixExpr);
//完成将一个中缀表达式转换为后缀表达式的功能
//说明：
//1、1+((2+3)x4)-5 => 转成 1 2 3 + 4 x + 5 -
//2、因为直接对str进行操作，不方便，因此先将“1+((2+3)x4)-5” 转换为中缀表达式对应的list
// 即“1+((2+3)x4)-5” => ArrayList [1,+,(,(,2,+,3,),x,4,),-,5]
//3、将得到的中缀表达式对应的list转换为后缀表达式对应的list
// 即ArrayList [1,+,(,(,2,+,3,),x,4,),-,5] => ArrayList [1 2 3 + 4 x + 5 -]
String infixExpr="1+((2+3)*4)-5";
List<String> infixExprList=toInfixExprList(infixExpr);
System.out.println(infixExprList);
List<String> suffixExprList=parseSuffixExprList(infixExprList);
System.out.println(suffixExprList);
int sum=calculate(suffixExprList);
System.out.printf("逆波兰表达式运行结果为：%s = %d\n",infixExpr,sum);
}
// 即ArrayList [1,+,(,(,2,+,3,),x,4,),-,5] => ArrayList [1 2 3 + 4 x + 5 -]
public static List<String> parseSuffixExprList(List<String> ls)
{
//定义两个栈，
Stack<String> s1=new Stack<String>();
//因为s2这个栈再整个过程中没有pop操作，而且最后还需要逆序输出，因此比较麻烦，因此直接使用list
//Stack<String> s2=new Stack<String>();
List<String> s2=new ArrayList<String>();
for(String item:ls)
{
//如果是一个数，就加入到s2
if(item.matches("\\d+"))
{
s2.add(item);
}
else if(item.equals("("))
{
s1.push(item);
}else if(item.equals(")"))
{
while(!s1.peek().equals("("))
{
s2.add(s1.pop());
}
s1.pop();//消除左括号
}else
{
//当item优先级小于等于s1栈顶运算符，将s1栈顶的运算符弹出并加入到s2中，再次跳转到4.1中与s1的新的栈顶运算符比较
while(s1.size() !=0 && Operation.getValue(s1.peek()) >=Operation.getValue(item))
{
s2.add(s1.pop());
}
s1.push(item);
}
}
while(s1.size()!=0)
{
s2.add(s1.pop());
}
return s2;
}
//完成将一个中缀表达式转换为后缀表达式的功能
//说明：
//1、1+((2+3)x4)-5 => 转成 1 2 3 + 4 x + 5 -
//2、因为直接对str进行操作，不方便，因此先将“1+((2+3)x4)-5” 转换为中缀表达式对应的list
// 即“1+((2+3)x4)-5” => ArrayList [1,+,(,(,2,+,3,),x,4,),-,5]
//s="1+((2+3)*4)-5"
public static List<String> toInfixExprList(String s)
{
//定义一个List，存放中缀表达式对应的内容
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++;
}
else
{
//如果是一个数，需要考虑多位数
str="";//现将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;
}
private static void polandNotationCalculator(String suffixExpr) {
/*
* 思路：
* 1、先将3 4 + 5 x 6 放入ArrayList中
* 2、将ArrayList传递给一个方法，配合栈完成计算
*/
List<String> rpnlist=getListString(suffixExpr);
int sum=calculate(rpnlist);
System.out.printf("逆波兰表达式运行结果为：%d\n",sum);
}
//将一个逆波兰表达式，依次将数字和云算法放入ArrayList中
public static List<String> getListString(String suffixExpr)
{
//将suffixExpr分割
String[] split=suffixExpr.split(" ");
List<String> list=new ArrayList<String>();
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+"");
}
}
//最后留在栈stack中的数据即为结果
return Integer.parseInt(stack.pop());
}
}
//编写一个类，Operation,可以返回一个运算符的优先级
class Operation
{
private static int ADD=1;
private static int SUB=1;
private static int DIV=2;
private static int MUL=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;
}
}
运行结果如下：
逆波兰表达式运行结果为：29
[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
不存在该操作符
不存在该操作符
[1, 2, 3, +, 4, *, +, 5, -]
逆波兰表达式运行结果为：1+((2+3)*4)-5 = 16
