[数据结构与算法]栈的应用：计算 2*2+(10-2)/(101-50*2)*3-2+5 表达式的值

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

public class ParseCalcMode {

    public static List parse(String calcMode) {
        List elementsList = new ArrayList();
        Pattern p = Pattern.compile("(\d+)|([-+*/])|([\(\)])");

        Matcher m = p.matcher(calcMode);
        while (m.find()) {
            elementsList.add(m.group(0));
            //            System.out.println(m.groupCount());
        }
        return elementsList;
    }

    /**
     * 进行混合运算
     * 
     * @param srcStack
     * @return
     */

    private static String calcMix(Stack srcStack) {
        Stack destStack = new Stack();
        // 否则有一个完成的带括计算式，则执行计算操作
        String data1;
        String opr;
        String data2;
        //
        String elem = (String) srcStack.pop();

        // 先执行乘除表式
        while (!elem.equals("(")) {
            if ("*".equals(elem) || "/".equals(elem)) {

                data1 = (String) srcStack.pop();
                opr = elem;
                data2 = (String) destStack.pop();

                Stack tmpStack = new Stack();
                // 如果是连续的乘除，则把连续乘除表达式存入一个临时栈中，待整个连续乘除表达时放完后计算临栈
                while (!srcStack.isEmpty()
                        && (srcStack.peek().equals("*") || srcStack.peek().equals("/"))) {
                    // 第一次放时
                    if (tmpStack.isEmpty()) {
                        tmpStack.push(data2);
                        tmpStack.push(elem);
                        tmpStack.push(data1);
                    } else {
                        tmpStack.push(srcStack.pop());
                        tmpStack.push(srcStack.pop());
                    }
                    System.out.println("临时栈 tmpStack=" + tmpStack);
                }

                // 如果不是连续的乘除时
                if (tmpStack.isEmpty()) {

                    switch (opr.charAt(0)) {
                    case '*':
                        destStack.push(String.valueOf(Integer.parseInt(data1)
                                * Integer.parseInt(data2)));
                        break;

                    case '/':
                        destStack.push(String.valueOf(Integer.parseInt(data1)
                                / Integer.parseInt(data2)));
                        break;
                    }

                } else {

                    destStack.push(calcSameLevel(tmpStack));

                }

                System.out.println("乘除计算后 destStack = " + destStack);
            } else {
                // 如果不是乘除时直接放入目标栈中
                destStack.push(elem);
                System.out.println("非乘除直接放入 destStack = " + destStack);
            }

            if (srcStack.isEmpty()) {
                break;
            }
            elem = (String) srcStack.pop();
        }

        // 如果没有加减时
        if (destStack.size() == 1) {
            return (String) destStack.pop();
        } else {
            // 后执行加减表式
            return calcSameLevel(destStack);
        }

    }

    /**
     * 同级运算
     * 
     * @param destStack
     * @return
     */
    private static String calcSameLevel(Stack destStack) {
        String tmpResult = null;
        String data1;
        String opr;
        String data2;

        while (!destStack.isEmpty()) {
            if (tmpResult == null) {
                data1 = (String) destStack.pop();

                opr = (String) destStack.pop();

                data2 = (String) destStack.pop();

            } else {
                data1 = tmpResult;
                opr = (String) destStack.pop();
                data2 = (String) destStack.pop();
            }
            switch (opr.charAt(0)) {
            case '+':
                tmpResult = String.valueOf(Integer.parseInt(data1)
                        + Integer.parseInt(data2));
                break;

            case '-':
                tmpResult = String.valueOf(Integer.parseInt(data1)
                        - Integer.parseInt(data2));
                break;
            case '*':
                tmpResult = String.valueOf(Integer.parseInt(data1)
                        * Integer.parseInt(data2));
                break;

            case '/':
                tmpResult = String.valueOf(Integer.parseInt(data1)
                        / Integer.parseInt(data2));
                break;
            }
        }
        System.out.println("同优先级运算结果=" + tmpResult);
        return tmpResult;
    }

