使用栈实现解析算术表达式

目的

　　1. 使用栈将中缀表达式转换成后缀表达式

　　2. 使用后缀表达式求算术值

---

注意：

　　因为是简单实践，所以代码逻辑已经简化，比如只能对个位数的加减乘除进行解析、没有设异常处理等

---

一：需要实现一个栈

这个没什么好说的，只是一个结构很简单的栈

public class Stack {

    private int maxSize;
    private int top;
    private Object[] stackArr;

    public Stack(int maxSize) {
        this.maxSize = maxSize;
        stackArr = new Object[maxSize];
        top = -1;
    }

    public void push(Object i){
        stackArr[++top] = i;
    }

    public Object pop(){
        return stackArr[top--];
    }

    public Object peek(){
        return stackArr[top];
    }

    public Object peekN(int n) {
        return stackArr[n];
    }

    public boolean isEmpty(){
        return (top == -1);
    }

    public boolean isFull(){
        return (top == maxSize-1);
    }

    public int size(){
        return top+1;
    }

    public void dispaly(String s) {
        System.out.print(s + "		" + "Stack {bottom-->top}: ");
        for (int i = 0; i < size(); i++) {
            System.out.print(peekN(i) + "	");
        }
        System.out.println();
    }
}

---

 二：将中缀表达式转换成后缀表达式

这里需要处理的操作符有："+"、"-"、 "*"、 "/"、 "(" 、")"

需要关注的有四点：

（1）操作符的优先级：  "( )"    >    "* /"    >    "+ -"

（2）同级操作符的操作顺序是无所谓的，只要操作数顺序不变即可

（3）遇到高优先级操作时，栈的压栈和出栈的实现

（4）栈存的是操作符

public class InfixToPostfix {

    private Stack stack;
    private String input;
    private StringBuilder output;
    /**
     * 加减类型
     */
    private static final int ADD_SUB_TYPE = 1;
    /**
     * 乘除类型
     */
    private static final int MUL_DIV_TYPE = 2;

    public InfixToPostfix(String input) {
        this.input = input;
        stack = new Stack(input.length());
        output = new StringBuilder();
    }

    public String doTransform() {
        String[] split = input.split("");
        for (int i = 0; i < split.length; i++) {
            stack.dispaly("FOR		" + split[i]);
            switch (split[i]) {
                case "+":
                case "-":
                    // 对"+"、"-"操作符进行处理
                    manageOperator(split[i], ADD_SUB_TYPE);
                    break;
                case "*":
                case "/":
                    // 对"*"、"/"操作符进行处理
                    manageOperator(split[i], MUL_DIV_TYPE);
                    break;
                case "(":
                    // 左括号表示下一个计算块拥有更高一级优先级，直接入栈即可
                    stack.push(split[i]);
                    break;
                case ")":
                    // 对")"操作符进行处理
                    manageParen(split[i]);
                    break;
                default:
                    // 拼接输出结果
                    output.append(split[i]);
                    break;
            }
        }
        // 将栈内剩余的元素全部出栈
        while (!stack.isEmpty()) {
            stack.dispaly("WHILE	");
            String pop = (String) stack.pop();
            output.append(pop);
        }
        stack.dispaly("END		");
        return output.toString();
    }

    /**
     * 对右括号操作符进行处理
     * @param rightParen
     */
    private void manageParen(String rightParen) {
        // 取出当前栈顶元素
        while (!stack.isEmpty()) {
            String top = (String) stack.pop();
            // 有两种情况：
            // 1. 取出的是 "("，说明被括号括起来的计算块已经结束，直接break掉循环即可。
            // 2. 取出来的是其他操作符(+-*/)，出栈并打印即可。这里不能break，因为操作符可能有多个，要一直出栈，直到取到 "("
            if (top.equals("(")) {
                break;
            } else {
                output.append(top);
            }
        }
    }

    /**
     * 对加减乘除操作符进行处理
     * @param operator
     * @param type
     */
    private void manageOperator(String operator, int type) {
        // 当栈不为空时，需要判断
        while (!stack.isEmpty()) {
            // 先取出栈顶元素
            String top = (String) stack.pop();
            // 此时，有两种情况：
            // 1. 取出的是 "(" 左括号，说明此时正在进行更高优先级的计算（也就是括号内的计算），所以需要把出栈 "(" 重新入栈，并break掉循环。最后将传过来的的操作符入栈。
            // 2. 取出的是其他操作符（+-*/），需要进行优先级判断。
            //      2.1 取出操作符优先级比读取的（即传过来的）高，说明应该执行上一个计算块，所以要将取出的操作符出栈并打印，break掉循环。最后将传过来的的操作符入栈。
            //      2.2 取出操作符优先级比读取的（即传过来的）低或者相等，说明应该或可以先执行下一个计算块，所以要将取出的操作符重新入栈，并break掉循环。最后将传过来的的操作符入栈。
            if (top.equals("(")) {
                stack.push(top);
                break;
            } else {
                // 确定取出来的操作符的类型
                int topType = 0;
                if (top.equals("+") || top.equals("-")) {
                    // 类型为加减
                    topType = 1;
                } else {
                    // 类型为乘除
                    topType = 2;
                }
                // 与传过来的类型比较
                if (topType > type) {
                    output.append(top);
                } else {
                    stack.push(top);
                    break;
                }
            }
        }
        // 将传过来的操作符入栈
        stack.push(operator);
    }
}

