Java中缀表达式转后缀表达式

中缀表达式转后缀表达式

1. 概述

• 初始化两个栈：运算符栈s1和存储中间结果的栈s2
• 从左向有扫描中缀表达式
• 遇到操作数时将其压入s2
• 遇到运算符时，比较其与s1栈顶运算符的优先级：
  1. 如果s1为空，或栈顶元素为’(’，则将此运算符入栈
  2. 否则，若优先级比栈顶运算符的优先级高，则将运算符压入s1栈
  3. 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到1，与新的栈顶元素进行比较
• 遇到括号时：
  1. 如果是’(’，则直接压入s1
  2. 如果是’)’，则依次弹出s1栈顶的运算符，并压入s2，知道遇到’('为止，此时将这一对括号丢弃
• 重复以上步骤2至5，直到表达式的最右边
• 将s1中剩余的运算符依次弹出并压入s2
• 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

2. 举例

• 将中缀表达式1+((2+3)x4)-5转为后缀表达式

扫描到的元素	s2(栈底–>栈顶)	s2(栈底–>栈顶)	说明
1	1	空	数字，直接入栈
+	1	+	s1为空，运算符直接入栈
(	1	+ (	左括号，直接入栈
(	1	+ ( (	左括号，直接入栈
2	1 2	+ ( (	数字
+	1 2	+ ( ( +	s1栈顶为左括号，运算符直接入栈
3	1 2 3	+ ( ( +	数字
)	1 2 3 +	+ (	右括号，弹出运算符压入s1直至遇到左括号
x	1 2 3 +	+ ( x	s1栈顶为左括号，运算符直接入栈
4	1 2 3 + 4	+ ( x	数字
)	1 2 3 + 4 x	+	右括号，弹出运算符压入s1直至遇到左括号
-	1 2 3 + 4 x +	-	-与+优先级相同，因此弹出+，再压入-
5	1 2 3 + 4 x + 5	-	数字
到达最右端	1 2 3 + 4 x + 5 -	空	s1中剩余的运算符

3. 代码演示

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

/**
 * @author DELL
 * @Date 2020/1/29 17:11
 **/
public class Exception_Conversion {
    public static void main(String[] args) {
        String exception="1+((2+3)*4)-5";
        List<String> s = exceptionList(exception);
        System.out.println("中缀表达式："+s);
        List<String> list = parseSuffixExpresionList(s);
        System.out.println("后缀表达式："+list);
    }
    public static List<String> parseSuffixExpresionList(List<String> ls){
        //符号栈
        Stack<String> s1 = new Stack<>();
        //存放中间结果
        //实际应用当中可以通过ArrayList存放中间结果，因为s2在整个操作过程中只进行push操作，
        //没有进行pop操作，并且最终输出时需要逆序输出，所以使用ArrayList更加方便，可以直接输出。
        ArrayList<String> s2 = new ArrayList<>();
        for (String item : ls) {
            //正则表达式
            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栈顶元素弹出加入到s2中
                while(!s1.empty()&&Operation.getPriority(s1.peek())>=Operation.getPriority(item)){
                    s2.add(s1.pop());
                }
                //最后将item压入s1中
                s1.push(item);
            }
        }
        //将s1中剩余的元素加入s2中
        while(!s1.empty()){
            s2.add(s1.pop());
        }
        return s2;
    }
    /**
     * 将表达式中数字和符号依次存入ArrayList中
     * @param str
     * @return
     */
    public static List<String> exceptionList(String str){
        List<String> list = new ArrayList<>();
        int i=0;
        char c;
        String s="";
        while(i<str.length()){
            c = str.substring(i, i + 1).charAt(0);
            if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'){
                list.add(c+"");
            }else{
                //考虑多位数
                s+=c;
                if(i==str.length()-1){
                    list.add(s);
                }else{
                    char c1 = str.substring(i+1, i + 2).charAt(0);
                    if(c1=='+'||c1=='-'||c1=='*'||c1=='/'||c1=='('||c1==')'){
                        list.add(s);
                    }
                }
                s="";
            }
            i++;
        }
        return list;
    }
}

/**
 * 得到运算符的优先级
 */
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 getPriority(String operation){
        int res=0;
        switch (operation){
            case "+":
                res=ADD;
                break;
            case "-":
                res=SUB;
                break;
            case "*":
                res=MUL;
                break;
            case "/":
                res=DIV;
                break;
            default:
                break;
        }
        return res;
    }
}