编程题目（三）使用栈计算字符串表达式的值

最新推荐文章于 2022-11-21 22:57:57 发布

ZmyCoder

最新推荐文章于 2022-11-21 22:57:57 发布

阅读量564

点赞数

分类专栏：面试 # 编程题目文章标签： java 数据结构散列表

本文链接：https://blog.csdn.net/a14654/article/details/125103189

版权

面试同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

编程题目

3 篇文章 0 订阅

订阅专栏

要求

写一个函数，传入字符串表达式，返回表达式的结果，如传入"100+4*（30-100/5）"，结果返回140（不能用JDK内置表达式求值和其它第三方框架）。

代码实现

import java.util.*;

public class Test {

    public static void main(String[] args) {
        System.out.println(getByExpress(express));
    }
    
    final static String express = "250+10/2+8*(30-5)";

    final static String JIAFA = "+";
    final static String JIANFA = "-";
    final static String CHENGFA = "*";
    final static String CHUFA = "/";
    final static String LEFT_BRACKET = "(";
    final static String RIGHT_BRACKET = ")";

    final static HashMap<String,Integer> YXJ = new HashMap<>();
    static {
        YXJ.put("+",1);
        YXJ.put("-",1);
        YXJ.put("*",2);
        YXJ.put("/",2);
        YXJ.put("(",3);
        YXJ.put(")",3);
    }

    /**
     * @Description: 使用栈实现
     */
    static int getByExpress(String express) {
        Map<String, List<String>> stringListMap = decomposeString(express);
        Stack<Integer> numberStack = new Stack<>();
        Stack<String> operationStack = new Stack<>();
        List<String> alls = stringListMap.get("alls");
        List<String> postfixExpression = getPostfixExpression(stringListMap);
        int result = getResult(postfixExpression, stringListMap);
        return result;
    }

    static boolean isNumber(char c) {
        return c >= '0' && c <= '9';
    }

    static Map<String,List<String>> decomposeString(String express) {
        express = express.trim();
        Map<String,List<String>> result = new HashMap<>();
        List<String> numbers = new ArrayList<>();
        List<String> operations = new ArrayList<>();
        List<String> alls = new ArrayList<>();
        StringBuilder tempNumber = new StringBuilder();
        String operation = "";
        int length = express.length();
        for (int i = 0; i < length; i++) {
            char c = express.charAt(i);
            if (isNumber(c)) {
                //拼接数字
                tempNumber.append(c);
            } else {
                //得到一个数字和一个运算符
                operation = String.valueOf(c);
                String s = tempNumber.toString();
                if (!s.isBlank()) {
                    numbers.add(s);
                    alls.add(s);
                }
                operations.add(operation);
                alls.add(operation);
                tempNumber = new StringBuilder();
            }
        }
        if (!tempNumber.toString().isBlank()) {
            numbers.add(tempNumber.toString());
            alls.add(tempNumber.toString());
        }
        result.put("numbers",numbers);
        result.put("operations", operations);
        result.put("alls", alls);
        return result;

    }

    /**
     * @Description: 获取后缀表达式
     */
    static List<String> getPostfixExpression(Map<String,List<String>> mapStrings) {
        List<String> numbers = mapStrings.get("numbers");
        List<String> operations = mapStrings.get("operations");
        List<String> alls = mapStrings.get("alls");

        Stack<String> operationsStack = new Stack<>();
        List<String> result = new ArrayList<>();

        for (int i = 0; i < alls.size(); i++) {
            String s = alls.get(i);
            //数字
            if (numbers.contains(s)) {
                result.add(s);
            } else {//操作符
                //空栈 或者 优先级更高才可以入栈
                if (operationsStack.isEmpty() || LEFT_BRACKET.equals(operationsStack.peek()) || (YXJ.get(s) > YXJ.get(operationsStack.peek()) && !RIGHT_BRACKET.equals(s)) ) {
                    operationsStack.push(s);
                } else{
                    //如果是右括号，则寻找左括号出栈
                    if (RIGHT_BRACKET.equals(s)) {
                        String operation = operationsStack.pop();
                        while (!LEFT_BRACKET.equals(operation)) {
                            result.add(operation);
                            operation = operationsStack.pop();
                        }
                    } else {
                        //优先级低，符号出栈
                        result.add(operationsStack.pop());
                        while (!operationsStack.isEmpty() && YXJ.get(s) <= YXJ.get(operationsStack.peek())) {
                            result.add(operationsStack.pop());
                        }
                        operationsStack.push(s);
                    }
                }
            }
        }
        //所有符号出栈，结束
        while (!operationsStack.isEmpty()) {
            result.add(operationsStack.pop());
        }
        return result;
    }

