Java数据结构-后缀表达式计算器（逆波兰表达式）

韩顺平2019-Java数据结构

学习韩顺平老师的Java数据结构

思路

先中缀转后缀表达式

1.初始化两个栈，运算栈s1和中间结果栈s2
2.从左至右扫描中缀表达式
3.遇到操作数，压入s2
4.遇到运算符，比较与s1栈顶运算符优先级
（1）如果s1为空，或者栈顶运算符为“（”，则直接将此运算符入栈
（2）否则，如果优先级比栈顶的高，也将运算符压入s1
（3）否则，将s1栈顶的运算符弹出压入到s2中，再次转到（4-1）与s1中新的栈顶运算符比较
5.遇到括号时
（1）如果是“（“，则压入s1
（2）如果是”）“，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将一对括号丢弃
6，重复2到5，直到表达式最右端
7，将s1中剩余的运算符依次弹出并压入s2
8.依次弹出说的元素并输出，结果的逆序即为中缀表达式的后缀表达式

后缀表达式进行计算

package com.stack;

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

/**
 * 〈一句话功能简述〉

 * 〈波兰表达式〉
 *
 * @author PitterWang
 * @create 2019/12/21
 * @since 1.0.0
 */
public class PolandNotation {


	public static void main(String[] args) {
		String express = "1+((2+3)*4)-5";

		List<String> list = toIndixExpressionList(express);

		System.out.println(list);
		List<String> parseSuffix = parseSuffix(list);
		System.out.println(parseSuffix);

		System.out.println(suffixCaclulator(parseSuffix));

	}
	public static List<String> getList(String expression){
		String[] sp = expression.split(" ");
		List<String> list = new ArrayList<>();

		for (String s : sp){
			list.add(s);
		}
		return list;
	}


	/**
	 * 后缀表达式计算
	 * @param list
	 * @return
	 */
	public static int suffixCaclulator(List<String> list){
		Stack<String> stack = new Stack<>();

		for (String item: list){
			if(item.matches("\\d+")){
				stack.push(item);
			}else {
				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("YUNSUANFUCUOLE");
				}
				stack.push("" + res);
			}
		}

		return Integer.valueOf(stack.pop());
	}

	/***
	 * 将后缀表达式的值转到list里
	 * @param s
	 * @return
	 */
	public static List<String> toIndixExpressionList(String s){

		List<String> ls = new ArrayList<>();
		int i = 0;
		String str;
		char c;

		do {
			//如果c式一个非数字，就加入到list
			if((c=s.charAt(i))<48||(c=s.charAt(i))>57){
				ls.add(c+"");
				i++;
			}else{
				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
	 * @param list
	 * @return
	 */
	public static List<String> parseSuffix(List<String> list){

		Caclulator caclulator = new Caclulator();
		Stack<String> s1 = new Stack<>();

		List<String> s2 = new ArrayList<>();

		for(String item: list){
			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{
				while(s1.size() !=0 && (caclulator.priority(s1.peek()) >= caclulator.priority(item))){

					s2.add(s1.pop());
				}
				s1.push(item);
			}


		}

		while (s1.size() != 0){
			s2.add(s1.pop());
		}


		return s2;
 	}



}

github 源码地址：自学数据结构源码地址