使用Java将中缀表达式转换为前缀和后缀表达式

我想制作一个应用程序，将表达式从中缀模式转换为后缀和前缀模式

例如：

中缀：a+b*c

后缀：abc*+

前缀：+a*bc

我需要两个类，一个用于后缀转换的类，另一个用于前缀转换的类

此外，我还为堆栈编写了一个类，如下所示：

public class Stack {

int top = 0;
int stackSize = 0;
String[] stack;

public Stack(int stackSize){
    this.stackSize = stackSize;
    stack = new String[stackSize];
}

public int getTop(){
    return top;
}

public void push(String arg)throws Exception{
    if(top == stackSize){
        throw new Exception("Stack is full!");
    }
    else{
        this.stack[top++] = arg;
    }
}

public String pop()throws Exception{
    if(top == 0){
        throw new Exception("Stack is empty");
    }
    else{
        return this.stack[--top];
    }
}

public int stackCount(){
    return top++;
}
}

我尝试将此代码作为后缀类：

public class Postfix {
Stack stack = new Stack(1000);
char []operators = {'(','*','%','/','+','-',')'}; 
char[] infixExpression;
public Postfix(String infixExpression){
    this.infixExpression = infixExpression.toCharArray();
}

int priority(char operator){
    int result = 0;
    switch(operator){
    case '(':
        result = 1;
        break;
    case '*':
        result = 2;
        break;
    case '%':
        result = 3;
        break;
    case '/':
        result = 4;
        break;
    case '+':
        result = 5;
        break;
    case '-':
        result = 5;
        break;
    case ')':
        result = 7;
    }
    return result;
}

public String convertToPostfix(){
    int priority;
    String lastData;
    String exp = "";
    for(int i = 0;i<this.infixExpression.length;i++){
        priority = priority(this.infixExpression[i]);
        if(priority == 0){
            exp += this.infixExpression[i];
        }
        else if(priority == 1){
            try {
                stack.push(String.valueOf(this.infixExpression[i]));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        else if(priority == 7){
            while(stack.top != 0){
                try {
                    lastData = stack.pop();
                    if(!lastData.equals("(")){
                        exp += lastData;
                    }
                    else{
                        break;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        else{
            try { 
                if(stack.top != 0){
                    while(true){
                        lastData = stack.pop();
                        stack.push(lastData);
                        if(stack.top == 0 || lastData.equals("(") || priority(lastData.toCharArray()[0]) > priority){
                            stack.push(String.valueOf(this.infixExpression[i]));
                            break;
                        }
                        exp += stack.pop();
                    }
                }else{
                    stack.push(String.valueOf(this.infixExpression[i]));
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    if(stack.top != 0){
        try {
            while(stack.top != 0){
                exp += stack.pop();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return exp;
}
}

公共类后缀{
堆栈=新堆栈（1000）；
char[]运算符={'（'，'*'，'%'，'/'，'+'，'-'，'）'}；
char[]infixExpression；
公共后缀（字符串infixExpression）{
this.infixExpression=infixExpression.toCharArray（）；
}
int优先级（字符运算符）{
int结果=0；
开关（操作员）{
格“（”：
结果=1；
打破
案例“*”：
结果=2；
打破
案例“%”：
结果=3；
打破
案例“/”：
结果=4；
打破
格“+”：
结果=5；
打破
案例'-'：
结果=5；
打破
案例“）”：
结果=7；
}
返回结果；
}
公共字符串convertToPostfix（）{
int优先级；
字符串数据；
字符串exp=“”；
for（int i=0；i优先级）{
stack.push（String.valueOf（this.infixExpression[i]）；
打破
}
exp+=stack.pop（）；
}
}否则{
stack.push（String.valueOf（this.infixExpression[i]）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
}
如果（stack.top！=0）{
试一试{
while（stack.top！=0）{
exp+=stack.pop（）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
返回经验；
}
}

但这不适用于括号。

您只需要：

将输入表达式拆分为项目，将项目拆分为乘数

按需要的顺序添加到缓冲区部分和分隔符

执行此操作的一些错误代码：

public class Converter {

    private String infix;

    private void addMultPre(StringBuilder builder, String item) {
        String[] multipliers = item.split("[*/]");
        for (int j = 0; j < multipliers.length - 1; j++) {
            builder.append(infix.charAt(builder.length() + multipliers[j].length()));
            builder.append(multipliers[j]);
        }
        builder.append(multipliers[multipliers.length - 1]);
    }

    private void addMultPost(StringBuilder builder, String item) {
        String[] multipliers = item.split("[*/]");
        builder.append(multipliers[0]);
        for (int j = 1; j < multipliers.length; j++) {
            builder.append(multipliers[j]);
            builder.append(infix.charAt(builder.length()));
        }
    }

    public String prefix() {
        String[] items = infix.split("[+-]");
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < items.length - 1; i++) {
            builder.append(infix.charAt(builder.length() + items[i].length()));
            addMultPre(builder, items[i]);
        }
        addMultPre(builder, items[items.length - 1]);
        return builder.toString();
    }

    public String postfix() {
        String[] items = infix.split("[+-]");
        StringBuilder builder = new StringBuilder();
        char sign;
        addMultPost(builder, items[0]);
        for (int i = 1; i < items.length; i++) {
            sign = infix.charAt(builder.length());
            addMultPost(builder, items[i]);
            builder.append(sign);
        }
        return builder.toString();
    }

    public Converter(String infix) {
        this.infix = infix;
    }

    public static void main(String[] args) {
        Converter c = new Converter("a+b*c");
        System.out.println(c.postfix());
        System.out.println(c.prefix());
    }
}

---

我想为后缀和前缀转换编写两个类。这是一个数学项目。。。谢谢，这仍然是毫无疑问的。告诉我们你做了什么，你的问题在哪里，我们可以给你帮助。我不知道做这个项目，我试图写，但我有问题。有必要在这里写我的代码吗？你应该问一些关于你遇到的问题的具体问题。在堆栈溢出时，要求他人为您编写代码是不可接受的。如果您试图编写一些东西，但遇到了问题，请询问此问题并包含您的代码。我编辑了此问题。根本不处理括号，如果它正确处理运算符优先级，我会感到惊讶。

abc*+
+a*bc