逆波兰式_临时算符栈-CSDN博客

定义：

　一个表达式E的后缀形式可以如下定义：

　　（1）如果E是一个变量或常量，则E的后缀式是E本身。

　　（2）如果E是E1 op E2形式的表达式，这里op是如何二元操作符，则E的后缀式为E1'E2' op，这里E1'和E2'分别为E1和E2的后缀式。

　　（3)如果E是（E1）形式的表达式，则E1的后缀式就是E的后缀式。　

以上那个是来至百度的解释

直接说就是a+b，这是中缀表达式，写成后缀表达式就是：ab+

算法实现：

　　将一个普通的中序表达式转换为逆波兰表达式的一般算法是：

　　首先需要分配2个栈，一个作为临时存储运算符的栈S1（含一个结束符号），一个作为输入逆波兰式的栈S2（空栈），S1栈可先放入优先级最低的运算符#，注意，中缀式应以此最低优先级的运算符结束。可指定其他字符，不一定非#不可。从中缀式的左端开始取字符，逐序进行如下步骤：

　　（1）若取出的字符是操作数，则分析出完整的运算数，该操作数直接送入S2栈

　　（2）若取出的字符是运算符，则将该运算符与S1栈栈顶元素比较，如果该运算符优先级大于S1栈栈顶运算符优先级，则将该运算符进S1栈，否则，将S1栈的栈顶运算符弹出，送入S2栈中，直至S1栈栈顶运算符低于（不包括等于）该运算符优先级，则将该运算符送入S1栈。

　　（3）若取出的字符是“（”，则直接送入S1栈栈顶。

　　（4）若取出的字符是“）”，则将距离S1栈栈顶最近的“（”之间的运算符，逐个出栈，依次送入S2栈，此时抛弃“（”。

　　（5）重复上面的1~4步，直至处理完所有的输入字符

　　完成以上步骤，S2栈便为逆波兰式输出结果。不过S2应做一下逆序处理。便可以按照逆波兰式的计算方法计算了！

（PS：依然来自百度）

下面是java实现：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Stack;

import javax.naming.spi.DirStateFactory.Result;


public class Main {

	/**
	 * @param args
	 */
	public static Hashtable<Character, Integer> ht=new Hashtable<>();//保存运算符优先级的hashtable
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//3*(2+3*7)-1
		String expressionString="3+1.6";
		ht.put('+', 1);
		ht.put('-', 1);
		ht.put('*', 2);
		ht.put('/', 2);
		ht.put('(', 0);
		List RPNList=changeToRPN(expressionString);
		double result=calculateRPN(RPNList);
		System.out.println(RPNList);
		System.out.println(result);
	}

	//计算逆波兰式的值
	private static double calculateRPN(List<Object> list){
		Stack<Double> reslut=new Stack<Double>();
		for(int i=0;i<list.size();i++){
			if(list.get(i) instanceof Character){
				double a=reslut.pop();
				double b=reslut.pop();
				double tempresult=cal(b,a,(Character)list.get(i));
				reslut.push(tempresult);
			}else {
				if(list.get(i) instanceof Double){
					reslut.push((Double)list.get(i));
				}
			}
		}
		return reslut.pop();
	}
	private static double cal(double a,double b,Character c){
		switch (c) {
		case '+':
			return a+b;
		case '-':
			return a-b;
		case '*':
			return a*b;
		case '/':
			return a/b;
		default:
			return 0;
		}
	}

	//将一个数学表达式转化成逆波兰式
	private static List<Object> changeToRPN(String s){
		StringBuilder sb=new StringBuilder();//用来保存数字字符的，如12.2,1234.44等等
		List<Character> opStack=new ArrayList<Character>();//保存操作符
		List<Object> allStack=new  ArrayList<Object>();//保存所有内容
		char[] ch=s.toCharArray();
		for(int i=0;i<ch.length;i++){
			switch (ch[i]) {
			case '(':
				opStack.add(ch[i]);
				break;
			case ')':
				while (opStack.get(opStack.size()-1)!='(') {
					char c=opStack.remove(opStack.size()-1);
					allStack.add(c);
				}
				opStack.remove(opStack.size()-1);//将'（'也出栈
				break;
			case '+':
			case '-':
			case '*':
			case '/':
				if(opStack.size()==0||ht.get(ch[i])>ht.get(opStack.get(opStack.size()-1))){//比较运算符的优先级，大于压栈，否则出栈
					opStack.add(ch[i]);
				}else{
					while (opStack.size()>0&&ht.get(ch[i])<=ht.get(opStack.get(opStack.size()-1))) {
						char c=opStack.remove(opStack.size()-1);
						allStack.add(c);
						
					}
					opStack.add(ch[i]);
				}
				break;
			default://如果是数字
				while(i<ch.length&&(Character.isDigit(ch[i])||ch[i]=='.')){
					sb.append(ch[i]);
					i++;
				}
				i--;
				allStack.add(Double.parseDouble(sb.toString()));
				sb.delete(0, sb.length());
				break;
			}
		}//遍历所有字符，将操作符链表全部出栈

		while(!opStack.isEmpty()){
			char c=opStack.remove(opStack.size()-1);
			allStack.add(c);
		}
		return allStack;
	}
		

}

PS：以上没有进行太多的异常判断，请各位自重。还有如果存在不足，请大家不吝指出