栈应用4 计算中缀表达式

来源：互联网发布：蓝可儿事件真相知乎编辑：程序博客网时间：2024/06/08 18:33

应用3中计算的是后缀表达式，需要先将中缀表达式转换为后缀表达式再计算，整个表达式会扫描两次，下面我们实现只扫描一次实现计算中缀表达式。‘

解决这个问题需要两个栈，一个是操作数栈，一个是运算符栈。

一、算法逻辑

1）创建操作数栈

2）创建运算符栈

我们定义运算操作为操作数栈中弹出两个元素，运算符栈中弹出元素，进行计算后，结果压入操作数栈。

3）扫描中缀表达式，进行遍历

a.如果字符是操作数，则压入操作数栈

b.如果左括号，压入运算符栈。

c.如果是右括号，循环执行运算操作，直至弹出的是左括号。

d.如果是运算符，如果运算符栈不为空，则判断运算栈栈顶运算符是不否为左括号，且优先级大于当前运算符，则执行运算操作。当前运算符压入运算符栈。

4）扫描完后，如果运算符栈不为空，就循环运算操作执行，直至运算符栈为空。操作数栈中最后栈顶元素就是运算结果。

二、算法实现

import java.util.Stack;
/**计算后缀表达式
 * Created by Administrator on 2017/6/25 0025.
 */
public class Operator2Stack {
    public static void main(String[] args) {
        String str = "(1+2)*5+(3*6+2)*2+(3*6-2)*3";
        System.out.println(useNum(str));
    }
    public static int useNum(String str){
        char[] chars = str.toCharArray();
        //创建操作数栈
        Stack<Integer> stack = new Stack<>();
        //创建运算符栈
        Stack<String> stack1 = new Stack<>();
        for(char c : chars){
            String s = String.valueOf(c);
            if(!OperatorEnum.isOperator(s)){
                //如果是操作数就压入到操作数栈
                stack.push(Integer.valueOf(s));
            }else if(OperatorEnum.isLeftSign(s)){
                //如果是左括号，则忽略
                continue;
            }else if(OperatorEnum.isRightSign(s)){
                //如果是右括号，就弹出两个操作数，弹出一个运算符，计算之后，结果压入操作数栈
                //弹出操作数
                Integer a = stack.pop();
                Integer b = stack.pop();
                //弹出元素符
                String operator = stack1.pop();
                stack.push(useOperator(operator,b,a));
            }else{
                //如果是运算符
                if(!stack1.isEmpty()){
                    //如果运算符栈不为空，且上一个运算符的优先级比当前运算符优先级大，就执行运算操作
                    String peek = stack1.peek();
                    if(OperatorEnum.getOperatorLevel(s) < OperatorEnum.getOperatorLevel(peek)){
                        peek = stack1.pop();
                        Integer a = stack.pop();
                        Integer b = stack.pop();
                        stack.push(useOperator(peek,b,a));
                    }
                }
                //当前运算符压入运算符栈
                stack1.push(s);
            }
        }
        //遍历完后，如果运算符栈不为空，就循环执行运算操作，直至操作符栈为空
        while(!stack1.isEmpty()){
            String pop = stack1.pop();
            Integer a = stack.pop();
            Integer b = stack.pop();
            stack.push(useOperator(pop ,b,a));
        }
        return stack.pop();
    }
    public static int useOperator(String operator, int a,int b){
        if(operator.equals(OperatorEnum.PLUS_SIGN.getOpertor())){
            return a+b;
        }
        if(operator.equals(OperatorEnum.MINUS.getOpertor())){
            return a-b;
        }
        if(operator.equals(OperatorEnum.TIMES_SIGN.getOpertor())){
            return a*b;
        }
        if(operator.equals(OperatorEnum.DIVISION_SIGN.getOpertor())){
            return a/b;
        }
        return 0;
    }
}

三、算法实现跟踪

我们假设计算

(1+2)*5+(3*6-2)*2

字符操作表达式操作数栈运算符栈（压入运算符栈 (1 压入操作数栈 1(+ 运算栈为空，压入运算符栈 1(+2压入操作数栈 1 2 (+）弹出两个操作数，弹出一个运算符，执行运算，结果压入操作数栈1+2 3 * 运算栈为空，压入运算符栈 3 5压入操作数栈 3 5 + 判断上一个运算符是否大于当前运算符优先级，大于, 弹出两个操作数，弹出上一个运算符，执行运算，结果压入操作数栈，当前运算符压入运算符栈3 * 5 = 15 15+（忽略 15 (+3压入操作数栈 15 3 (+* 判断上一个运算符是否大于当前运算符优先级，不大于, 当前运算符压入运算符栈 15 39+ *6压入操作数栈 15 3 6 （+ *- 判断上一个运算符是否大于当前运算符优先级，大于, 弹出两个操作数，弹出上一个运算符，执行运算，结果压入操作数栈，当前运算符压入运算符栈3*6=18 15 18 （+ - 2 压入操作数栈 15 18 2（+ - ) 弹出两个操作数，弹出一个运算符，执行运算，结果压入操作数栈18-2 = 16 15 16 +*判断上一个运算符是否大于当前运算符优先级，不大于, 当前运算符压入运算符栈 15 16+ *2压入操作数栈 15 16 2+ *输入结束循环执行运算操作 16*2 = 32
15+32 = 47 47

阅读全文

0 0