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

Java算法

设计思路

1. 初始化一个栈stack用来存放操作符，一个队列queue用来存放结果。
2. 从左到右扫描中缀表达式。
3. 根据扫描到的是数字、操作符、括号做出以下处理。
   数字：直接压入队列；
   操作符：若stack栈为空 或者栈顶运算符为’(’ 或者 优先级大于栈顶优先级均将该操作符压入stack栈。
   否则循环先将stack栈顶优先级大的退出到队列中，后再将该操作符加入stack栈顶。
   括号：如果是左括号’(‘直接压入stack栈 ，若是右括号’)‘将stack栈中的操作符依次退出到队列直到匹配到第一个左括号’(’（左括号直接退出并不放入队列）。
4. 将stack中剩余的操作符依次退入到队列中。
5. 依次退出队列中的元素即为最终结果。

图解

首次写文章，暂时不会制作图片，望见谅。

源码

import java.util.Deque;
import java.util.LinkedList;

/**
 * Created with IntelliJ IDEA
 *
 * @author WSX
 * @Date: 2022/01/16/14:04
 * @Description:
 */
public class InfixedSuffix {
    public static void main(String[] args) {
        InfixedSuffix infixedSuffix = new InfixedSuffix();
        String s = "1+((2+3)*4)-5";
        System.out.println(infixedSuffix.transferSuffix(s));
    }
    public String transferSuffix(String prefix) {
        prefix.replaceAll(" ","");
        char[] expression = prefix.toCharArray();
        Deque<String> stack = new LinkedList<>();
        //存储后缀表达式
        Deque<String> queue = new LinkedList<>();
        int num = 0;
        String res = "";
        boolean mod =false;//判断是否有数字需要加入队列
        for (int i = 0; i < prefix.length(); i++) {
            if (isNum(expression[i])) {
                num = num*10+expression[i]-'0';
                mod = true;
            } else{
                if (mod == true) {
                queue.offer(num+"");
                num = 0;
                mod =false;
                }
                if (isOps(expression[i])) {
                    if (stack.size() == 0||stack.peek().toCharArray()[0] =='('||priority(expression[i]) > priority(stack.peek().toCharArray()[0])) {
                        stack.push(expression[i]+"");
                    }else {
                        //将stack栈中优先级大于expression[i]操作符优先级高的操作数退出到后缀表达式队列queue中
                        while(!(stack.size() == 0||stack.peek().toCharArray()[0] =='('||priority(expression[i]) > priority(stack.peek().toCharArray()[0]))) {
                            queue.offer(stack.pop());
                        }
                        //此时操作数栈顶元素优先级低于expression[i]操作符，要记得将该expression[i]操作符入栈
                        stack.push(String.valueOf(expression[i]));
                    }
                } else if (isParenthesis(expression[i])) {
                    if (expression[i] == '(') {
                        stack.push(String.valueOf(expression[i]));
                    }else if (expression[i] == ')') {
                        while(!stack.peek().equals(String.valueOf('('))) {
                            queue.offer(stack.pop());
                        }
                        //清除stack栈顶部的左括号'('
                        stack.pop();
                    }
                }

            }
        }
        while(stack.size()!=0) {
            queue.offer(stack.pop());
        }
        if (num != 0) {
            queue.offer(num+"");
        }
        while (queue.size()!=0) {
            res +=queue.poll();
        }
        return res;
    }

    /**
     * 判断是不是数字
     * @param s
     * @return
     */
    public boolean isNum(char s) {
        return (int)s>=48&&(int)s<=57;
    }

    /**
     * 判断是不是操作数
     * @param c
     * @return
     */
    public boolean isOps(char c) {
        return (int)c == 42||(int)c == 43||(int)c == 45||(int)c == 47;
    }

    /**
     * 判断是不是括号
     * @param c
     * @return
     */
    public boolean isParenthesis(char c) {
        return c=='('||c==')';
    }

    /**
     * 返回操作符优先级
     * @param a
     * @return
     */
    public int priority(char a) {
        if (a == '*'||a == '/') {
            return 1;
        } else if (a == '+'||a == '-') {
            return 0;
        } else
            return -1;
    }
}