栈的应用--逆波兰表达式

四则运算的中缀表达式转后缀表达式

实现规则：

• 数字直接输出
• 非数字，栈为空或者栈顶元素为左括号或者该符号为左括号，直接入栈
• 如果是右括号，持续出栈并输出符号，直到栈顶元素为左括号，将左括号出栈（左括号只出栈，不输出，右括号不入栈）
• 遇到运算符并且栈非空，如果栈顶元素的运算优先级大于等于该运算符的优先级，则持续出栈并输出符号，直到栈顶元素优先级小于该运算符的优先级，将该运算符入栈
• 读到末尾，将栈中所有元素依次输出

---

代码块

代码块java代码，例如：

/**
 *
 *@Description:中缀表达式  转  后缀表达式,运算符包含'+','-','*','/','(',')';
 *
 *@date:2017年11月7日
 *@author:cdy
 *
 */
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class ReversePolishNotation {
    static Stack<Character> symbolStack = new Stack<>();
    static StringBuilder reversePolishNoation = new StringBuilder();

    /**
     * 定义运算符优先级
     * @param c
     * @return
     */
    static int priority(char c) {
        if (c == '(') {
            return 0;
        } else if (c == '+' || c == '-') {
            return 1;
        } else if (c == '*' || c == '/') {
            return 2;
        }
        return 0;
    }

    /**
     * 中缀表达式转  后缀表达式
     * @param expression
     * @return
     */
    public static String getReversePolishNotation(String expression) {
        int length = expression.length();
        for (int i = 0; i < length; i++) {
            // 本次输入字符
            char c = expression.charAt(i);
            if (Character.isDigit(c)) {
                // 数字直接输出
                reversePolishNoation.append(c);
            } else {
                // 输入为运算符
                if (symbolStack.isEmpty() || symbolStack.peek() == '(' || c == '(') {
                    // 如果栈为空或者栈顶为'('或者本次输入运算符为'('，直接入栈，进行下一次
                    symbolStack.push(c);
                    continue;
                }
                if (c == ')') {
                    // 如果输入运算符为')'
                    while (symbolStack.peek() != '(') {
                        // 栈顶不是'('
                        // 运算符持续出栈并输出
                        char ch = symbolStack.pop();
                        reversePolishNoation.append(ch);
                    }

                    // 栈顶为'('出栈不输出，进行下一次
                    symbolStack.pop();
                    continue;

                }
                // char top = symbolStack.peek();
                // int topPriority=priority(top);
                int cPriority = priority(c);
                while (!symbolStack.isEmpty() && priority(symbolStack.peek()) >= cPriority) {
                    // 栈不为空，栈顶元素优先级大于等于本次输入运算符的优先级
                    // 运算符持续出栈并输出
                    char ch = symbolStack.pop();
                    reversePolishNoation.append(ch);
                }
                // 栈顶元素优先级小于本次输入运算符的优先级，本次输入的运算符入栈
                symbolStack.push(c);

            }
            // 本次输入结束
        }
        // 读到输入末尾，栈中所以元素依次输出
        while (!symbolStack.isEmpty()) {
            char ch = symbolStack.pop();
            reversePolishNoation.append(ch);
        }
        return reversePolishNoation.toString();
    }

}