【算法与数据结构】－－栈的应用－逆波兰计算器完整版代码

逆波兰计算器完整版代码

１．将中缀表达式转为后缀表达式

２．正则表达式

３．递归调用

ReversePolishMultiCala.java代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;

/*
1.支持+-()* /
2.多位数，支持小数
3.兼容处理，过滤任何空白字符，包括空格、制表符、换页符
说明：逆波兰计算器完整版考虑的因素较多，下面给出完整版代码，使用：中缀表达式转后缀表达式
*/

public class ReversePolishMultiCala{
    /**
    * 匹配+-* /()运算符
     * */
    static final String SYMBOL = "\+|-|\*|/|\(|\)";
    //https://baijiahao.baidu.com/s?id=1636927461989417537&wfr=spider&for=pc
    //被static关键字修饰的不需要创建对象去调用，直接根据类名就可以去访问。
    //static可以让对象共享属性.用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；
    static final String LEFT = "(";
    static final String RIGHT = ")";
    static final String ADD = "+";
    static final String MINUS = "-";
    static final String TIMES = "*";
    static final String DIVISION = "/";
    //https://www.cnblogs.com/dolphin0520/p/3736238.html
    //对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；
    //如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

    /**
     * 加减　＋　－
     */
    static final int LEVEL_01 = 1;
    /**
     * 乘除　* /
     */
    static final int LEVEL_02 = 2;
    /**
     * 括号
     */
    static final int LEVEL_HIGH = Integer.MAX_VALUE;

    static Stack<String> stack = new Stack<>();
    static List<String> data = Collections.synchronizedList(new ArrayList<String>());
    //要实现List的线程安全,可以使用 Collections.synchronizedList

