java 栈 Stack类 栈的应用--中缀表达式转后缀表达式并计算

为什么80%的码农都做不了架构师？>>>   

package com.test;

import java.math.BigDecimal;
import java.util.Stack;

/**
 * 利用栈实现中缀表达式转后缀表达式,并提供对后缀表达式的计算
 * Created by jockiller on 2016/3/4.
 */
public class BiaoDaShi {

    public static void main(String[] args) {
        String bds = "60/(5-2) + 5 *(20 *(3-1))";
        System.out.println(bds);
        String hzBds = revertBds(bds);
        System.out.println(hzBds);

        BigDecimal res = calculate(hzBds);
        System.out.println(res);
    }

    /**
     * 对后缀表达式进行计算
     * @param hzBds
     * @return
     */
    private static BigDecimal calculate(String hzBds) {
        Stack<BigDecimal> stack = new Stack<>();
        String[] split = hzBds.split(" ");
        for (String s : split) {
            if (null == s || "".equals(s.trim())) continue;
            if (YunSuanFu.isYunSuanFu(s.charAt(0))){
                //如果是运算符 则将堆中的两个值拿出来计算 然后放回堆中
                stack.push(stackoperate(stack.pop(),stack.pop(),s.charAt(0)));
            }else {
                stack.push(new BigDecimal(s));
            }
        }
        return stack.pop();
    }

    /**
     * 根据运算符进行计算
     * @param v1
     * @param v2
     * @param c
     * @return
     */
    private static BigDecimal stackoperate(BigDecimal v2, BigDecimal v1, char c) {
        YunSuanFu yun = YunSuanFu.parse(c);
        switch (yun){
            case MULTIPLY:
                return v2.multiply(v1);
            case DIVIDE:
                return v1.divide(v2);
            case ADD:
                return v1.add(v2);
            case MINUS:
                return v1.subtract(v2);
            default:
                throw new RuntimeException("不支持的运算");
        }
    }


    /**
     * 中缀表达式转换为后缀表达式
     *
     * @param bds 中缀表达式
     * @return
     */
    private static String revertBds(String bds) {
        Stack<Character> stack = new Stack();
        String s = bds.replaceAll(" ", "");
        StringBuffer sb = new StringBuffer();
        boolean nextPop = false;
        char ic;
        for (int i = 0; i < s.length(); i++) {
            if (YunSuanFu.isYunSuanFu(ic = s.charAt(i))) {
                if (nextPop) {
                    nextPop = false;
                    sb.append(" ").append(stack.pop());
                    sb.append(" ").append(stack.pop());
                }
                //判断当前运算符是否是右括号
                if (ic == YunSuanFu.RIGHT.ele) {
                    //将栈中上一个左括号之前的运算符出栈
                    while (true) {
                        if ((ic = stack.pop()) != YunSuanFu.LEFT.ele) {
                            sb.append(" ").append(ic);
                        } else {
                            // 如果左括号之前的一个运算符是或者除 那么也需要出栈
                            if (stack.peek() == YunSuanFu.DIVIDE.ele || stack.peek() == YunSuanFu.MINUS.ele) {
                                sb.append(" ").append(stack.pop());
                            }
                            break;
                        }
                    }
                } else if (stack.size() > 1 && YunSuanFu.isPriorityHigh(ic, stack.peek())) {
                    //判断当前栈中是否有一个运算符 并且新运算符的优先级高于当前优先级,如果是 则下一位的数字输出 并将栈中的两个运算符出栈
                    nextPop = true;
                    stack.push(ic);
                    sb.append(" ");
                } else {
                    //如果是运算符 则入栈
                    stack.push(ic);
                    sb.append(" ");
                }
            } else {
                sb.append(ic);
            }

            if (i == s.length() - 1) {
                int size = stack.size();
                for (int j = 0; j < size; j++) {
                    sb.append(" ").append(stack.pop());
                }
            }
        }
        return sb.toString();

    }

    private enum YunSuanFu {
        ADD('+'),
        MINUS('-'),
        MULTIPLY('*'),
        DIVIDE('/'),
        LEFT('('),
        RIGHT(')'),;

        private char ele;

        YunSuanFu(char ele) {
            this.ele = ele;
        }

        /**
         * 判断是不是运算符
         *
         * @param c
         * @return
         */
        public static boolean isYunSuanFu(char c) {
            for (YunSuanFu fu : YunSuanFu.values()) {
                if (fu.ele == c) {
                    return true;
                }
            }
            return false;
        }

        /**
         * 转换运算符
         *
         * @param c
         * @return
         */
        public static YunSuanFu parse(char c) {
            for (YunSuanFu fu : YunSuanFu.values()) {
                if (fu.ele == c) {
                    return fu;
                }
            }
            throw new RuntimeException("未知运算符");
        }


        /**
         * 判断第一个运算符优先级是否高于第二个
         *
         * @param c1
         * @param c2
         * @return
         */
        public static boolean isPriorityHigh(char c1, char c2) {
            if ((c1 == MULTIPLY.ele || c1 == DIVIDE.ele) && (c2 == ADD.ele || c2 == MINUS.ele)) {
                return true;
            }
            return false;
        }


    }


}

转载于:https://my.oschina.net/razox/blog/851802