逆波蘭演算法、中綴表示式轉字尾表示式

Ac_c0mpany丶發表於2022-03-19
演算法

一、前、中、字尾表達

字首表示式(波蘭表示式、Prefix expression)

又稱為波蘭表示式，字首表示式的運算子位於運算元之前

例如：(3 + 4) * 5 - 6對應的字首表示式：- * + 3 4 5 6

中綴表示式(Infix expression)

中綴表示式就是常見的運算表示式，中綴表示式的求值往往是人們所熟悉的，但是對計算機來說卻不好操作，一般將中綴表示式轉換成其他表示式(一般轉換成字尾表示式)

例如：(3 + 4) * 5 - 6

字尾表示式(逆波蘭表示式、Postfix expression)

又稱逆波蘭表示式，字尾表示式的運算子位於運算元之後

例如：(3 + 4) * 5 - 6對應的字尾表示式為：3 4 + 5 * 6 -

二、中綴表示式轉前、字尾表示式(手算)

轉換過程

中綴表示式為：a + b * c - ( d + e )

  1. 使用按照運算子的優先順序對所有的運算單位加括號
    操作完成後式子變成： ( ( a + ( b * c ) ) - ( d + e ) )
  2. 中綴表示式轉字首表示式：
    1）將運算子移動到對應括號之前：- ( + ( a * ( b c ) ) + ( d e ) )
    2）去掉括號：- + a * b c + d e
    3）轉換完成
  3. 中綴表示式轉字尾表示式：
    1）將運算子移動到對應括號之後：( ( a ( b c ) * ) + ( d e ) + ) -
    2）去掉括號：a b c * + d e + -
    3）轉換完成

三、中綴表示式轉字尾表示式(程式碼實現)

演算法思路

1.初始化兩個棧:運算子棧operStack和儲存結果的棧resStack
2.從左至右掃描中綴表示式
3.遇到運算元時(數字),直接將其壓入棧resStack
4.遇到運算子時(+、-、*、/),比較其與operStack棧頂運算子的優先順序
	4.1 如果operStack為空,或operStack棧頂運算子為左括號"(",則直接將此運算子壓入棧operStack;
	4.2 否則,若優先順序比operStack棧頂運算子優先順序高,則將此運算子壓入棧operStack;
	4.3 否則,將operStack棧頂的運算子彈出並壓入到棧resStack,再次轉到4與operStack中新的棧頂運算子相比較
5.遇到括號時:
	5.1 如果是左括號("("),則直接壓入棧resStack
	5.2 如果是左括號(")"),則依次彈出operStack棧頂的運算子,並壓入resStack,直到遇到左括號為止,並且把左括號彈出棧operStack,此時這一對括號丟棄
6.重複步驟2到5,直到遍歷完整個表示式
7.將operStack中剩餘的運算子依次彈出並壓入resStack
8.依次彈出resStack中的元素並輸出,結果的逆序即為中綴表示式對應的字尾表示式

程式碼實現

