手写逆波兰表达式-练习栈的使用

概念：
逆波兰表达式也叫后缀表示法，即操作符号都置于操作数的后面，逆波兰表达式可以不用括号来标识操作符的优先级。例如：3+4 是一个中缀表达式，转换成逆波兰表达式为34+ 。有人可能会想有后缀表达式，中缀表达式，那有没有前缀表达式呢？答案是：有前缀表达式，也叫波兰表达式，上文中的3+4 用前缀表达式表示为+34。

用途：
了解了什么是逆波兰表达式，那它有什么具体的用途呢？
1.逆波兰表达式中不需要括号，用户只需按照表达式顺序求值，让堆栈自动记录中间结果；同样的，也不需要指定操作符的优先级
2.机器状态永远是一个堆栈状态，堆栈里是需要运算的操作数，栈内不会有操作符。
3.当有操作符时就计算，因此，表达式并不是从右至左整体计算而是每次由中心向外计算一部分，这样在复杂运算中就很少导致操作符错误。
计算原理：
逆波兰表达式进行数据计算的时候一般分为两步：
1.将中缀表达式转换为后缀表达式
2.对转换完成后的后缀表达式进行计算

package com.jason.datastruct;

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

public class ReversePolish {
    private List<String> sList = new ArrayList<String>();// 中缀表达式集合
    private List<String> dList = new ArrayList<String>();// 后缀表达式集合
    private Stack<String> opStack = new Stack<String>();// 操作符栈
    private Stack<String> rStack = new Stack<String>();// 结果运算栈
    private final int level1 = 0;// +-的级别是0
    private final int level2 = 1;// */的级别是1
    private final int level3 = 3;// 左右括号是3

    // 初始化
    public ReversePolish(String input) {
        // a+b-c*(d+e) 转换为实际值例如：1+2-3*(4+5)
        StringTokenizer st = new StringTokenizer(input, "+-*/()", true);
        while (st.hasMoreTokens()) {
            sList.add(st.nextToken());
        }
    }

    public List<String> infix2ReversePolish() {
        for (String string : sList) {
            // 如果是数字 直接放入dlist 数组
            if (isNumber(string)) {
                dList.add(string);
            } else if (isOperation(string)) {
                // 如果是运算符 放入运算符栈

                opHandler(string);

            } else {
                System.out.println("非法操作符");

            }

        }
        // 将栈置空
        while (!opStack.empty()) {
            dList.add(opStack.pop());
        }
        return dList;
    }

    private void opHandler(String s) {

        for (Object string : opStack.toArray()) {
            System.out.print(string + "");
        }
        System.out.println();
        // 如果运算符栈是空 直接放入栈

        if (opStack.empty()) {
            opStack.push(s);
            return;
        }
        // 如果是(直接入栈
        if (s.equals("(")) {
            opStack.push(s);
            return;
        }
        // 如果是) 将(和)之间的出栈
        if (s.equals(")")) {
            while (!"(".equals(opStack.peek())) {
                dList.add(opStack.pop());
            }
            opStack.pop();
            // String tmp = "";
            // while (!"(".equals(tmp = opStack.pop())) {
            // dList.add(tmp);
            // }
            return;

        }

        // 如果栈顶是( 直接入栈

        if ("(".equals(opStack.peek())) {
            opStack.push(s);
            return;
        }
        // 如果运算符等级大于当前预算符 直接入栈

        if (comparePriority(s, opStack.peek())) {
            opStack.push(s);
            return;
        }
        // 如果等级小 或者等于 栈里的出栈 // 小的入栈 (在调用一次)
        if (!comparePriority(s, opStack.peek())) {
            dList.add(opStack.pop());
            opHandler(s);

        }

    }

    // 判斷是否是数字
    private boolean isNumber(String s) {
        return s.matches("\\d+");
    }

    // 判断是否是运算符
    private boolean isOperation(String s) {
        return s.matches("[\\+\\-\\*\\/\\(\\)]");
    }

    // 判断op1 的优先级 是否大于 op2的优先级
    private boolean comparePriority(String op1, String op2) {
        return getLevel(op1) > getLevel(op2);
    }

    // 获得操作符的优先级
    private int getLevel(String op) {
        if ("+".equals(op) || "-".equals(op)) {
            return level1;
        }
        if ("*".equals(op) || "/".equals(op)) {
            return level2;
        }
        if ("(".equals(op) || ")".equals(op)) {
            return level3;
        }
        return -1;
    }

    // 计算 反波兰表达式
    public String resultFromReversePolish() {
        for (String string : dList) {
            // 如果是数字 入栈
            if (isNumber(string)) {
                rStack.push(string);
            } else if (isOperation(string)) {
                // 如果是运算符 取出上面2个 进行运算 结果入栈
                if (string.equals("(") || string.equals(")")) {
                    return "公式错误";
                }
                int num2 = Integer.parseInt(rStack.pop());
                int num1 = Integer.parseInt(rStack.pop());
                String result = operation(num1, string, num2);
                rStack.push(result);
            }
        }
        if (rStack.empty()) {
            return "";
        }
        return rStack.pop();
    }
    //运算
    private String operation(int num1, String string, int num2) {

        switch (string) {
        case "+":
            return num1 + num2 + "";
        case "-":

            return num1 - num2 + "";

        case "*":

            return num1 * num2 + "";

        case "/":
            return num1 / num2 + "";

        default:
            return "";
        }

    }

}

测试类：

package com.jason.datastruct;

import java.util.ArrayList;

public class ReversePolishTest {

    public static void main(String[] args) {

        String str="1+((2-3)*(4+5))+((6/2))";
        System.out.println("中缀表达式："+str);
        ReversePolish rPolish=new ReversePolish(str);

        ArrayList reversePolish =(ArrayList) rPolish.infix2ReversePolish();
        System.out.println("转换 逆波兰表达式：");
        for (String string : reversePolish) {
            System.out.print(string+",");
        }
        //1,2,3,4,-,*,6,*,+,7,-,
        System.out.println();
        System.out.println("结果\t:"+rPolish.resultFromReversePolish());
    }
}

结果：

中缀表达式：1+((2-3)*(4+5))+((6/2))

+
+(
+((
+((-
+(
+(*
+(*(
+(*(+
+(*
+

+
+(
+((
+((/
+(
转换 逆波兰表达式：
1,2,3,-,4,5,+,*,+,6,2,/,+,
结果  :-5