从中缀转换为后缀？Java计算器

我完全明白网上已经有很多这样的代码了，但是我已经看过了，我真的不明白我做错了什么。我正在创建一个计算器，将表达式从中缀转换为后缀，然后进行计算。我正在为它创建类；主要是一个gui，并已给出。我被这个问题难住了。这两个问题是：

• 由于某些原因，我的运算符优先级不起作用，当输出出现时，运算符实际上只是向后打印，例如我输入的 5+5/2，而不是给我5 5 2/+它给我5 5 2+/
• 我遇到的第二个问题是，我的数字不会像前面的例子那样只打印运算符，而不是得到5 2/+，我得到的只是+/

任何帮助都会被感激的，我真的很沮丧，甚至不能再思考了。你知道我的意思

这是我的计算器代码：

 import java.util.*;
import java.io.*;

public class Evaluator{
  private String infixExp;
  private char opPrec;
  private char op;


public Evaluator(String infixExp){
    this.infixExp = infixExp; // holds my infix expression inputted from gui
    this.opPrec = opPrec; // not being used
    this.op = op;
}
    private boolean isOperator(char op){ // not being used i dont think?
    return(op == '+' || op == '-' || op == '*' || op == '/'
    || op == '^' || op == '(' || op == ')' || op == '%'||  op == '=');
}
 // this is where I order the precedence
private int isLowerPrec(char op) {
    if (op == ('(') || op ==(')') || op ==('='))

    return 0;

    if (op ==('+') || op ==('-'))

    return 1;

    if (op == ('*') || op == ('/'))

    return 2;
    if (op == ('^')|| op ==('%') )

    return 3;
    else
        return -1;
} // end lowerPrecedence
/* converting the infix to postfix, must return expression as a String
   but numbers should be converted to doubles  */

public String Convert(){
    // must use stacks & queues 
    Stack <Character> exp = new Stack<Character>();
    Queue result = new LinkedList(); // not sure how to incorporate queue
    String postfix = "";
    int priority = 0;

    // going through infix expression
    for (int i = 0; i < infixExp.length(); i++){
     // expr(infixExp);
        op = infixExp.charAt(i);

        if(infixExp.length() == 0){
           continue;
        }

       // this is where I call my precedence
       // I know Im close but am missing something
        if(isLowerPrec(op) == -1){
           priority = -1; // pushing numbers onto stack
                if(exp.isEmpty() && priority == -1 ){
                postfix += exp.push(op);

             }
         }
         if(op == '+' || op == '-'){ // come first in stack
            priority = 1;
            isLowerPrec(op);
            if(priority == 1 && isLowerPrec(op) == 1 ){
                postfix += exp.push(op);

               }
           } 

             if(op == '*' || op == '/'){ // come second
                priority = 2;
                //isLowerPrec(op);

                if(priority == 2 && isLowerPrec(op) == 2 || exp.isEmpty()){
                      postfix += exp.push(op);
                     if(exp.peek() == '+' || exp.peek() == '-' ){
                     postfix += exp.push(op);

               }
            }   
        }
        if(op == '^'|| op ==('%')){ // come third
            priority = 3;
            isLowerPrec(op);
            if(priority == 3 && isLowerPrec(op) == 3){
                postfix += exp.push(op);

            }  


        }




       }
         // these must be deleted
        if(op == ')' || op == '(' || op == '='){ // delete
            priority = 4;
            isLowerPrec(op);
             if(priority == 4 && isLowerPrec(op) == 0){
                postfix += exp.push(op);
                 postfix += exp.pop();

            }                 
        }


            return postfix;
   }
 }      

import java.util.*；
导入java.io.*；
公共类评估员{
私有字符串infixExp；
私人char opPrec；
私有字符操作；
公共计算器（字符串infixExp）{
this.infixExp=infixExp；//保存从gui输入的中缀表达式
this.opPrec=opPrec；//未使用
this.op=op；
}
私有布尔等运算符（char op）{//未被使用我不认为？
返回（op='+'| | op='-'| | op='*'| | op='/'
||op='^'| | op='（'| | op='）'| | op='%'| | op='='）；
}
//这是我排列优先顺序的地方
私人int isLowerPrec（字符操作）{
如果（op==（'（'）| | op==（'））| | op==（'=））
返回0；
如果（op==（'+'）| | op==（'-'））
返回1；
如果（op==（'*'）| | op==（'/'））
返回2；
如果（op==（'^'）| | op==（'%'））
返回3；
其他的
返回-1；
}//结束下限接收
/*将中缀转换为后缀必须以字符串形式返回表达式
但是数字应该转换成双倍*/
公共字符串转换（）{
//必须使用堆栈和队列
Stack exp=新堆栈（）；
Queue result=new LinkedList（）；//不确定如何合并队列
字符串后缀=”；
int优先级=0；
//通过中缀表达式
对于（int i=0；i

我没有包括gui计算器代码，只是因为它很长。 如果我必须的话，我可以。不过，谢谢你的帮助和建议

关于你的第二个问题： 代码不打印数字的原因是中的条件

exp.isEmpty（）

if(exp.isEmpty() && priority == -1 ){
    postfix += exp.push(op);

也就是说，只要将第一个符号推到

exp

上，就不会再读取数字文字，因为读取方括号时只会

pop

堆栈

关于你的第一个问题： 我不确定您的算法应该做什么，但在我看来，它似乎将它能找到的每个符号添加到字符串

后缀

，因此基本上它只是复制输入字符串，而不是转换它。因此，运算符总是按照它们在字符串中出现的顺序打印，而不是按照所需的顺序打印

你如何处理这个问题 我无法帮助您直接修复现有代码，因为似乎缺少太多的实现。但是，我可能会帮助您从不同的角度看待这个问题

将表达式视为一棵树，将数值文字视为叶子，将运算符视为节点。例如，表达式

1+2*（3-4）/5将由以下树表示：


现在，要以后缀形式打印此树，您需要以后缀形式打印左子树，然后以后缀形式打印右子树，然后打印节点本身的值。一步一步地，我们将打印树，如下所示：


打印叶
1
（打印
“1”
）
在
/

在
*

打印叶子
2
在
-

打印叶子
3
打印叶子
4
打印操作员
-

打印操作员
*

打印leaf
5
public abstract class ExpressionTree {
    public abstract String postfixString();
}

public class ExpressionTreeNode extends ExpressionTree {
    final Operator operator;
    final ExpressionTree left, right;

    public ExpressionTreeNode(Operator operator, ExpressionTree left, ExpressionTree right) {
        this.operator = operator;
        this.left = left;
        this.right = right;
    }

    public String toString() {
        return String.format("Node(%s, %s, %s)", operator.toString(), left.toString(), right.toString());
    }

    public String postfixString() {
        return String.format("%s %s %s", left.postfixString(), right.postfixString(), operator.toString());
    }
}

public class ExpressionTreeLeaf extends ExpressionTree {
    final int value;

    public ExpressionTreeLeaf(int value) {
        this.value = value;
    }

    public String toString() {
        return String.format("Leaf(%d)", value);
    }

    public String postfixString() {
        return String.valueOf(value);
    }
}

public enum Operator {
    ADDITION, SUBTRACTION, MULTIPLICATION, DIVISION, POWER, MODULO;

    public String toString() {
        switch (this) {
            case ADDITION:
                return "+";
            case SUBTRACTION:
                return "-";
            case MULTIPLICATION:
                return "*";
            case DIVISION:
                return "/";
            case POWER:
                return "^";
            case MODULO:
                return "%";
            default:
                throw new IllegalStateException("Unknown Operator");
        }
    }
}

System.out.println(
        new ExpressionTreeNode(
                Operator.ADDITION,
                new ExpressionTreeLeaf(1),
                new ExpressionTreeNode(
                        Operator.DIVISION,
                        new ExpressionTreeNode(
                                Operator.MULTIPLICATION,
                                new ExpressionTreeLeaf(2),
                                new ExpressionTreeNode(
                                        Operator.SUBTRACTION,
                                        new ExpressionTreeLeaf(3),
                                        new ExpressionTreeLeaf(4)
                                )
                        ),
                        new ExpressionTreeLeaf(5)
                )
        ).postfixString()
);