public static ArrayList<String> InfixChangeToPostfix(ArrayList<String> tokens) {
    // step1:初始化兩個棧:運算子棧numStack和儲存結果的棧resStack
    Stack<String> operStack = new Stack<>();
    Stack<String> resStack = new Stack<>();

    // step2:從左至右掃描中綴表示式
    for (String item : tokens) {
        if ("+".equals(item) || "-".equals(item) || "*".equals(item) || "/".equals(item)) { // 如果遇到運算子時
            if (operStack.isEmpty() || "(".equals(operStack.peek())) {
                operStack.push(item);
            } else if (priority(item) > priority(operStack.peek())) {
                operStack.push(item);
            } else { // 當前操作符比棧頂操作符 優先順序小或者相等
                while (!operStack.isEmpty() && priority(operStack.peek()) >= priority(item)) {
                    resStack.push(operStack.pop());
                }
                // 還需將item壓入operStack棧
                operStack.push(item);
            }
        } else if ("(".equals(item) || ")".equals(item)) { // 遇到括號時
            // 如果是左括號,則直接壓入numStack
            if ("(".equals(item)) {
                operStack.push(item);
            }
            // 如果是右括號,則依次彈出numStack棧頂的運算子,並壓入resStack,直到遇到左括號為止,此時將這一對括號丟棄
            if (")".equals(item)) {
                while (!"(".equals(operStack.peek())) {
                    resStack.push(operStack.pop());
                }
                // 此時operStack棧頂元素為(,將其彈出
                operStack.pop();
            }
        } else { // 數字的話,直接壓入resStack
            resStack.push(item);
        }
    }
    // step3:將numStack中剩餘的運算子依次彈出並壓入resStack
    while (!operStack.isEmpty()) {
        resStack.push(operStack.pop());
    }

    // step4:依次彈出resStack的元素並輸出,結果的逆序即為表示式對應的字尾表示式
    ArrayList<String> list = new ArrayList<>();
    while (!resStack.isEmpty()) {
        list.add(resStack.pop());
    }
    Collections.reverse(list); //結果的逆序即為中綴表示式對應的字尾表示式

    return list;
}

public static ArrayList<String> InfixChangeToPostfix(ArrayList<String> tokens) {
    // step1:初始化兩個棧:運算子棧numStack和儲存結果的棧resStack
    Stack<String> operStack = new Stack<>();
    Stack<String> resStack = new Stack<>();

    // step2:從左至右掃描中綴表示式
    for (String item : tokens) {
        if ("+".equals(item) || "-".equals(item) || "*".equals(item) || "/".equals(item)) { // 如果遇到運算子時
            if (operStack.isEmpty() || "(".equals(operStack.peek())) {
                operStack.push(item);
            } else if (priority(item) > priority(operStack.peek())) {
                operStack.push(item);
            } else { // 當前操作符比棧頂操作符 優先順序小或者相等
                while (!operStack.isEmpty() && priority(operStack.peek()) >= priority(item)) {
                    resStack.push(operStack.pop());
                }
                // 還需將item壓入operStack棧
                operStack.push(item);
            }
        } else if ("(".equals(item) || ")".equals(item)) { // 遇到括號時
            // 如果是左括號,則直接壓入numStack
            if ("(".equals(item)) {
                operStack.push(item);
            }
            // 如果是右括號,則依次彈出numStack棧頂的運算子,並壓入resStack,直到遇到左括號為止,此時將這一對括號丟棄
            if (")".equals(item)) {
                while (!"(".equals(operStack.peek())) {
                    resStack.push(operStack.pop());
                }
                // 此時operStack棧頂元素為(,將其彈出
                operStack.pop();
            }
        } else { // 數字的話,直接壓入resStack
            resStack.push(item);
        }
    }
    // step3:將numStack中剩餘的運算子依次彈出並壓入resStack
    while (!operStack.isEmpty()) {
        resStack.push(operStack.pop());
    }

    // step4:依次彈出resStack的元素並輸出,結果的逆序即為表示式對應的字尾表示式
    ArrayList<String> list = new ArrayList<>();
    while (!resStack.isEmpty()) {
        list.add(resStack.pop());
    }
    Collections.reverse(list); //結果的逆序即為中綴表示式對應的字尾表示式

    return list;
}

