Question

我一直试图找出我的代码的错误无济于事。除了评估后缀表达式之外，我应该将中缀编码为postfix翻译器。我的代码运行，但不幸的是它没有返回正确的值。

我有一个计算器GUI，只要按下等号，就会调用下面显示的代码。计算器将以空格分隔的字符串作为参数传递。然后我在这个空格分隔的字符串上使用String Tokenizer并从那里开始工作。如果它有帮助，我可以提供计算器GUI的代码。

我的问题在于计算器提供的答案。例如，如果我输入（5 + 2），则计算器返回2作为答案，如果我再次按等号，则返回5作为答案。如果我输入（5 * 2）+（3 * 9），则返回9作为答案，如果我再次按等号，则返回5作为答案。我已尝试多次浏览我的代码，但不幸的是我无法找到我的错误。任何帮助将不胜感激！

免责声明：我知道有关使用字符串标记符的附注。我会使用其他东西，但这是要求之一。我还没有实现任何错误检查或检查优先级，因为我想确保它正常工作假设输入是正确的并且首先不是过于复杂。此外，我知道我的代码将无法正确处理像（5 + 2）-1这样的东西，因为1周围缺少括号。但是再次它不会用于比这更简单的东西。一旦我能用更简单的输入工作，我会担心这一点。最后，这确实是一项家庭作业，但请不要认为我希望完全为我完成这项工作。我们将非常感谢您的一些指示。

这是我的代码：

public class ExpressionEvaluator {

Stack<String> myStack = new Stack<>();
Queue<String> myQueue = new Queue<>();

String curToken; //Current token of my tokenized string.
double temp1;    //Place holder for first value of the calc section.
double temp2;    //Place holder for second value of the calc section.

public String processInput(String s) {

    StringTokenizer st = new StringTokenizer(s);

    while (st.hasMoreTokens()) {

        curToken = st.nextToken();

        if (openParenthesis(curToken)) {
            myStack.push(curToken);
        }

        if (closeParenthesis(curToken)) {
            do {
                myQueue.enqueue(myStack.pop());
            } while (!openParenthesis(myStack.peek()));
        }

        if (isOperator(curToken)) {
            while (!myStack.isEmpty() && !openParenthesis(myStack.peek())) {
                myQueue.enqueue(myStack.pop());
            }
            myStack.push(curToken);
        }
        if (isDouble(curToken)) {
            myQueue.enqueue(curToken);
        }
    }

    while (!myStack.isEmpty()) {
        myQueue.enqueue(myStack.pop());
    }

    while (!myQueue.isEmpty()) {
        if (isDouble(myQueue.peek())) {
            myStack.push(myQueue.dequeue());
        }

        else if (isOperator(myQueue.peek())) {
            temp1 = Double.parseDouble(myStack.pop());
            temp2 = Double.parseDouble(myStack.pop());
            myStack.push(Double.toString(calc(temp1, temp2)));
        }

        else {
            myQueue.dequeue();
        }
    }
    return myStack.pop();
}

 //Private methods used to simplify/clarify some things.


 //Checks if input is an operator, returns true if it is
private boolean isOperator(String str) {
    if (str == "+") {return true;}
    else if (str == "-") {return true;}
    else if (str == "*") {return true;}
    else if (str == "/") {return true;}
    else if (str == "^") {return true;}
    else {return false;}
}

 //Checks if input is an open parenthesis "(", returns true if it is

private boolean openParenthesis(String str) {
    if (str == "(") {return true;}
    else {return false;}
}

 //Checks if input is a close parenthesis ")", returns true if it is

private boolean closeParenthesis(String str) {
    if (str == ")") {return true;}
    else {return false;}
}

 //Checks if input is a double, returns true if it is
 //I actually got this method from Stack Overflow, so thanks!

private boolean isDouble(String str) {
    try {
        Double.parseDouble(str);
        return true;
    } catch (NumberFormatException e) {
        return false;
    }
}

 //Method used to actually do the calculations. I have
 //a feeling this is where my problem is, but I can't
 //think of a way to fix it.

private double calc(double a, double b) {
    String op = myQueue.dequeue();

    if (op == "+") {return a+b;}
    else if (op == "-") {return a-b;}
    else if (op == "*") {return a*b;}
    else if (op == "/") {return a/b;}
    else if (op == "^") {return Math.pow(a, b);}
    else {throw new UnknownElementException(null, "ERROR");}
}
 }

抱歉这个奇怪的缩进。任何帮助将不胜感激！

Answer 1

有一个名为 Shunting-yard 的算法，它指定了如何将中缀符号转换为后置符号（也称为＆＃34;反向波兰符号＆＃34;）。然后，您不必担心运营商优先权。

它使用队列和堆栈。基本上，当您遇到一个数字时，您将其添加到队列中。当你遇到操作员时，你将它们推到堆栈上。

您可以在此处找到详细算法：Shunting-Yard Algorithm

一旦采用反向抛光表示法，您可以轻松评估它，如下所述： Postfix evaluation algorithm

Answer 2

我终于明白了！我使用==而不是.equals（）来比较我的isOperator，closeParenthesis和openParenthesis方法中的字符串。

Postfix评估程序未返回正确的结果

2 个答案: