棧：中綴表達式轉換為后綴表達式

大家看到，后綴表達式適合計算機進行計算，但是人卻不太容易寫出來，尤其是表達式很長的情況下，因此在開發中，我們需要將 中綴表達式轉成后綴表達式。

具體步驟如下：

1) 初始化兩個棧：運算符棧s1和儲存中間結果的棧s2；

2) 從左至右掃描中綴表達式；

3) 遇到操作數時，將其壓s2；

4) 遇到運算符時，比較其與s1棧頂運算符的優先級：

　　(1). 如果s1為空，或棧頂運算符為左括號“(”，則直接將此運算符入棧；

　　(2). 否則，若優先級比棧頂運算符的高，也將運算符壓入s1；

　　(3). 否則，將s1棧頂的運算符彈出並壓入到s2中，再次轉到(4.1)與s1中新的棧頂運算符相比較；

5) 遇到括號時：
　　(1). 如果是左括號“(”，則直接壓入s1
　　(2). 如果是右括號“)”，則依次彈出s1棧頂的運算符，並壓入s2，直到遇到左括號    為止，此時將這一對括號丟棄

6) 重復步驟2至5，直到表達式的最右邊

7) 將s1中剩余的運算符依次彈出並壓入s2

8) 依次彈出s2中的元素並輸出，結果的逆序即為中綴表達式對應的后綴表達式

舉例說明

將中綴表達式 1 + ( ( 2 + 3 )× 4) - 5 => 后綴表達式 過程如下：

結果為： 1 2 3 + 4 * + 5 -

 代碼實現

package com.jyj.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {
        //完成一個中綴表達式轉后綴表達式的功能
        //說明：
        //1. 1+((2+3)*4)-5 => 轉成 1 2 3 + 4 * + 5 -
        //2. 因為直接對str 進行操作，不方便，因此先將"1+((2+3)*4)-5" => 中綴的表達式對應的List
        //   即"1+((2+3)×4)-5" => ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]
        //3. 將得到的中綴表達式對應的List => 后綴表達式對應的List
        //   即ArrayList[1,+,(,(,2,+,3,),*,4,),-,5] => ArrayList[1,2,3,+,4,*,+,5,-]
        String expression = "1+((2+3)*4)-5";
        List<String> inffixExpressionList = toInffixExpressionList(expression);
        System.out.println("inffixExpressionList = "+inffixExpressionList);
        List<String> suffixExpressionList = parseSuffixExpressionList(inffixExpressionList);
        System.out.println("suffixExpressionList = " + suffixExpressionList);    
    }
    
    //將得到的中綴表達式對應的List => 后綴表達式對應的List
    //即ArrayList[1,+,(,(,2,+,3,),*,4,),-,5] => ArrayList[1,2,3,+,4,*,+,5,-]
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //定義兩個棧
        Stack<String> s1 = new Stack<String>();//符號棧
        //說明：因為s2這個棧，在整個轉換過程中，沒有pop操作，而且后面我們還需要逆序輸出
        //因此比較麻煩，這里我們就不使用Stack<String> 直接使用 List<String> s2
        List<String> s2 = new ArrayList<String>();
        //遍歷ls
        for(String item : ls) {
            //如果是一個數，加入s2
            if(item.matches("\\d+")) {
                s2.add(item);
            }else if(item.equals("(")) {
                s1.push(item);
            }else if(item.equals(")")) {//如果是右括號“)”
                //依次彈出s1棧頂的運算符，並壓入s2，直到遇到左括號為止，此時將這一對括號丟棄
                while(!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//注意！！將“(”彈出s1，消除
            }else {
                //當item優先級小於等於s1棧頂運算符,將s1棧頂的運算符彈出並加入到s2中
                //問題：缺少比較優先級的方法
                while(s1.size() != 0 && !s1.peek().equals("(") && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //item優先級比s1棧頂運算符的高，將運算符壓入s1
                s1.push(item);
            }
        }
        
        while(s1.size() != 0) {
            //將s1中剩余的運算符依次彈出並壓入s2
            s2.add(s1.pop());
        }
        return s2; //注意因為是存放到List，因此按順序輸出就是對應的后綴表達式
    }
    
    
    //將中綴表達式轉成對應的List
    // s = "1+((2+3)×4)-5"
    public static List<String> toInffixExpressionList(String s) {
        //定義一個List，存放中綴表達式 對應的內容
        List<String> ls = new ArrayList<String>();
        int i = 0; //指針，用於遍歷 中綴表達式字符串
        String str; //對多位數的拼接
        char c; //每遍歷到一個字符，就放入到c
        do{
            //如果c是一個非數字，需要加入ls
            if((c=s.charAt(i)) < 48 || (c=s.charAt(i)) > 57) {
                ls.add(""+c);
                i++;
            }else {
                str = ""; //先將str 置成""
                //'0'[48]->'9'[57]
                while(i < s.length() && (c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                ls.add(str);
            }
        }while(i < s.length());
        
        return ls;//返回
    }
}

//編寫一個類 Operation 可以返回一個運算符對應的優先級
class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;
    public static int getValue(String operation) {
        int result = 0;
        switch(operation) {
        case "+":
            result = ADD;
            break;
        case "-":
            result = SUB;
            break;
        case "*":
            result = MUL;
            break;
        case "/":
            result = DIV;
            break;
        default:
//            throw new RuntimeException("運算符有誤");
            System.out.println("運算符有誤");
            break;
        }
        return result;
    }
}

結果例：

以上。