线性表栈队列和优先队列(代码片段)

/**
 * 使用两个栈（operandStack，operatorStack）分别存放操作数和操作符
 * 阶段1：扫描表达式 ，（15+2）*5-23，从左到右扫描表达式，提取出操作数和操作符以及括号
 *         1.如果提取的是操作数，则将其压入operandStack。
 *         2.如果提取的是+或者-号运算符，处理operatorStack栈顶所有的运算符，并将提取到的运算符压入到operatorStack
 *         3.如果提取的是*或者/号运算符，处理operatorStack栈顶所有的*和/运算符，并将提取到的运算符压入到operatorStack
 *         4.如果提取的是（，将提取到的运算符压入到operatorStack。
 *         5.如果提取的是）,重复处理来自operatorStack栈顶的运算符，直到遇到(为止。
 * 阶段2：清除栈
 *         重复处理来自operatorStack栈顶的运算符，直到operatorStack栈为空
 * 
 *
 */
public class EvaluateExpression 
    public static void main(String[] args) 
        System.out.println("请输入一个整数的简单运算表达式，比如：（ 15 + 2 ) * 5 - 23");
        Scanner input = new Scanner(System.in);
        String expression = input.nextLine();
        int ret = evaluateExpression(expression);
        System.out.println(expression + " = " + ret);
        input.close();
    
    /**
     * 计算表达式
     * @param expression 表达式
     * @return 结果
     */
    public static int evaluateExpression(String expression) 
        //创建operandStack存储操作数
        Stack<Integer> operandStack = new Stack<>();
        //创建operatorStack存储操作符
        Stack<Character> operatorStack = new Stack<>();
        //在表达式的操作符前后 添加空格，以便于提取操作数和操作符
        expression = insertBlanks(expression);
        //提取操作数及操作符
        String[] tokens = expression.split(" ");
        //阶段1：扫描表达式
        for(String token : tokens) 
            if(token.length() == 0) continue;//如果为
            else if(token.charAt(0) == ‘+‘ || token.charAt(0) == ‘-‘ ) 
                //处理运算符栈顶的所有+，-，*，/
                while(!operatorStack.isEmpty() && (
                        operatorStack.peek() == ‘+‘ ||
                        operatorStack.peek() == ‘-‘ || 
                        operatorStack.peek() == ‘*‘ || 
                        operatorStack.peek() == ‘/‘)) 
                    processAnOperator(operandStack,operatorStack);
                
                //将+或者-压入operatorStack
                operatorStack.push(token.charAt(0));
            else if (token.charAt(0) == ‘*‘ || token.charAt(0) == ‘/‘ ) 
                while(!operatorStack.isEmpty() && (
                        operatorStack.peek() == ‘*‘ || 
                        operatorStack.peek() == ‘/‘)) 
                    processAnOperator(operandStack,operatorStack);
                
                operatorStack.push(token.charAt(0));
            else if (token.trim().charAt(0) == ‘(‘) 
                operatorStack.push(‘(‘);
            else if(token.trim().charAt(0) == ‘)‘) 
                while(!operatorStack.isEmpty() && (
                        operatorStack.peek() != ‘(‘)) 
                    processAnOperator(operandStack,operatorStack);
                
                operatorStack.pop();//弹出（
            else 
                operandStack.push(Integer.valueOf(token));
        
        //阶段2：清空栈
        while(!operatorStack.isEmpty()) 
            processAnOperator(operandStack,operatorStack);
        
        return operandStack.pop();
    
    /**
     * 在表达式的操作符前后 添加空格，以便于提取操作数和操作符
     * @param expression 表达式
     * @return 添加空格后的表达式
     */
    private static String insertBlanks(String expression) 
        String result = "";
        for(int i = 0; i < expression.length(); i++) 
            if(expression.charAt(i) == ‘(‘ || expression.charAt(i) == ‘)‘ || expression.charAt(i) == ‘+‘ ||
                    expression.charAt(i) == ‘-‘ || expression.charAt(i) == ‘*‘ || expression.charAt(i) == ‘/‘) 
                result += " " + expression.charAt(i) + " ";
            else
                result += expression.charAt(i) ;
        
        return result;
    
    
    private static void processAnOperator(Stack<Integer> operandStack,Stack<Character> operatorStack) 
        char op = operatorStack.pop();
        int num1 = operandStack.pop();
        int num2 = operandStack.pop();
        if(op == ‘+‘) operandStack.push(num2 + num1);
        else if(op == ‘-‘) operandStack.push(num2 - num1);
        else if(op == ‘*‘) operandStack.push(num2 * num1);
        else if(op == ‘/‘) operandStack.push(num2 / num1);