前缀、中缀、后缀表达式

前缀表达式

• 前缀表达式又称波兰式，前缀表达式的运算符位于操作符之前
  
  前置表达式的计算机求值：从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们做相应的计算（栈顶元素和次顶元素），并将结果存入；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
  

中缀表达式

• 中缀表达式就是常见的运算表达式，如（3+4）*5-6
• 中缀表达式的求值使我们最熟悉的，但是对于计算机来说却不好操作，因此在计算过程中，往往会将中缀表达式转为其他表达式来操作（一般转为后缀表达式）

后缀表达式

后缀表达式又称为逆波兰表达式，与前缀表达式相似，只是将运算符位于操作数之后

后缀表达式的计算机求值：从左至扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们做相应的计算（次顶元素和栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出值即为表达式的结果

中缀表达式转为后缀表达式

具体步骤如下：

• 初始化两个栈：运算符栈s1和储存中间结果的栈s2；
• 从左至右扫描中缀表达式
• 遇到操作数时，将其压s2
• 遇到运算符的时候，比较其与s1栈顶运算符优先级
  • 如果s1为空，或栈顶运算符为左括号“（”，则直接将此运算符入栈
  • 否则，若优先级比栈顶运算符的高，也将运算符压入s1
  • 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到上述粗体步骤与s1中新的栈顶运算符相比较 ；

• 遇到括号时：
  • 如果是左括号“（”，则直接压入s1
  • 如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这对括号丢弃
• 重复上述划线部分，知道表达式的最右端
• 将s1中剩余的运算符依次弹出并压入s2
• 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
  

逆波兰计算器

package com.xxxx.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolanNotation {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//先定义一个逆波兰表达式
		//(3+4)*5-6  =>3 4 + 5 * 6 -
		//说明为了方便，逆波兰表达式的数字和符号使用空格隔开
		/* String str="3 4 + 5 * 6 -";
		   List<String> rpnlist=getListString(str);
		   int res=calculate(rpnlist);
		   System.out.println("计算的结果是"+res);
		*/
		
		
		/*
		 * 思路：
		 * 1.先将"3 4 + 5 * 6 -"放到ArrayList中
		 * 2.将ArrayList传递一个方法，遍历ArrayList配合栈完成计算
		 *   即"1+((2+3)*4)-5"=>ArrayList[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
		 * 3.将得到的中缀表达式对应的List=>后缀表达式对应的List
		 */
		
		String str="1+((2+3)*4)-5";
		List<String> infixString=toInfixString(str);
		System.out.println("中缀表达式对应的list"+infixString);
		List<String> parseSuffixString=parseSuffixStr(infixString);
		System.out.println("后缀表达式对应的list"+parseSuffixString);
		System.out.printf("最后的结果是%d",calculate(parseSuffixString));
	}
	
	//方法：将中缀表达式转为对应的list
	//s="1+((2+3)*4)-5";
	public static List<String> toInfixString(String s){
		//定义一个List，存放中缀表达式对应的内容
		List<String> ls=new ArrayList<String>();
		int i=0;//这时是一个指针，用于遍历中缀表达式的字符串
		String str;//对多位数的拼接
		char c;//每遍历到一个字符，就放到c
		do {
			//如果是一个非数字，需要加入到ls
			if((c=s.charAt(i))<48||(c=s.charAt(i))>57){
				ls.add(""+c);
				i++;//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;
	}
	
	//方法：将得到的中缀表达式对应的List=>后缀表达式对应的List
	public static List<String> parseSuffixStr(List<String> ls){
		//定义两个栈
		Stack<String> s1=new Stack<String>();//符号栈
		//说明：因为s2这个栈，在整个转换的过程中，没有pop操作，而且我们后面还需要逆序输出
		//因此比较麻烦，这里我们就不用Stack<String>了，直接使用List<String>了
//		Stack<String> s2=new Stack<String>();//存储中间结果的栈
		List<String> s2=new ArrayList<String>();//存储中间结果的list
		
		//遍历
		for(String item:ls) {
			if(item.matches("\\d+")) {
				s2.add(item);
			}else if(item.equals("(")) {
				s1.push(item);
			}else  if(item.equals(")")) {
				//如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这对括号丢弃
				while(!s1.peek().equals("(")) {
					s2.add(s1.pop());
				}
				s1.pop();//!!!消掉左括号
			}else {
				//当item的优先级小于等于s1栈顶运算符，将s1栈顶的运算符弹出并压入到s2中，再次转到上述粗体步骤与s1中新的栈顶运算符相比较 
				while(s1.size()!=0&&priority(item)<=priority(s1.peek())) {
					s2.add(s1.pop());
				}
				s1.push(item);
			}
		}
		
		//将s1中的剩余的运算符依次弹出并加入s2
		while(s1.size()!=0) {
			s2.add(s1.pop());
		}
		
		return s2;//注意因为是存放到List，因此按顺序输出就是对应的后缀表达式
	}
	
	//定义一个判断优先级的方法
	public static int priority(String s) {
		if(s.equals("*")||s.equals("/")) {
			return 1;
		}else if(s.equals("+")||s.equals("-")) {
			return 0;
		}else {
			return -1;//假定目前的表达式只有+、-、*、/
		}
	}
	
	//将一个逆波兰表达式，依次将数据和运算符放入ArrayList中
	public static List<String> getListString(String str){
		//将str分割
		String[] split=str.split(" ");
		List<String> list=new ArrayList<String>();
		for(String el:split) {
			list.add(el);
		}
		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 num1=Integer.parseInt(stack.pop());
				int num2=Integer.parseInt(stack.pop());
				int res=0;
				if(item.equals("+")) {
					res=num1+num2;
				}else if(item.equals("-")) {
					res=num2-num1;
				}else if(item.equals("*")) {
					res=num1*num2;
				}else if(item.equals("/")) {
					res=num2/num1;
				}else {
					throw new RuntimeException("运算符有误");
				}
				//把res入栈
				stack.push(res+"");
			}
		}
		//最后留在栈中的数据是运算结果
		return Integer.parseInt(stack.pop());
	}
}