通过后缀表达式进行算数表达式求值(栈的应用)

这是一道面试时遇到的题目,那时没答出来,之后查了相关资料。在这里将自己对于这个问题的理解做下记录,之后便于查阅。

题目:给定一个算数表达式,用程序进行算数表达式求值。比如求解1×2+6×(3-4÷5)。

思路:先用运算符栈将常见的中缀表达式转化为后缀表达式(逆波兰表达式)。再通过操作数栈进行后缀表达式的求值。

后缀表达式:操作数在前,运算符在后,且运算符按优先级从高到低排序。

运算符有+,-,×,÷,(,)。其中‘×’,‘÷’的优先级高于‘+’,‘-’的优先级;‘(’的优先级大于之前所有运算符的优先级,小于之后所有运算符的优先级。‘)’无所谓优先级,碰到’)‘时需要将运算符栈中’(‘之上的运算符弹出来,最后将’('也弹出来。其中,同优先级的运算符,先出现运算符的优先级高。

  1. 将中缀表达式转化为后缀表达式

    下面描述下将常见的中缀表达式转换成后缀表达式的做法:从前到后扫描算数表达式。如果是数字,直接添加到后缀表达式的最后。如果是运算符且运算符栈为空时,将运算符添加到运算符栈中。如果运算符栈不为空,需要进行多情况处理

    (1)如果是’+’,’-‘运算符,它们的优先级只比’(‘高,所以需要不断弹出运算符栈中的运算符,直到栈为空或者栈顶为’('运算符;

    (2)如果是’×’,‘÷’运算符,它们的优先级比’(‘、’+’、’-‘高,所以需要不断弹出运算符栈中的运算符,直到栈为空或者栈顶为’(’、’+‘,’-'运算符;

    (3)如果是’('运算符,直接入栈;

    (4)如果是’)‘运算符,不断弹出运算符,直到栈顶为’(’,将’('运算符弹出;

  2. 求解后缀表达式

    得到后缀表达式之后,通过操作数栈就可以计算后缀表达式的值。具体做法为:从头到尾扫描后缀表达式,如果是操作数,入栈;如果是运算符,弹出两个操作数,先弹出的为右操作数,后弹出的为左操作数,计算完之后将结果入栈。扫描完之后,栈中的结果即为表达值的值。

下面是具体的代码(Java实现):

import java.util.Scanner;
import java.util.Stack;

/**
 * 数学表达式求值
 * 思路:
 * 先用栈转换成后缀表达式,然后用栈对后缀表达式求值
 * @Author CHT
 */
public class Main {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String expression = null;
        while (true){
            expression = scanner.next();
            System.out.println(String.format("%.2f",new Main().resultOfMathematicalExpression(expression)));
        }
    }
    /**
     * 根据后缀表达式计算结果
     * @param mathematicalExpression
     * @return
     */
    private double resultOfMathematicalExpression(String mathematicalExpression){
        String postExpression = postMathematicalExpression(mathematicalExpression);
        String[] strings = postExpression.split("#");
        Stack<Double> operandStack = new Stack<>();
        double operandLeft = 0,operandRight = 0;
        for (String string:strings) {
            switch (string){
                case "+":{
                    operandRight = operandStack.pop();
                    operandLeft = operandStack.pop();
                    operandStack.push(operandLeft+operandRight);
                    break;
                }
                case "-":{
                    operandRight = operandStack.pop();
                    operandLeft = operandStack.pop();
                    operandStack.push(operandLeft-operandRight);
                    break;
                }
                case "*":{
                    operandRight = operandStack.pop();
                    operandLeft = operandStack.pop();
                    operandStack.push(operandLeft*operandRight);
                    break;
                }
                case "/":{
                    operandRight = operandStack.pop();
                    operandLeft = operandStack.pop();
                    operandStack.push(operandLeft/operandRight);
                    break;
                }
                default:
                    operandStack.push(Double.parseDouble(string));
            }
        }
        return operandStack.pop();
    }

    /**
     * 将中缀表达式转换成后缀表达式。用'#'分隔
     * @param mathematicalExpression
     * @return
     */
    private String postMathematicalExpression(String mathematicalExpression){
        //后缀表达式
        StringBuilder postExpression = new StringBuilder();
        //操作符栈
        Stack<Character> operatorStack = new Stack<>();
        //数字直接添加到后缀表达式,运算符按照优先级从高到低排序
        for (int i = 0; i < mathematicalExpression.length(); i++) {
            //0~9直接添加到后缀表达式
            if (mathematicalExpression.charAt(i)>='0' && mathematicalExpression.charAt(i)<='9'){
                postExpression.append(mathematicalExpression.charAt(i));

            }//'+' '-' 运算符的优先级只比 '(' 高
            else if (mathematicalExpression.charAt(i)=='+' || mathematicalExpression.charAt(i)=='-'){
                postExpression.append('#');
                if (operatorStack.empty() || operatorStack.peek()=='('){
                    operatorStack.push(mathematicalExpression.charAt(i));
                }else {
                    while (!operatorStack.empty() && operatorStack.peek()!='('){
                        postExpression.append(operatorStack.pop()).append('#');
                    }
                    operatorStack.push(mathematicalExpression.charAt(i));
                }
            }//'*' '/'的优先级比 '+' '-' '('高
            else if (mathematicalExpression.charAt(i)=='*' || mathematicalExpression.charAt(i)=='/'){
                postExpression.append('#');
                if (operatorStack.empty() || operatorStack.peek()=='(' || operatorStack.peek()=='+' || operatorStack.peek()=='-'){
                    operatorStack.push(mathematicalExpression.charAt(i));
                }else {
                    while (!operatorStack.empty() && operatorStack.peek()!='(' && operatorStack.peek()!='+' && operatorStack.peek()!='-'){
                        postExpression.append(operatorStack.pop()).append('#');
                    }
                    operatorStack.push(mathematicalExpression.charAt(i));
                }
            }// '('的优先级比前面的运算符都高,比后面的运算符优先级低
            else if (mathematicalExpression.charAt(i)=='('){
                operatorStack.push(mathematicalExpression.charAt(i));
            }// 碰到')',将'('之前的运算符弹出,最后将'('弹出
            else if (mathematicalExpression.charAt(i)==')'){
                postExpression.append('#');
                while (operatorStack.peek()!='('){
                    postExpression.append(operatorStack.pop()).append('#');
                }
                postExpression.deleteCharAt(postExpression.length()-1);
                operatorStack.pop();
            }
        }
        while (!operatorStack.empty()){
            postExpression.append("#").append(operatorStack.pop());
        }
        return postExpression.toString();
    }

参考:

https://blog.csdn.net/smile_zhangw/article/details/82916346

https://blog.csdn.net/qq_40395874/article/details/79904233

你可能感兴趣的:(数据结构与算法)