Question

我正在阅读有关算法和数据结构的book，并尝试按照示例进行操作。我试图实现的是Dijkstra的用于表达式评估的双栈算法。它以( 1 + 2 ) * 3之类的字符串形式输入，然后计算表达式。我的代码编译但它没有产生正确的输出。

上述表达式的输出为：

3.0

这是我的代码：

public class Eval {
    public static void main(String[] args) {
        String s = "( 1 + 2 ) * 3";
        evaluateAndPrintResult(s);
    }
    public static void evaluateAndPrintResult(String s)
    {
        String[] str = s.split("\\s+");
        Queue<String> q = new LinkedList<String>();
        for(String ss : str)
            q.add(ss);
        Stack<String> ops = new Stack<String>();
        Stack<Double> vals = new Stack<Double>();
        while (!q.isEmpty())
        { // Read token, push if operator.
            String token = q.poll();
            if (token.equals("(")) ;
            else if (token.equals("+")) ops.push(s);
            else if (token.equals("-")) ops.push(s);
            else if (token.equals("*")) ops.push(s);
            else if (token.equals("/")) ops.push(s);
            else if (token.equals("sqrt")) ops.push(s);
            else if (token.equals(")"))
            { // Pop, evaluate, and push result if token is ")".
                String op = ops.pop();
                double v = vals.pop();
                if (op.equals("+")) v = vals.pop() + v;
                else if (op.equals("-")) v = vals.pop() - v;
                else if (op.equals("*")) v = vals.pop() * v;
                else if (op.equals("/")) v = vals.pop() / v;
                else if (op.equals("sqrt")) v = Math.sqrt(v);
                vals.push(v);
            } // Token not operator or paren: push double value.
            else vals.push(Double.parseDouble(token));
        }
        System.out.println(vals.pop());
    }
}

我不太了解该程序以纠正它。我怎样才能纠正我的程序？

Answer 1

您的问题出在您使用ops.push(s)的几个地方。您应该使用ops.push(token)。

您正在推动整个表达式，您应该只推送当前令牌。

此代码正确打印9.0。

public static void evaluateAndPrintResult(String s) {
    String[] str = s.split("\\s+");
    Queue<String> q = new LinkedList<>();
    q.addAll(Arrays.asList(str));
    Stack<String> ops = new Stack<>();
    Stack<Double> vals = new Stack<>();
    while (!q.isEmpty()) { // Read token, push if operator.
        String token = q.poll();
        if (token.equals("(")) {
        } else if (token.equals("+")) {
            ops.push(token);
        } else if (token.equals("-")) {
            ops.push(token);
        } else if (token.equals("*")) {
            ops.push(token);
        } else if (token.equals("/")) {
            ops.push(token);
        } else if (token.equals("sqrt")) {
            ops.push(token);
        } else if (token.equals(")")) { // Pop, evaluate, and push result if token is ")".
            // Replace the top exp with it' result.
            double v = vals.pop();
            String op = ops.pop();
            if (op.equals("+")) {
                v = vals.pop() + v;
            } else if (op.equals("-")) {
                v = vals.pop() - v;
            } else if (op.equals("*")) {
                v = vals.pop() * v;
            } else if (op.equals("/")) {
                v = vals.pop() / v;
            } else if (op.equals("sqrt")) {
                v = Math.sqrt(v);
            }
            vals.push(v);
        } else {
            // Token not operator or paren: push double value.
            vals.push(Double.parseDouble(token));
        }
    }
    System.out.println(vals.pop());
}

public void test() {
    evaluateAndPrintResult("( ( 1 + 2 ) * 3 )");
}

但是，表达式"( 1 + 2 ) * 3"仍然评估为3.0。要解决此问题，您需要评估推送的最后一个操作，如果有的话。

public static void evaluateAndPrintResult(String s) {
    String[] str = s.split("\\s+");
    Queue<String> q = new LinkedList<>();
    q.addAll(Arrays.asList(str));
    Stack<String> ops = new Stack<>();
    Stack<Double> vals = new Stack<>();
    while (!q.isEmpty()) { // Read token, push if operator.
        String token = q.poll();
        if (token.equals("(")) {
        } else if (token.equals("+")) {
            ops.push(token);
        } else if (token.equals("-")) {
            ops.push(token);
        } else if (token.equals("*")) {
            ops.push(token);
        } else if (token.equals("/")) {
            ops.push(token);
        } else if (token.equals("sqrt")) {
            ops.push(token);
        } else if (token.equals(")")) {
            vals.push(evaluateOp(ops, vals));
        } else {
            // Token not operator or paren: push double value.
            vals.push(Double.parseDouble(token));
        }
    }
    System.out.println(evaluateOp(ops, vals));
}

private static Double evaluateOp(Stack<String> ops, Stack<Double> vals) {
    // Replace the top exp with its result.
    double v = vals.pop();
    String op = ops.pop();
    if (op.equals("+")) {
        v = vals.pop() + v;
    } else if (op.equals("-")) {
        v = vals.pop() - v;
    } else if (op.equals("*")) {
        v = vals.pop() * v;
    } else if (op.equals("/")) {
        v = vals.pop() / v;
    } else if (op.equals("sqrt")) {
        v = Math.sqrt(v);
    }
    return v;
}

public void test() {
    evaluateAndPrintResult("( 1 + 2 ) * 3");
}

最后 - 这是一个更加整洁的方式。

public static void evaluateAndPrintResult(String s) {
    String[] str = s.split("\\s+");
    Queue<String> q = new LinkedList<>();
    q.addAll(Arrays.asList(str));
    Stack<String> ops = new Stack<>();
    Stack<Double> vals = new Stack<>();
    while (!q.isEmpty()) { // Read token, push if operator.
        String token = q.poll();
        switch (token) {
            case "(":
                break;
            case "+":
            case "-":
            case "*":
            case "/":
            case "sqrt":
                ops.push(token);
                break;
            case ")":
                vals.push(evaluateOp(ops, vals));
                break;
            default:
                // Token not operator or paren: push double value.
                vals.push(Double.parseDouble(token));
                break;
        }
    }
    System.out.println(s + " = " + evaluateOp(ops, vals));
}

private static Double evaluateOp(Stack<String> ops, Stack<Double> vals) {
    // Replace the top exp with its result.
    double v = vals.pop();
    if (!ops.empty()) {
        String op = ops.pop();
        switch (op) {
            case "+":
                v = vals.pop() + v;
                break;
            case "-":
                v = vals.pop() - v;
                break;
            case "*":
                v = vals.pop() * v;
                break;
            case "/":
                v = vals.pop() / v;
                break;
            case "sqrt":
                v = Math.sqrt(v);
                break;
            default:
                break;
        }
    }
    return v;
}

public void test() {
    evaluateAndPrintResult("( ( 1 + 2 ) * 3 )");
}

Answer 2

我已经阅读了本书的这一部分。该书提到，它提供的代码具有一些使其更简单的假设。

最重要的简化是表达式可以是：

一个数字。
左括号后跟一个表达式，后跟一个运算符，然后是一个表达式，再跟右括号。

也就是说，为了使根表达式可以被代码识别，必须将其括在括号中，即(( 1 + 2 ) * 3)。否则，您的堆栈将不会被完全清空。

Dijkstra的双栈算法用于表达式评估

2 个答案: