java中的栈Stack的基本使用和应用（二） ——利用栈计算合法的算术表达

package com.xumz.stack;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
/**
 * 中缀表达式转后缀表达式
 * 
 * @author xumz 2017/10/18
 */
public class ExpressionChange {
    // 存放左运算符的优先级
    Map<Character, Integer> leftOperator = new HashMap<Character, Integer>() {
        {
            put(‘=‘, 0);
            put(‘(‘, 1);
            put(‘+‘, 3);
            put(‘-‘, 3);
            put(‘*‘, 5);
            put(‘/‘, 5);
            put(‘)‘, 6);
        }
    };
    // 存放右运算符的优先级
    Map<Character, Integer> rightOperator = new HashMap<Character, Integer>() {
        {
            put(‘=‘, 0);
            put(‘(‘, 6);
            put(‘+‘, 2);
            put(‘-‘, 2);
            put(‘*‘, 4);
            put(‘/‘, 4);
            put(‘)‘, 1);
        }
    };

    /**
     * 中缀转后缀
     * 
     * @param str
     * @return
     */
    public String trans(String str) {
        // 转换成char[]
        char[] exp = str.toCharArray();
        // 存放转换结果
        List<Character> resultExp = new ArrayList<Character>();
        // 存放运算符,初始底为‘=’
        Stack<Character> operator = new Stack<Character>();
        operator.push(‘=‘);
        // 扫描exp表达式
        int i = 0;
        while (i != exp.length) {
            // 数字情况
            if (!isOperator(exp[i])) {
                while (i != exp.length && !isOperator(exp[i])) {
                    resultExp.add(exp[i]);
                    i++;
                }
                resultExp.add(‘#‘);
            }
            // 运算符情况
            else {
                switch (compareOperatorNice(operator.peek(), exp[i])) {
                case -1:
                    operator.push(exp[i]);
                    i++;// 继续下一个字符
                    break;
                case 0:
                    operator.pop();
                    i++;// 继续下一个字符
                    break;
                case 1:
                    resultExp.add(operator.peek());
                    operator.pop();
                    break;
                }
            }

        }
        while (!(operator.peek()==‘=‘)) {
            resultExp.add(operator.peek());
            operator.pop();
        }
        

        // 转换为String返回
        return resultExp.toString();
    }

    boolean isOperator(char ch) {
        if (leftOperator.containsKey(ch)) {
            return true;
        }
        return false;
    }

    /**
     * 比较左右运算符优先级，返回状态结果
     * 
     * @param leftOperator
     * @param rightOperator
     * @return
     */
    int compareOperatorNice(char left, char right) {
        if (leftOperator.get(left) == rightOperator.get(right)) {
            return 0;
        }
        if (leftOperator.get(left) < rightOperator.get(right)) {
            return -1;
        }
        return 1;
    }

}