补交20145226蓝墨云班课 -- 后缀表达式

蓝墨云班课 -- 后缀表达式

具体描述：

后缀表达式

内容：

###基本概念

后缀表达式，也叫逆波兰式，不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：(2 + 1) * 3 ， 后缀表达式即为2 1 + 3 *。

###后缀表达式计算：
建立一个栈S 。从左到右读表达式，如果读到操作数就将它压入栈S中，如果读到n元运算符(即需要参数个数为n的运算符)则取出由栈顶向下的n项按操作数运算，再将运算的结果代替原栈顶的n项，压入栈S中 。如果后缀表达式未读完，则重复上面过程，最后输出栈顶的数值则为结束。

具体的代码：

public class MyDC
{

    private final char ADD = '+';

    private final char SUBTRACT = '-';

    private final char MULTIPLY = '*';

    private final char DIVIDE = '/';

    private Stack<Integer> stack = new Stack<Integer>();

    public MyDC()
    {
        stack = new Stack<Integer>();
    }
    public int evaluate (String expr)
    {
        int op1, op2, result = 0;
        String token;
        String[] p = expr.split("");
        for(int i = 0; i<p.length;i++){
            token = p[i];
            if (isOperator(token))
            {
                op2 = (stack.pop()).intValue();
                op1 = (stack.pop()).intValue();
                result = evalSingleOp (token.charAt(0), op1, op2);
                stack.push (new Integer(result));
            }
            else{
                stack.push (new Integer(Integer.parseInt(token)));
            }
        }
        
        return result;
    }

    private boolean isOperator (String token)
    {
        return ( token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/") );
    }
    private int evalSingleOp (char operation, int op1, int op2)
    {
        int result = 0;

        switch (operation)
        {
        case ADD:
            result = op1 + op2;
            break;
        case SUBTRACT:
            result = op1 - op2;
            break;
        case MULTIPLY:
            result = op1 * op2;
            break;
        case DIVIDE:
            result = op1 / op2;
        }

        return result;
    }
}    

中缀表达式转为后缀表达式过程：

1. 设立一个栈，存放运算符，首先栈为空；
2. 从左到右扫描中缀式，若遇到操作数，直接输出，并输出一个空格作为两个操作数的分隔符；
3. 若遇到运算符，则与栈顶比较，比栈顶级别高则进栈，否则退出栈顶元素并输出，然后输出一个空格作分隔符；
4. 若遇到左括号，进栈；若遇到右括号，则一直退栈输出，直到退到左括号止。
5. 当栈变成空时，输出的结果即为后缀表达式。

具体的代码为：

public class MyBC {
    /** 
     * 优先级比较 
     * @param operator1 比较值 
     * @param operator2 被比较值 
     * @return 小于等于返回false,大于返回true 
     */  
    public boolean comparePrior(String operator1, String operator2) {  
        if("(".equals(operator2)) {  
            return true;  
        }  
        if ("*".equals(operator1) || "/".equals(operator1)) {  
            if ("+".equals(operator2) || "-".equals(operator2)) {  
                return true;  
            }  
        }  
        return false;  
    }  

    public String[] toSuffixExpression(String[] expressionStrs) {  
        //新组成的表达式  
        List<String> newExpressionStrs = new ArrayList<String>();  
        Stack<String> stack = new Stack<String>();  

        for (int i = 0; i < expressionStrs.length; i++) {  
            if ("(".equals(expressionStrs[i])) { // 如果是左括号,则入栈  
                stack.push(expressionStrs[i]);  
            } else if ("+".equals(expressionStrs[i]) || "-".equals(expressionStrs[i]) || "*".equals(expressionStrs[i]) || "/".equals(expressionStrs[i])) {  
                if (!stack.empty()) { // 取出先入栈的运算符  
                    String s = stack.pop();  
                    if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈  
                        stack.push(s);  
                    } else {  //否则取出值  
                        newExpressionStrs.add(s);  
                    }  
                }  
                stack.push(expressionStrs[i]);  
            } else if (")".equals(expressionStrs[i])) { //如果是")",则出栈,一直到遇到"("  
                while (!stack.empty()) {  
                    String s = stack.pop();  
                    if (!"(".equals(s)) {  
                        newExpressionStrs.add(s);  
                    } else {  
                        break;  
                    }  
                }  
            } else {  
                newExpressionStrs.add(expressionStrs[i]);  
            }  
        }  
        while (!stack.empty()) {  
            String s = stack.pop();  
            newExpressionStrs.add(s);  
        }  
        return newExpressionStrs.toArray(new String[0]);  
    }  

    
}

转载于:https://www.cnblogs.com/bestixyh/p/6941671.html