    /**
     * @Description: 获得运算结果
     */
    static int getResult(List<String> list, Map<String,List<String>> mapStrings) {
        List<String> numbers = mapStrings.get("numbers");
        List<String> operations = mapStrings.get("operations");
        Stack<Integer> numberStack = new Stack<>();
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (numbers.contains(s)) {
                numberStack.push(Integer.valueOf(s));
            } else {
                Integer pop1 = numberStack.pop();
                Integer pop2 = numberStack.pop();
                int temp;
                if (JIAFA.equals(s)) {
                    temp = pop1 + pop2;

                } else if (JIANFA.equals(s)) {
                    temp = pop2-pop1;

                } else if (CHENGFA.equals(s)) {
                    temp = pop1 * pop2;
                } else {
                    temp = pop2 / pop1;
                }
                numberStack.push(temp);
            }
        }
        return numberStack.pop();
    }

}

思路

1.中缀表达式转后缀表达式（栈的应用)

中缀表达式9+（3−1）∗3+10/29+（3−1）∗3+10/2转化为后缀表达式为931−3∗+102/+931−3∗+102/+.
规则：从左到右遍历中缀表达式的每一数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于栈顶符号（乘除优先加减）则栈顶元素依次出栈并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。

a.初始化一空栈，用来对符号进出栈使用。

b.第一个字符是数字9，输出9，后面是符号“+”，进栈。

c.第三个字符是“（”，依然是符号，因其只是左括号，还没有配对，故进栈。

d.第四个字符是数字3，输出，总表达式为9 3，接着是“-”，进栈。

e.接下来是数字1，输出，总表达式为9 3 1，后面是符号“）”，此时，我们需要去匹配此前的“（”，所以栈顶依次出栈，并输出，直到“（”出栈为止。此时左括号上方只有“-”，因此输出“-”。总的表达式为9 3 1 -。

f.接着是数字3，输出，总的表达式为9 3 1 - 3.紧接着是符号“*”，因为此时的栈顶符号为“+”号，优先级低于“*”，因此不输出，“*”进栈。

g.之后是符号“+”，此时当前栈顶元素“*”比这个“+”的优先级高，因此栈中元素出栈并输出（没有比“+”更低的优先级，所以全部出栈），总输出表达式为9 3 1 - 3 * +。然后将当前这个符号“+”进栈。

h.紧接着数字10，输出，总表达式为9 3 1 - 3 * + 10。后是符号“/”，所以“/”进栈。

i.最后一个数字2，输出，总的表达式为9 3 1 - 3 * + 10 2。

j.因已经到最后，所以将栈中符号全部出栈并输出。最终输出的后缀表达式结果为9 3 1 - 3 * + 10 2 / +。
12345678910111213141516171819

2.后缀表达式计算结果（栈的应用）

后缀表达式为：931−3∗+102/+931−3∗+102/+

规则为：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。

a.初始化一个空栈。此栈用来对要运算的数字进行进出使用。

b.后缀表达式中前三个是、都是数字，所以9 3 1 进栈。

c.接下来是“-”，所以将栈中的1出栈作为减数，3出栈作为被减数，并运算3-1得到2，再讲2进栈。

d.接着是数字3进栈。

e.后面是“*”，也就意味着栈中3和2出栈，2与3相乘，得到6，并将6进栈。

f.下面是“+”，所以栈中6和9出栈，9和6相加，得到15，将15进栈。

g.接着是10和2两数字进栈。

h.接下来是符号“/”，因此，栈顶的2与10出栈，10与2相除，得到5，将5进栈。

i.最后一个是符号“+”，所以15与5出栈并相加，得到20，讲20进栈。

j.结果是20出栈，栈变为空。