逆波兰表达式（后缀表达式）计算器的实现总结

   **逆波兰表达式又叫做后缀表达式。
   逆波兰表示法是波兰逻辑学家J・卢卡西维兹于1929年首先提出的一种表达式的表示方法 [1]**  

先说一下实现的思路

一）使用栈完成表达式的计算思路

1.通过一个index值（索引），来遍历我们的表达式
2.如何是一个数字直接入栈
3.如何发现是一个符号 就分以下情况
1）如何发现当前符号栈为空，就直接入栈
2）如何符号栈有操作符，就进行比较，如何当前的操作符
的优先级小于或者等于栈中的操作符，就需要从栈中pop
出两个数，再从符号栈中pop出一个符号，进行运算，将
得到的结果入数栈，然后将当前的操作符入符号栈，如果
当前的操作符的优先级大于栈中的操作符，就直接入符号栈
4.当表达式扫描完毕，就顺序的从数栈的符号栈中pop出相
应的数和符号，并运行
5.最后在数栈中就只有一个数字，就是表达式的结果

二）中缀表达式转后缀表达式的思路步骤分析

1. 初始化两个栈：运算符栈是s1和储存中间结果的栈
2. 从左至右扫描中缀表达式
3. 遇到操作数时，将其压入S2
4. 遇到运算符时，比较其与S1栈顶运算符的优先级
   1） 如果S1为空，或者栈顶运算符为左括号，则直接将其运算符入栈
   2） 否则，若优先级比栈顶运算符的高，也将运算符压入s1
   3） 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到（1）与s1中的新的栈顶运算符相比较
5. 遇到括号时：
   1） 如果是左括号“（”，则直接压入s1
   2） 如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2,直到遇到左括号为止，此时将这一对括号丢弃
6. 重复步骤2至5，直到表达书的最右边
7. 将s1中剩余的运算符依次弹出并压入S2
8. 依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
   有了这两个思路，下面就是具体的实现方法

第一步先写两个方法中缀、后缀转list

    //将后缀表达式转成对应的list
    public static List<String> getListString(String suff) {
        String[] split = suff.split(" ");
        List<String> list = new ArrayList<String>();
        for (String item : split) {
            list.add(item);
        }
        return list;
    }

    /*将中缀表达式转成对应的list s="1+((2+3)*4)-5"*/
    public static List<String> toinfixExpression(String s) {
        List<String> list = new ArrayList<String>();
        int i = 0;
        String str;
        char c;
        do {
            /*如果c是一个非数字，则加入到list中*/
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                list.add("" + c);
                i++;
            } else {//如果是一个数 则考虑多位数
                str = "";
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;
                    i++;
                }
                list.add(str);
            }
        } while (i < s.length());
        return list;
    }

第二步完成中缀表达式转后缀表达式 这个比较难理解参考上面的思路（二）

  /*将中缀表达式对应的list转化为后缀表达式对应的list*/
    public static List<String> parsesuffix(List<String> ls) {
        Stack<String> s1 = new Stack<String>();//符号栈
        List<String> s2 = new ArrayList<String>();//储存中间结果的列表list2
        for (String item : ls) {
            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();//将(弹出s1栈，消除小括号
            } else {
                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;

    }

第三步实现计算后缀表达式的方法

 //完成对逆波兰表达式的运算
    /*
     * 从左到右依次扫描 将3和4入堆栈
     * 遇到+运算符，因此弹出4和3 计算出3+4的值 7 压入栈
     * 将5入栈
     * 接下来是*运算符 弹出5和7 计算出5*7=35压入栈
     * 将6压入栈
     * 最后是-运算符 计算出35-6的值29 即是最终的结果*/
    public static int calculate(List<String> ls) {

        Stack<String> stack = new Stack<String>();
        int res = 0;
        for (String item : ls) {
            if (item.matches("\\d+")) {
                stack.push(item);
            } else {
                int num1 = Integer.parseInt(stack.pop());
                int num2 = 0;
                if (!stack.empty()) {
                    num2 = Integer.parseInt(stack.pop());
                }
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    res = num2 - num1;
                } else if (item.equals("*")) {
                    res = num2 * num1;
                } else if (item.equals("-")) {
                    res = num2 / num1;
                } else {
                    throw new RuntimeException("运算符有误");
                }
                stack.push("" + res);

            }
        }
        return res;

    }

}
//补充一下比较操作符优先级的方法
class Operation {
    public static int getValue(String str) {
        switch (str) {
            case "+":
                return 0;

            case "-":
                return 0;

            case "*":
                return 1;

            case "/":
                return 1;

            default:
                return -1;
        }
    }
}

第四步就是最后测试了

public class PolandNotation {
    public static void main(String[] args) {
   /*(3+4)*5-6对应的前缀表达式是-*+3456
              对应的后缀的表达式34+5*6-
              此次是后綴演示
   * */
//        String suff = "3 4 + 5 * 6 -";
//        /*先将suff表达式放入到arrayList中
//         * 将Arraylist 传递给一个方法 遍历arraylist 配合栈完成计算*/
//        List<String> list = getListString(suff);
//        System.out.println(list);
//        int res = calculate(list);
//        System.out.println("res=" + res);
        String string="1+((2+3)*4)-5";
        List<String> ls1=toinfixExpression(string);
        System.out.println("中缀表达式="+ls1);
        List<String> ls2=parsesuffix(ls1);
        System.out.println("后缀表达式="+ls2);
        int res=calculate(ls2);
        System.out.println("res="+res);
    }

这是结果图