后缀表达式

前缀表达式（波兰表达式）

• 前缀表达式的运算符位于操作数之前；例:(3+4)*5-6 前缀表达式为 - * + 3 4 5 6
• 从右至左扫描，遇到数字压入数字栈，遇到运算符号时，出栈两个数，将运算结果入栈，直到扫描到算式的最左面
• 先出栈的数对后出栈的数进行运算

---

后缀表达式（逆波兰表达式）

• 从左至右扫描，遇到数字压入数字栈，遇到运算符号，弹出两个数字，进行运算，直到扫描到最右端。
• 后出栈的数对先出栈的数进行运算

---

中缀表达式转后缀表达式

转换步骤

1. 定义两个栈，运算符栈、数字栈
2. 从左至右扫描中缀表达式
3. 当扫描到数字的时候最直接入数字栈
4. 当运算符栈为空或为左括号‘（’时，扫描到运算符号，直接入符号栈
5. 当符号栈不为空，如果优先级比栈顶符号高，则直接入符号栈；如果优先级小于等于栈顶符号，将符号栈栈顶符号出栈，将栈顶符号压入数字栈，再将当前符号压入符号栈。
6. 当扫描到左括号‘（’，则直接压入符号栈
7. 当扫描到右括号‘）’，则一次弹出符号栈中的符号，并以此入数字栈，直到栈顶符号位左括号，将这对括号丢弃。
8. 当中缀表达式全部扫描完成，将符号栈剩下的符号一次压入数字栈中
9. 结果为数字栈一次出栈的逆序。

代码展示：

/**
 * 中缀表达式转后缀表达式
 */
class Postfix {
    //中缀转换为后缀表达式入口，传入中缀表达式
    public String start(String Infix) {
        int index = 0;
        String keepnum = "";//用于拼接多位数
        Stack operStack = new Stack();//用于存放符号的符号栈
        ArrayList numList = new ArrayList();//用于存放数字，和最终结果的输出
        Postfix p = new Postfix();
        //先要对中缀表达式进行分解
        while (true) {
            //传入一个字符
            char ch = Infix.substring(index, index + 1).charAt(0);
            //当传入的为数字
            if (ch >= 48 && ch <= 57) {
                //先进行多位数的拼接
                keepnum += ch;
                //当下一位不为数字时清空keepnum
                if (Infix.substring(index + 1, index + 2).charAt(0) <= 48 || Infix.substring(index + 1, index + 2).charAt(0) >= 57) {
                    //将数字放入数字链表
                    numList.add(keepnum);
                    keepnum = "";
                }

            } else if (ch == '=') {
                //当传入的为等号‘=’时，直接停止循环
                break;
            } else {
                //当传入的为符号
                //当符号栈为空或输入符号为左括号
                if (operStack.isEmpty() || ch == '(') {
                    //将符号直接入栈
                    operStack.push(ch);
                } else {
                    //符号栈不为空
                    //符号优先级大于栈顶符号
                    if (ch == ')') {
                        //如果输入标签为右括号,将符号栈中的符号依次出栈，然后加入到数字链表中，直到遇见左括号，将左括号出栈
                        while (true) {
                            if ((char) operStack.peek() == '(') {
                                //将左括号出栈
                                operStack.pop();
                                break;
                            }
                            numList.add(operStack.pop());
                        }
                    } else if (p.classifyOperation(ch) > p.classifyOperation((char) operStack.peek())) {
                        //直接入栈
                        operStack.push(ch);
                    } else if (p.classifyOperation(ch) <= p.classifyOperation((char) operStack.peek())) {
                        //当符号优先级小于等于栈顶符号，将栈顶符号出栈存入数字链表中
                        numList.add(operStack.pop());
                        //再次判断当前符号是不是优先级小于等于栈顶符号
                        if (p.classifyOperation(ch) <= p.classifyOperation((char) operStack.peek()) && operStack.peek() != null) {
                            //如果小于等于，再次执行
                            numList.add(operStack.pop());
                        }
                    }
                }
            }
            index++;//指针后移一位
        }
        //中缀表达式扫描完毕，开始将符号栈中的符号出栈，加入到数字链表中
        while (!operStack.isEmpty()) {
            numList.add(operStack.pop());
        }
        return numList.toString();
    }

    //返回符号优先级
    public int classifyOperation(char ch) {
        if (ch == '+' || ch == '-') {
            return 1;
        } else if (ch == '*' || ch == '/') {
            return 2;
        } else if (ch == '(') {
            return 0;
        } else if (ch == ')') {
            return 3;
        } else {
            return -1;
        }
    }
}