标签：oper itme Java 中缀 s2 s1 栈顶 equals 表达式

中缀转后缀

​ 思路分析：

1）初始化两个栈：运算符栈s1和中间结果栈s2

2）从左到右扫描中缀表达式

3）遇到操作数将其压入s2

4）遇到操作符时，将其与s1栈顶运算符比较优先级

​ 4.1）如果s1为空，或者栈顶元素为“（”直接将其压入运算符栈

​ 4.2）如果优先级比s1栈顶元素的优先级高，将其直接入栈

​ 4.3）如果优先级小于等于s1栈顶元素优先级，则将s1栈顶元素弹出并压入s2中，再次转到4.1与s1中新的栈顶元素比较

5）遇到括号

​ 5.1）如果是左括号“（“，直接压入s1

​ 5.2）如果是右括号”）“，则依次弹出s1栈顶元素，并压入s2，直到遇到”（“，并将这一对括号废弃

6）重复2~5步骤，直到表达式最右边

7）最后将其s1剩余运算符依次加入s2

8）依次弹出s2中元素输出结果就为后缀表达式

代码实现：

package com.cwnu.stack;

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

/*
 * 中缀转后缀的算法实现
 * */
public class InfixtoSuffix {
    public static void main(String[] args) {
        //声明字符转
        String express = "1 + ( ( 2 + 3 ) * 4 ) - 5";
        //字符串转数组
        String[] expressArray = toStringArray(express);
        //初始化两个栈符号栈s1和中间栈s2
        Stack<String> s1 = new Stack<>();
        Stack<String> s2 = new Stack<>();
        s2 = suffixesToSuffixes(s1, s2, expressArray);
        String[] print = new String[s2.size()];
        for (int i = 0; i < s2.size(); i++) {
            print[i] = s2.get(i);
        }
        System.out.print("表达式为：");
        for (String e : print) {
            System.out.print(e + " ");
        }
    }

    //将字符串转化为数组
    public static String[] toStringArray(String string) {
        return string.split(" ");
    }

    //运算优先级
    public static int priority(String oper) {
        if (oper.equals("*") || oper.equals("/")) {
            return 1;
        } else if (oper.equals("+") || oper.equals("-")) {
            return 0;
        } else {
            return -1;
        }
    }

    //判断是否为运算符
    public static boolean isOperator(String oper) {
        return oper.equals("*") || oper.equals("/") || oper.equals("+") || oper.equals("-");
    }

    //判断是否为括号
    public static boolean isParentheses(String oper) {
        return oper.equals("(") || oper.equals(")");
    }

    //中缀转后缀
    public static Stack suffixesToSuffixes(Stack<String> s1, Stack<String> s2, String[] strings) {
        //对表达时进行扫描
        for (String itme : strings) {
            if (!isOperator(itme) && !isParentheses(itme)) {//表示为既不是运算符也不是括号，数字直接入s2
                s2.push(itme);
            } else if (isOperator(itme)) {//遇到运算符
                // 如果s1为空，或者栈顶元素为“（”直接将其压入运算符栈
                if (s1.isEmpty() || s1.peek().equals("(")) {
                    s1.push(itme);
                } else if (priority(itme) > priority(s1.peek())) {//如果优先级比s1栈顶元素的优先级高，将其直接入栈
                    s1.push(itme);
                } else if (priority(itme) <= priority(s1.peek())) {//如果优先级小于等于s1栈顶元素优先级，则将s1栈顶元素弹出并压入s2中，再次转到4.1与s1中新的栈顶元素比较
                    while (true) {
                        s2.push(s1.pop());
                        if (s1.isEmpty() || s1.peek().equals("(") || priority(itme) > priority(s1.peek())) {
                            s1.push(itme);
                            break;
                        }
                    }
                }
            } else if (isParentheses(itme)) {
                // 5.1）如果是左括号“（“，直接压入s1
                if (itme.equals("(")) {
                    s1.push(itme);
                }
                //5.2）如果是右括号”）“，则依次弹出s1栈顶元素，并压入s2，直到遇到”（“，并将这一对括号废弃
                if (itme.equals(")")) {
                    while (true) {
                        s2.push(s1.pop());
                        if (s1.peek().equals("(")) {
                            s1.pop();
                            break;
                        }
                    }
                }
            }
        }
        while (true) {
            s2.push(s1.pop());
            if (s1.isEmpty()) {
                break;
            }
        }
        return s2;
    }
}

标签：oper,itme,Java,中缀,s2,s1,栈顶,equals,表达式
来源： https://blog.csdn.net/rotry11/article/details/121137191

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。