public static ArrayList<String> InfixChangeToPostfix(ArrayList<String> tokens) {
    // step1:初始化兩個棧:運算子棧numStack和儲存結果的棧resStack
    Stack<String> operStack = new Stack<>();
    Stack<String> resStack = new Stack<>();

    // step2:從左至右掃描中綴表示式
    for (String item : tokens) {
        if ("+".equals(item) || "-".equals(item) || "*".equals(item) || "/".equals(item)) { // 如果遇到運算子時
            if (operStack.isEmpty() || "(".equals(operStack.peek())) {
                operStack.push(item);
            } else if (priority(item) > priority(operStack.peek())) {
                operStack.push(item);
            } else { // 當前操作符比棧頂操作符 優先順序小或者相等
                while (!operStack.isEmpty() && priority(operStack.peek()) >= priority(item)) {
                    resStack.push(operStack.pop());
                }
                // 還需將item壓入operStack棧
                operStack.push(item);
            }
        } else if ("(".equals(item) || ")".equals(item)) { // 遇到括號時
            // 如果是左括號,則直接壓入numStack
            if ("(".equals(item)) {
                operStack.push(item);
            }
            // 如果是右括號,則依次彈出numStack棧頂的運算子,並壓入resStack,直到遇到左括號為止,此時將這一對括號丟棄
            if (")".equals(item)) {
                while (!"(".equals(operStack.peek())) {
                    resStack.push(operStack.pop());
                }
                // 此時operStack棧頂元素為(,將其彈出
                operStack.pop();
            }
        } else { // 數字的話,直接壓入resStack
            resStack.push(item);
        }
    }
    // step3:將numStack中剩餘的運算子依次彈出並壓入resStack
    while (!operStack.isEmpty()) {
        resStack.push(operStack.pop());
    }

    // step4:依次彈出resStack的元素並輸出,結果的逆序即為表示式對應的字尾表示式
    ArrayList<String> list = new ArrayList<>();
    while (!resStack.isEmpty()) {
        list.add(resStack.pop());
    }
    Collections.reverse(list); //結果的逆序即為中綴表示式對應的字尾表示式

    return list;
}

測試

public static void main(String[] args) {
    ArrayList<String> infixList = new ArrayList<>(); // 中綴表示式
    String infixExpression = "1+((2+3)*4)-5";

    char[] chs = infixExpression.toCharArray();
    for (char ch : chs) {
        infixList.add(ch + ""); // char轉String的小技巧
    }
    System.out.println("中綴表示式:" + infixList);

    ArrayList<String> postfixList = InfixChangeToPostfix(infixList);
    System.out.println("字尾表示式:" + postfixList);
}

執行結果

