栈（中缀表达式转后缀[逆波兰]表达式的实现）

最新推荐文章于 2025-04-11 00:16:46 发布

Strine

最新推荐文章于 2025-04-11 00:16:46 发布

阅读量119

点赞数

分类专栏：数据结构与算法文章标签： java 开发语言数据结构

本文链接：https://blog.youkuaiyun.com/Strine/article/details/130159875

版权

数据结构与算法专栏收录该内容

17 篇文章

订阅专栏

该文章介绍了一种基于栈的方法，将中缀表达式（如(56-20)/(4+2)）转换为后缀表达式（5620-42+/）。通过初始化两个栈，分别处理中间结果和运算符，按照运算符优先级规则进行操作，遇到数字直接压入结果栈，遇到运算符或括号则按规则处理。最后，将所有运算符从符号栈移至结果栈，生成后缀表达式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

目的

将传入的中缀表达式转为后缀表达式；

思路分析

例如：（56-20）/(40+2):

转为后缀表达式则为：56 20 - 4 2 + /

因此我们想要快速的得到结果的话最好是从左往右扫描中缀表达式；

1.初始化两个栈，一个中间结果栈和一个符号栈；

2.扫描中缀表达式，遇到数字则直接压入中间结果栈中；

3.如果遇到符号，则比较该符号和中间结果栈顶的符号优先级；

3.1 如果运算符栈顶为空，或者栈顶的符号是"("左括号，则直接将其压入符号栈；

3.2 如果该符号优先级比符号栈栈顶的符号优先级高，也将其压入符号栈；

3.2 否则就将符号栈的栈顶运算符弹出，压入中间结果栈中，然后再将当前符号与栈顶元素相比较，直到该符号压入符号栈为止；

4.如果遇到“）”右括号，则将"("左括号之前的运算符出栈，压入中间结果栈，并且将“（”左括号出栈；

代码实现

 /**
     *
     * @Author：Strine
     * 基于栈实现中缀表达式转后缀表达式
     * */
    public static String getSuffix(List<String>list){
        //初始化中间结果栈
        Stack<String> retStack = new Stack<>();
        //初始化符号栈
        Stack<String> optrStack = new Stack<>();
        for (int i = 0; i < list.size(); i++) {
            if (!isOper(list.get(i))){
                //如果是一个数字，则直接添加到中间结果栈中
                retStack.push(list.get(i));
            }else if (optrStack.isEmpty()||priority(list.get(i))==-1||priority(optrStack.peek())<priority(list.get(i))){
                //如果符号栈为空或者栈顶元素是一个左括号，则直接将当前运算符压入符号栈
                optrStack.push(list.get(i));
            }else if (priority(list.get(i))==-2){
                //如果当前符号是右括号，则取出左括号前的元素，并且将左括号出栈：
                String c = optrStack.pop();
                retStack.push(c);
                optrStack.pop();//将左括号取出
            }else {
                //如果走到这一步就说明，当前符号不是左右括号，且当前符号的优先级比栈顶元素优先级低；
                while (priority(list.get(i))<priority(optrStack.peek())){
                    String top = optrStack.pop();
                    retStack.push(top);
                    if (optrStack.isEmpty()){
                        break;
                    }
                }
            }
        }
        for (int i = 0; i < optrStack.size(); i++) {
            String ret = optrStack.pop();
            retStack.push(ret);
        }
        StringBuilder str = new StringBuilder();
        for (int i = 0; ; i++) {
            String ret = retStack.pop();
           str.append(ret).append(" ");
           if (retStack.isEmpty()){
               break;
           }
        }
        String ret = str.toString();
        String[] r = ret.split(" ");
        String result="";
        for (int i = 0; i < r.length; i++) {
            result=result+r[r.length-1-i]+" ";
        }
        return result;
    }
    /**
     *
     * 判断是不是一个运算符
     * */
    public static boolean isOper(String oper){
        return "+".equals(oper) || "-".equals(oper) || "*".equals(oper) || "/".equals(oper)||"(".equals(oper)||")".equals(oper);
    }
    /**
     * 返回运算符的优先级(我们这里规定数字越大优先级越高)
     * */
    public static int priority(String oper){
        if ("*".equals(oper) || "/".equals(oper)){
            return 1;
        }else if ("+".equals(oper) || "-".equals(oper)){
            return 0;
        }else if ("(".equals(oper)){
            return -1;
        }else if (")".equals(oper)){
            return -2;
        }else {
            return -10;
        }
    }

效果展示

public static void main(String[] args) {
    String str = "( 56 - 20 ) / ( 4 + 2 )";
    List<String> list = getList(str);
    String result = Infix2SuffixUtils.getSuffix(list);
    System.out.println(str+"转换为逆波兰表达式的结果为："+result);
}
public static List<String> getList(String str){
    String[] tar = str.split(" ");
    List<String> list = new ArrayList<>();
    for (int i = 0; i < tar.length; i++) {
        list.add(tar[i]);
    }
    return list;
}