    /**
     * 去除所有空白符
     * @param s
     * @return
     */
    public static String replaceAllBlank(String s){
        // 正则表达式　\s+　匹配任何空白字符，包括空格、制表符、换页符等等，等价于[f

	v]
        //replaceFirst 替换首次匹配，replaceAll 替换所有匹配。
        return s.replaceAll("\s+", "");
    }
    /**
     * 判断是不是数字　int double long float
     * @param s
     * @return
     */
    public static boolean isNumber(String s){
        Pattern pattern = Pattern.compile("[-\+]?[.\d]*$");
        return pattern.matcher(s).matches();
    }
    /**
     * 判断是不是运算符
     * @param s
     * @return
     */
    public static boolean isSymbol(String s){
        return s.matches(SYMBOL);
    }
    /**
     * 匹配运算等级
     * @param s
     * @return
     */
    public static int calcLevel(String s){
        if("+".equals(s)||"-".equals(s)){
            return LEVEL_01;
        }else if("*".equals(s)||"/".equals(s)){
            return LEVEL_02;
        }
        return LEVEL_HIGH;
    }
    /**
     * 匹配
     * @param s
     * @throws Exception
     */
    public static List<String> doMatch(String s) throws Exception {
        if (s == null || "".equals(s.trim())) throw new RuntimeException("data is empty");
        if (!isNumber(s.charAt(0) + "")) throw new RuntimeException("data illeagle, start not with a number");
        s = replaceAllBlank(s);
        System.out.println("doMatch s"+s);

        String each;
        int start = 0;

        for (int i = 0; i < s.length(); i++) {
            if (isSymbol(s.charAt(i) + "")) {
                each = s.charAt(i) + "";
                System.out.println("eachSymbol"+each+i);
                //栈为空，“(”操作符，或者
                //操作符优先级大于栈顶优先级&&操作符优先级不是()的优先级,直接入栈;当遇到(时不能入栈，走else if.
                //注意逻辑运算符的优先级，先计算&&再计算||
                if (stack.isEmpty() || LEFT.equals(each) || calcLevel(each) > calcLevel(stack.peek())
                        && calcLevel(each) < LEVEL_HIGH) {
                    System.out.println(i+"	"+calcLevel(each)+"	"+LEVEL_HIGH);
                    System.out.println("each"+each);
                    stack.push(each);
                } else if (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {
                    //栈非空，操作符优先级小于等于栈顶优先级时出栈入列，直到栈为空，或者遇到了(,最后操作符入栈
                    while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {
                        if (calcLevel(stack.peek()) == LEVEL_HIGH) {
                            break;
                        }
                        data.add(stack.pop());
                    }
                    stack.push(each);
                } else if (RIGHT.equals(each)) {
                    //匹配到")"操作符，依次出栈入列直到空栈或者遇到第一个"("操作符，此时"("出栈
                    while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())) {
                        if (LEVEL_HIGH == calcLevel(stack.peek())) {
                            stack.pop();
                            break;
                        }
                        data.add(stack.pop());
                    }
                }
                start = i;
            } else if (i == s.length() - 1 || isSymbol(s.charAt(i + 1) + "")) {
                each = (start == 0 ? s.substring(start, i + 1) : s.substring(start + 1, i + 1));
                System.out.println("eachNum"+each+'	'+i);
                //如果start为0，each就是将s截取(start, i + 1)
                //substring() 方法返回字符串的子字符串。
                if (isNumber(each)) {
                    data.add(each);
                    continue;
                }
                throw new RuntimeException("data not match number");
            }
        }
        //如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为/,栈底为+，
        //应该依次出栈入列，可以直接翻转整个stack添加到队列
        Collections.reverse(stack);
        data.addAll(new ArrayList<>(stack));

        System.out.println("doMatch"+data);
        return data;
    }
    /**
     * 计算结果
     * @param list
     * @return
     */
    public static Double doCalc(List<String> list){
        Double d = 0d;
        if(list == null || list.isEmpty()){
            return null;
        }
        if(list.size() == 1){
            //当list中只有一个元素时即是最终结果
            System.out.println(list);
            d = Double.valueOf(list.get(0));
            //System.out.println(d);
            return d;
        }
        ArrayList<String> list1 = new ArrayList<>();
        for(int i = 0;i<list.size();i++){
            list1.add(list.get(i));//获取后缀表达式列表的每一个元素并添加到新列表list1中
            System.out.println("doCalc"+list1+i);
            if(isSymbol(list.get(i))){
                Double d1 = doTheMath(list.get(i-2),list.get(i-1),list.get(i));
                list1.remove(i);//在新列表中删除第i个字符
                list1.remove(i-1);//在新列表中删除第i-1个数字
                list1.set(i-2,d1+"");//在新列表中用d1代替第i-2个数字
                list1.addAll(list.subList(i+1,list.size()));//将原始列表剩下的数字和运算符添加到新列表中
                break;
            }
        }
        doCalc(list1);//递归调用此方法
        return d;
    }
    /**
     *运算
     * @param s1
     * @param s2
     * @param symbol
     * @return
     */
    public static Double doTheMath(String s1, String s2, String symbol){
        Double result;
        switch (symbol){
            case ADD:
                result = Double.valueOf(s1) + Double.valueOf(s2);
                break;
            case MINUS:
                result = Double.valueOf(s1) - Double.valueOf(s2);
                break;
            case TIMES:
                result = Double.valueOf(s1) * Double.valueOf(s2);
                break;
            case DIVISION:
                result = Double.valueOf(s1) / Double.valueOf(s2);
                break;
            default:
                result = null;
        }
        return result;
    }

    public static void main(String[] args){
        //String math = "9+(3-1)*3+10/2";
        String math = "12.8 + (2 - 3.55)*4+10/5.0";//8.6
        try{
            doCalc(doMatch(math));
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

运行结果：

[12.8, 2, 3.55, -, 4, *, +, 10, 5.0, /, +]
[8.600000000000001]

有关递归和正则表达式的内容后面继续学习，另外还有一些java的基础知识需要补充。