测试：

@Test
public void fun1(){
    // String input = "A+B-C";
    String input = "A*(B+C)-D/(E+F)";
    InfixToPostfix trans = new InfixToPostfix(input);
    String output = trans.doTransform();
    System.out.println("----------------------");
    System.out.println("后缀表达式为： " + output);
}

结果：

FOR        A        Stack {bottom-->top}: 
FOR        *        Stack {bottom-->top}: 
FOR        (        Stack {bottom-->top}: *    
FOR        B        Stack {bottom-->top}: *    (    
FOR        +        Stack {bottom-->top}: *    (    
FOR        C        Stack {bottom-->top}: *    (    +    
FOR        )        Stack {bottom-->top}: *    (    +    
FOR        -        Stack {bottom-->top}: *    
FOR        D        Stack {bottom-->top}: -    
FOR        /        Stack {bottom-->top}: -    
FOR        (        Stack {bottom-->top}: -    /    
FOR        E        Stack {bottom-->top}: -    /    (    
FOR        +        Stack {bottom-->top}: -    /    (    
FOR        F        Stack {bottom-->top}: -    /    (    +    
FOR        )        Stack {bottom-->top}: -    /    (    +    
WHILE            Stack {bottom-->top}: -    /    
WHILE            Stack {bottom-->top}: -    
END                Stack {bottom-->top}: 
----------------------
后缀表达式为： ABC+*DEF+/-

---

 三：使用后缀表达式求算术值

需要注意的是：

　　栈存的是操作数，和上面的相反

public class ParsePostfix {

    private Stack stack;
    private String input;
    private StringBuilder sb;

    public ParsePostfix(String input) {
        this.input = input;
        stack = new Stack(input.length());
        sb = new StringBuilder();
    }

    public int doParse(){
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            // 两种情况:
            // 1. 传过来的是一个数字，直接压入栈
            // 2. 传过来的是一个操作符，那就取两个栈内元素，进行算术处理，并将结果压入栈
            if (c >= '0' && c <= '9') {
                // 直接压入栈，需要转成int，网上找的，-'0' 即可
                stack.push(c - '0');
            } else {
                int result = 0;
                // 取两个栈内元素，进行算术处理
                int num1 = (int) stack.pop();
                int num2 = (int) stack.pop();
                switch (c) {
                    case '+':
                        result = num2 + num1;
                        break;
                    case '-':
                        result = num2 - num1;
                        break;
                    case '*':
                        result = num2 * num1;
                        break;
                    case '/':
                        result = num2 / num1;
                        break;
                }
                stack.push(result);
            }
        }
        int finalResult = (int) stack.pop();
        return finalResult;
    }
}

 测试：

@Test
public void fun2(){
    String input = "531-+";
    ParsePostfix pp = new ParsePostfix(input);
    int i = pp.doParse();
    System.out.println(i);
}

结果：

7

---

 四：两者结合测试

public static void main(String[] args) {
    String input = "5+3-5*8/2";
    InfixToPostfix trans = new InfixToPostfix(input);
    String output = trans.doTransform();
    System.out.println("----------------------");
    System.out.println("后缀表达式为： " + output);
    System.out.println("----------------------");
    ParsePostfix pp = new ParsePostfix(output);
    int result = pp.doParse();
    System.out.println("最终结果为: " + result);
}

结果：

FOR        5        Stack {bottom-->top}: 
FOR        +        Stack {bottom-->top}: 
FOR        3        Stack {bottom-->top}: +    
FOR        -        Stack {bottom-->top}: +    
FOR        5        Stack {bottom-->top}: +    -    
FOR        *        Stack {bottom-->top}: +    -    
FOR        8        Stack {bottom-->top}: +    -    *    
FOR        /        Stack {bottom-->top}: +    -    *    
FOR        2        Stack {bottom-->top}: +    -    *    /    
WHILE            　　Stack {bottom-->top}: +    -    *    /    
WHILE            　　Stack {bottom-->top}: +    -    *    
WHILE            　　Stack {bottom-->top}: +    -    
WHILE            　　Stack {bottom-->top}: +    
END                 Stack {bottom-->top}: 
----------------------
后缀表达式为： 53582/*-+
----------------------
最终结果为: -12

---