中綴表示式:[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
字尾表示式:[1, 2, 3, +, 4, *, +, 5, -]

四、字尾表示式求值(逆波蘭表示式求值)

即根據逆波蘭表示法(字尾表示式)，求表示式的值。

演算法思路

從左至右掃描表示式
若遇到數字,則將數字壓入堆疊
遇到運算子時,彈出棧頂的兩個數(分別為棧頂元素和次頂元素),用元素對它們做相應的計算,並將結果入棧
重複上述過程直到表示式最右端
最後棧的最後一個元素即為表示式的結果

樣例

程式碼實現

// 字尾表示式求值(逆波蘭表示式求值)
public static int evalRPN(ArrayList<String> list) {
    Stack<Integer> stack = new Stack<>();
    for (String item : list) {
        if ("+".equals(item) || "-".equals(item) || "*".equals(item) || "/".equals(item)) {
            int num1 = stack.pop(); // 棧頂元素
            int num2 = stack.pop(); // 次頂元素
            switch (item) {
                case "+" : stack.push(num1 + num2);break;
                case "-" : stack.push(num2 - num1);break;
                case "*" : stack.push(num1 * num2);break;
                case "/" : stack.push(num2 / num1);break;
            }
        } else {
            stack.push(Integer.parseInt(item));
        }
    }
    return stack.pop();
}

對應LeetCode一題：LeetCode150. 逆波蘭表示式求值

五、中綴表示式轉字尾表示式並計算結果(程式碼實現)

前提：運算元為整數並且運算子為+ 、 - 、 * 、 /

程式碼實現

package 棧;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Stack;

public class 中綴表示式轉字尾表示式 {
    public static void main(String[] args) {
        ArrayList<String> infixList = new ArrayList<>(); // 中綴表示式
        String infixExpression = "1+((2+3)*4)-5";

        char[] chs = infixExpression.toCharArray();
        for (char ch : chs) {
            infixList.add(ch + ""); // char轉String的小技巧
        }
        System.out.println("中綴表示式:" + infixList);

        ArrayList<String> postfixList = InfixChangeToPostfix(infixList);
        System.out.println("字尾表示式:" + postfixList);

        int res = evalRPN(postfixList);
        System.out.println("字尾表示式的值為:" + res);
    }

    public static ArrayList<String> InfixChangeToPostfix(ArrayList<String> tokens) {
        // step1:初始化兩個棧:運算子棧numStack和儲存結果的棧resStack
        Stack<String> operStack = new Stack<>();
        Stack<String> resStack = new Stack<>();

        // step2:從左至右掃描中綴表示式
        for (String item : tokens) {
            if ("+".equals(item) || "-".equals(item) || "*".equals(item) || "/".equals(item)) { // 如果遇到運算子時
                if (operStack.isEmpty() || "(".equals(operStack.peek())) {
                    operStack.push(item);
                } else if (priority(item) > priority(operStack.peek())) {
                    operStack.push(item);
                } else { // 當前操作符比棧頂操作符 優先順序小或者相等
                    while (!operStack.isEmpty() && priority(operStack.peek()) >= priority(item)) {
                        resStack.push(operStack.pop());
                    }
                    // 還需將item壓入operStack棧
                    operStack.push(item);
                }
            } else if ("(".equals(item) || ")".equals(item)) { // 遇到括號時
                // 如果是左括號,則直接壓入numStack
                if ("(".equals(item)) {
                    operStack.push(item);
                }
                // 如果是右括號,則依次彈出numStack棧頂的運算子,並壓入resStack,直到遇到左括號為止,此時將這一對括號丟棄
                if (")".equals(item)) {
                    while (!"(".equals(operStack.peek())) {
                        resStack.push(operStack.pop());
                    }
                    // 此時operStack棧頂元素為(,將其彈出
                    operStack.pop();
                }
            } else { // 數字的話,直接壓入resStack
                resStack.push(item);
            }
        }
        // step3:將numStack中剩餘的運算子依次彈出並壓入resStack
        while (!operStack.isEmpty()) {
            resStack.push(operStack.pop());
        }

        // step4:依次彈出resStack的元素並輸出,結果的逆序即為表示式對應的字尾表示式
        ArrayList<String> list = new ArrayList<>();
        while (!resStack.isEmpty()) {
            list.add(resStack.pop());
        }
        Collections.reverse(list); //結果的逆序即為中綴表示式對應的字尾表示式

        return list;
    }

    // 返回運算子的優先順序,優先順序是程式設計師來確定的,優先順序使用數字表示
    // 數字越大,則優先順序就越高
    // 假定目前只有 四種運算子: + - * /
    public static int priority(String oper) {
        if ("*".equals(oper) || "/".equals(oper)) {
            return 1;
        } else if ("+".equals(oper) || "-".equals(oper)) {
            return 0;
        } else {
            return -1;
        }
    }

    // 字尾表示式求值(逆波蘭表示式求值)
    public static int evalRPN(ArrayList<String> list) {
        Stack<Integer> stack = new Stack<>();
        for (String item : list) {
            if ("+".equals(item) || "-".equals(item) || "*".equals(item) || "/".equals(item)) {
                int num1 = stack.pop(); // 棧頂元素
                int num2 = stack.pop(); // 次頂元素
                switch (item) {
                    case "+" : stack.push(num1 + num2);break;
                    case "-" : stack.push(num2 - num1);break;
                    case "*" : stack.push(num1 * num2);break;
                    case "/" : stack.push(num2 / num1);break;
                }
            } else {
                stack.push(Integer.parseInt(item));
            }
        }
        return stack.pop();
    }
}

執行結果

中綴表示式:[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
字尾表示式:[1, 2, 3, +, 4, *, +, 5, -]
字尾表示式的值為:16

相關文章