    public static void main(String[] args) {
        String str = "2*2+(10-2)/(101-50*2)*3-2+5";
        // String str ="2*(3+2-1)";
        List elementsList = parse(str);
        System.out.println("组成算术表达式的各元素为＝" + elementsList);

        // 存入整体算术表达式各元素，在放入过程中如果遇到括号则要先计算括号里的算术式后再把计算出的结果放入栈中
        Stack srcStack = new Stack();
        for (int i = 0; i < elementsList.size(); i++) {
            String elem = (String) elementsList.get(i);
            if (elem.equals(")")) {
                System.out.println("遇到右括号，准备计算括号里的算术式，srcStack = " + srcStack);
                srcStack.push(calcMix(srcStack));
                System.out.println("括号里的算术式计算完毕，srcStack = " + srcStack);
            } else {
                // 如果不为右括号放入栈
                srcStack.push(elem);
                System.out.println("非右括号，直接入栈 srcStack = " + srcStack);
            }
        }
        System.out.println(srcStack);
        // 所有括号里表达式计算完后计算整体算术式
        if (srcStack.size() > 1) {
            System.out.println("结果为=" + calcMix(srcStack));
        } else {
            System.out.println("结果为=" + srcStack.pop());
        }
    }
}

组成算术表达式的各元素为＝[2, *, 2, +, (, 10, -, 2, ), /, (, 101, -, 50, *, 2, ), *, 3, -, 2, +, 5]
非右括号，直接入栈 srcStack = [2]
非右括号，直接入栈 srcStack = [2, *]
非右括号，直接入栈 srcStack = [2, *, 2]
非右括号，直接入栈 srcStack = [2, *, 2, +]
非右括号，直接入栈 srcStack = [2, *, 2, +, (]
非右括号，直接入栈 srcStack = [2, *, 2, +, (, 10]
非右括号，直接入栈 srcStack = [2, *, 2, +, (, 10, -]
非右括号，直接入栈 srcStack = [2, *, 2, +, (, 10, -, 2]
遇到右括号，准备计算括号里的算术式，srcStack = [2, *, 2, +, (, 10, -, 2]
非乘除直接放入 destStack = [2]
非乘除直接放入 destStack = [2, -]
非乘除直接放入 destStack = [2, -, 10]
同优先级运算结果=8
括号里的算术式计算完毕，srcStack = [2, *, 2, +, 8]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, (]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -, 50]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -, 50, *]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, (, 101, -, 50, *, 2]
遇到右括号，准备计算括号里的算术式，srcStack = [2, *, 2, +, 8, /, (, 101, -, 50, *, 2]
非乘除直接放入 destStack = [2]
乘除计算后 destStack = [100]
非乘除直接放入 destStack = [100, -]
非乘除直接放入 destStack = [100, -, 101]
同优先级运算结果=1
括号里的算术式计算完毕，srcStack = [2, *, 2, +, 8, /, 1]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -, 2]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -, 2, +]
非右括号，直接入栈 srcStack = [2, *, 2, +, 8, /, 1, *, 3, -, 2, +, 5]
[2, *, 2, +, 8, /, 1, *, 3, -, 2, +, 5]
非乘除直接放入 destStack = [5]
非乘除直接放入 destStack = [5, +]
非乘除直接放入 destStack = [5, +, 2]
非乘除直接放入 destStack = [5, +, 2, -]
非乘除直接放入 destStack = [5, +, 2, -, 3]
临时栈 tmpStack=[3, *, 1]
临时栈 tmpStack=[3, *, 1, /, 8]
同优先级运算结果=24
乘除计算后 destStack = [5, +, 2, -, 24]
非乘除直接放入 destStack = [5, +, 2, -, 24, +]
非乘除直接放入 destStack = [5, +, 2, -, 24, +, 2]
乘除计算后 destStack = [5, +, 2, -, 24, +, 4]
同优先级运算结果=31
结果为=31

上面实现的有点复杂了，下面想了下使用 LinkedList 可能要简单一些

使用LinkedList实现

import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 使用 LinkedList 计算算术表达试的值
 * @author jzj
 *
 */
public class ArithmeticCalc {
    /**
     * 提取算术表达式中的括号部分
     * 
     * @param expression 算术表达式
     * @return
     */
    public static String bracket(String expression) {
        Pattern p = Pattern.compile("\(([^\(]+?)\)");

        Matcher m = p.matcher(expression);

        if (m.find()) {
            return m.group(1);
        }
        else {
            return null;
        }
    }

    /**
     * 分解算术表达式
     * 
     * @param expression 算术表达式
     * @return
     */
    public static LinkedList parse(String expression) {
        LinkedList elemList = new LinkedList();
        //注，减号要放在第一个，放在中间时代表特殊意义
        Pattern p = Pattern.compile("(\d+)|[-+*/()]");

        Matcher m = p.matcher(expression);
        while (m.find()) {
            elemList.add(m.group(0));
        }
        return elemList;
    }

    /**
     * 计算不带括号的算术表达式
     * @param expression 不带括号的算术表达式
     * @return String 返回计算结果
     */
    private static String caclExpression(String expression) {
        //分解算术表达式
        LinkedList linkList = parse(expression);

        //先计算乘除
        for (int i = 0; i < linkList.size(); i++) {
            String e = (String) linkList.get(i);
            if ("*".equals(e) || "/".equals(e)) {
                String oprData1 = (String) linkList.remove(i - 1);

                String opr = (String) linkList.remove(i - 1);

                String oprData2 = (String) linkList.remove(i - 1);

                //计算完成后将结果插入到原表达式所在位置
                linkList.add(i - 1, cacl(oprData1, opr, oprData2));

                i = i - 1 - 1;//从结果位置向后计算
            }
        }

        //再算计算加减
        for (int i = 0; i < linkList.size() && linkList.size() > 1; i++) {
            String oprData1 = (String) linkList.remove(i);
            String opr = (String) linkList.remove(i);
            String oprData2 = (String) linkList.remove(i);
            //计算完成后将结果插入到原表达式所在位置

            linkList.add(i, cacl(oprData1, opr, oprData2));
            i = i - 1;//从结果位置向后计算
        }

        return (String) linkList.get(0);
    }

    /**
     * 两个数计算
     * @param oprData1 操作数一
     * @param opr 操作
     * @param oprData2 操作数二
     * @return String 返回计算结果
     */
    private static String cacl(String oprData1, String opr, String oprData2) {
        switch (opr.charAt(0)) {
        case '+':
            return String.valueOf(Integer.parseInt(oprData1)
                    + Integer.parseInt(oprData2));

        case '-':
            return String.valueOf(Integer.parseInt(oprData1)
                    - Integer.parseInt(oprData2));
        case '*':
            return String.valueOf(Integer.parseInt(oprData1)
                    * Integer.parseInt(oprData2));

        case '/':
            return String.valueOf(Integer.parseInt(oprData1)
                    / Integer.parseInt(oprData2));
        default:
            return "";
        }
    }

    public static void main(String[] args) {
        String expression = "2*2+(2+5/(10-2*(1+1)*2-1))/(7-3*2)*3-2+5";
        String bracketStr;
        //如果算术表达式中有括号，则先计算括号中的表达式
        while ((bracketStr = bracket(expression)) != null) {
            String result = caclExpression(bracketStr);
            System.out.println(bracketStr + "=" + result);
            bracketStr = bracketStr.replaceAll("\*", "\\*").replaceAll(
                    "\+", "\\+");
            expression = expression.replaceAll("\(" + bracketStr + "\)",
                    result);
        }

        System.out.println(expression + "=" + caclExpression(expression));
    }
}