Java 如何使用递归方法查找前缀表达式的值？

我有以下伪代码，需要编写一个java方法来计算前缀表达式：

prefixExpression（prefixExpression）的算法值
输入：前缀形式的有效正整数算术表达式
返回值：前缀表达式的值

如果下一个标记是整数
返回整数
否则
读一个操作符，说op
第一个操作数获取prefixexpression（remainingExpression）的值
第二个操作数获取prefixexpression（remainingExpression）的值
返回第一个操作数操作第二个操作数
恩迪夫

如何编写此方法？我尝试了这个，我认为它可能是正确的，但我得到了一个“缺少返回语句”错误，所以我无法编译。假设仅当args有1个或多个元素时才调用方法。（无空数组）

公共静态int前缀算法（字符串[]args）{
对于（int i=0；i

带输入和扫描仪的前缀评估器： 不带输入和队列的前缀赋值器：

import java.util.*；
公共类前缀赋值器{
公共静态void main（字符串[]args）{
字符串输入=“-*+4 3 2 5”；
字符串[]表达式=input.split（“”）；
Queue expressionQueue=新建LinkedList（）；
for（字符串元素：表达式）
{
expressionQueue.add（元素）；
}
System.out.println（“value=“+evaluate（expressionQueue））；
}
//pre:input包含合法前缀表达式
//post：使用表达式并返回结果
公共静态双重求值（队列输入）{
如果（input.peek（）！=null&&input.peek（）.matches（“^（-）\\d+$”）
{
返回Long.parseLong（input.poll（））；
}
其他的
{
字符串运算符=input.poll（）；
双操作数1=计算（输入）；
双操作数2=计算（输入）；
返回求值（运算符、操作数1、操作数2）；
}
}
//前置：运算符是+、-、*、/或%之一
//post：返回将给定运算符应用于的结果
//给定的操作数
公共静态双计算（字符串运算符，双操作数1，
双操作数（2）{
if（运算符等于（“+”）{
返回操作数1+2；
}else if（运算符等于（“-”）{
返回操作数1-操作数2；
}else if（运算符等于（“*”）{
返回操作数1*2；
}else if（运算符等于（“/”）{
返回操作数1/2；
}else if（运算符等于（“%”）{
返回操作数1%操作数2；
}否则{
抛出新的运行时异常（“非法运算符”+运算符）；
}
}
}

I/O示例： 这个程序计算前缀表达式

对于运算符+、-、*、/和%

表达式？-*+4 3 2 5

数值=9.0

文档： 队列：

---

模式：

您的编译问题是因为您没有从该方法获得保证的返回。如果arg[i]不是整个数组所需的四个字符之一，则只需从函数的底部运行

---

您可能认为输入将始终符合预期，但编译器知道最好不要相信人。：-）

这是一项非常奇怪的任务。前缀（和后缀）表示法的全部要点是，您不需要递归，只需要一个结果堆栈。看起来很棒！如果在不使用扫描器的情况下运行程序时希望从命令行获取输入，您将如何编写此代码？我可能会使用queue，因为您可以很容易地删除第一个元素，并使用一个简单的正则表达式来检查是否为number@moist_beetle检查我编辑的答案，我在您的需求中添加了一个新的解决方案。

public static int prefixAlgorithm(String[] args) {
    for (int i = 0; i < args.length; i++) {
        if (!args[i].equals("+") && !args[i].equals("-")
                && !args[i].equals("*") && !args[i].equals("/")) {
            int operand = parseInt(args[i]);
            return operand;
        } else {
            int firstOperand = prefixAlgorithm(Arrays.copyOfRange(args, i, (args.length - 1)));
            int secondOperand = prefixAlgorithm(Arrays.copyOfRange(args, i, (args.length - 1)));
            if (args[i].equals("+")) {
                return firstOperand + secondOperand;
            } else if (args[i].equals("-")) {
                return firstOperand - secondOperand;
            } else if (args[i].equals("*")) {
                return firstOperand * secondOperand;
            } else if (args[i].equals("/")) {
                return firstOperand / secondOperand;
            }
        }
    }
}

import java.util.*;

public class PrefixEvaluator {
    public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        System.out.println("This program evaluates prefix expressions");
        System.out.println("for operators +, -, *, / and %");
        System.out.print("expression? ");
        System.out.println("value = " + evaluate(console));
    }

    // pre : input contains a legal prefix expression
    // post: expression is consumed and the result is returned
    public static double evaluate(Scanner input) {
        if (input.hasNextDouble()) {
            return input.nextDouble();
        } else {
            String operator = input.next();
            double operand1 = evaluate(input);
            double operand2 = evaluate(input);
            return evaluate(operator, operand1, operand2);
        }
    }

    // pre : operator is one of +, -, *, / or %
    // post: returns the result of applying the given operator to
    //       the given operands
    public static double evaluate(String operator, double operand1,
                                  double operand2) {
        if (operator.equals("+")) {
            return operand1 + operand2;
        } else if (operator.equals("-")) {
            return operand1 - operand2;
        } else if (operator.equals("*")) {
            return operand1 * operand2;
        } else if (operator.equals("/")) {
            return operand1 / operand2;
        } else if (operator.equals("%")) {
            return operand1 % operand2;
        } else {
            throw new RuntimeException("illegal operator " + operator);
        }
    }
}

import java.util.*;

public class PrefixEvaluator {
    public static void main(String[] args) {
        String input = "- * + 4 3 2 5";
        String[] expression = input.split ( " " );

        Queue<String> expressionQueue = new LinkedList<String>();

        for (String element : expression)
        {
            expressionQueue.add ( element );
        }

        System.out.println("value = " + evaluate(expressionQueue));
    }

    // pre : input contains a legal prefix expression
    // post: expression is consumed and the result is returned
    public static double evaluate(Queue <String> input) {
        if(input.peek ( ) != null && input.peek ( ).matches ( "^(-?)\\d+$" ))
        {
            return Long.parseLong ( input.poll ( ) );
        }
        else 
        {
            String operator = input.poll();
            double operand1 = evaluate(input);
            double operand2 = evaluate(input);
            return evaluate(operator, operand1, operand2);
        }
    }

    // pre : operator is one of +, -, *, / or %
    // post: returns the result of applying the given operator to
    //       the given operands
    public static double evaluate(String operator, double operand1,
                                  double operand2) {
        if (operator.equals("+")) {
            return operand1 + operand2;
        } else if (operator.equals("-")) {
            return operand1 - operand2;
        } else if (operator.equals("*")) {
            return operand1 * operand2;
        } else if (operator.equals("/")) {
            return operand1 / operand2;
        } else if (operator.equals("%")) {
            return operand1 % operand2;
        } else {
            throw new RuntimeException("illegal operator " + operator);
        }
    }
}