中綴表達式轉前綴和後綴表達式-棧結構

前綴、中綴、後綴表達式

• 前綴表達式：/+A*BCD。
• 中綴表達式：A+B*C/D。
• 後綴表達式：ABC*+D/。

中綴表達式轉換後綴表達式思路

     操作數順序不變，將運算符進行排序

1. 將棧初始化爲空棧；
2. 從左到右掃描表達式的每一個字符，執行下面操作：

　　　　2.1  遇到操作數：直接輸出（添加到後綴表達式中）

　　　　2.2  棧爲空時，遇到運算符，直接入棧

　　　　2.3  遇到左括號：將其入棧

　　　　2.4  遇到右括號：執行出棧操作，並將出棧的元素輸出，直到彈出棧的是左括號，左括號不輸出。

　　　　2.5  遇到其他運算符：加減乘除：彈出所有優先級大於或者等於該運算符的棧頂元素，然後將該運算符入棧

　　　　2.6  最終將棧中的元素依次出棧，輸出。

中綴轉前綴表達式思路

基本同以上相同，不同點：

1、上面的從左到右掃描表達式，改成從右向左掃描每一個字符。

2、左括號和右括號的判斷和上面相反。

代碼演示：

package com.arithmetic.learn.arith4.c1.chapter3;

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

public class C1_3_10 {

    public static void main(String[] args) {

        String e = "20+5*(15-(9+1))/2";
        String resultPost = "20 5 15 9 1 + - * 2 / +";
        List<String> postFix = convert2Postfix(e);
        System.out.println(postFix);
        List<String> prefix = convert2Prefix(e);
        String resultPre = "+ 20 / * 5 - 15 + 9 1 2";
        System.out.println(resultPre);
    }

    private static List<String> convert2Prefix(String e) {
        List<String> items = convertStrToItems(e);
        List<String> prefix = convertToPrefix(items);
        return prefix;
    }

    private static List<String> convertToPrefix(List<String> items) {
        List<String> prefix = new ArrayList<>();

        Stack<String> stack = new Stack();
        for(int i = items.size()-1; i>= 0; i--){
            operate(items.get(i),stack,prefix);
        }
        while(!stack.isEmpty()){
            prefix.add(stack.pop());
        }
        return prefix;
    }

    private static List<String> convert2Postfix(String e) {
        List<String> items = convertStrToItems(e);
        List<String> posfix = convertToPostfix(items);
        return posfix;
    }

    private static List<String> convertToPostfix(List<String> items) {
        List<String> postfix = new ArrayList<>();

        Stack<String> stack = new Stack();
        for(String item : items){
            operate(item,stack,postfix);
        }
        while(!stack.isEmpty()){
            postfix.add(stack.pop());
        }
        return postfix;
    }

    private static void operate(String item,Stack<String> stack, List<String> postfix) {
        if(isOprator(item)){
            if(stack.isEmpty()){
                stack.push(item);
            }else{
                if(item.equals(")")){
                    //入棧
                    stack.push(item);
                }else if(item.equals("(")){
                    //出棧輸出，直至遇到(
                    String last = null;
                    while(!stack.isEmpty() && !( last = stack.pop()).equals("(")){
                        postfix.add(last);
                    }
                }else{
                    if(isGE(stack.peek(),item)){
                        //彈出直至優先級大於前面的運算符，或前面是數字
                        String last = null;
                        while(!stack.isEmpty() && isGE((last = stack.pop()),item)){
                            postfix.add(last);
                        }
                        stack.push(last);
                        stack.push(item);
                    }else{
                        //入棧
                        stack.push(item);
                    }
                }
            }

        }else{
            postfix.add(item);
        }
    }

    private static boolean isGE(String last, String item) {
        if(last.equals("+") || last.equals("-")){
            return item.equals("+") || item.equals("-");
        }else if(last.equals("*") || last.equals("/")){
            return true;
        }
        return false;
    }

    private static List<String> convertStrToItems(String e) {
        List<String> items = new ArrayList<>();

        String[] units = e.split("");
        int index = 0;
        for(String unit : units){
            if(isOprator(unit))  {
                items.add(index++,unit);
            }else{
                if(index == 0){
                    items.add(index++,unit);
                    continue;
                }
                String lastUnit = items.get(index-1);
                if(isOprator(lastUnit)){
                    items.add(index++,unit);
                }else{
                    items.remove(index-1);
                    items.add(index-1,lastUnit+unit);
                }
            }
        }
        return items;
    }

    private static boolean isOprator(String unit) {
        return unit.equals("+") || unit.equals("-") || unit.equals("*") || unit.equals("/")
                || unit.equals("(") || unit.equals(")");
    }
}