Question

这是来自aws educate的问题。我一直在考虑这个问题，而且我并没有真正去任何地方。

您希望使用二叉树在整数上编码中缀算术表达式。操作是加法和乘法画一幅树的样子。写一个类定义。编写evaluate（）成员函数。你将如何使用evaluate（）迭代而不是递归

如果我能得到一个很好的解释或一些例子

Answer 1

问题是要求你写一个树类，它可以代表像＆＃34; 2 + 2＆＃34;或＆＃34; 3 * 1 + 5＆＃34;。因此，该类表示一个树，它具有根和内部节点，这些节点与＆＃34; *＆＃34;的应用程序相对应。或＆＃34; +＆＃34;运营商。叶节点将对应于整数值，如＆＃34; 5＆＃34;或＆＃34; 2＆＃34;正在进行的。从这样的树产生结果的典型评估函数可能是递归的。他们要求您也考虑如何迭代地得出结果。这种迭代方法可能涉及将节点连续添加到队列或堆栈数据结构中，并逐个弹出它们以便以某种方式处理。

见这里：https://en.wikipedia.org/wiki/Tree_traversal

Answer 2

插图 - 在整数上编码中缀算术表达式的二叉树

如您所见，叶子是值（或文字），其他节点包含算术运算符（+， - ，/，*）

一些代码 - 重复

在Java中，您可以使用递归来解决此问题（在树的高度不大的情况下）

public class Main {

    public static void main(String[] args) {
        // op1=(1 + 2)
        Node op1 = new Node(1, "+", 2);
        System.out.println("op1="+op1.evaluate()); // op1=3

        // op2=(1 + 2) + 3
        Node op2 = new Node(op1, "+", 3);
        System.out.println("op2="+op2.evaluate()); // op2=6

        // op3=(4 * 5)
        Node op3 = new Node(4, "*", 5);
        System.out.println("op3="+op3.evaluate()); // op3=20

        // op4=((1+2)+3)*(4*5)
        Node op4 = new Node(op2, "*", op3);
        System.out.println("op4="+op4.evaluate()); // op4=120
    }
}

class Node {

    private Node left;
    private Node right;
    private String operatorOrLiteral;

    public Node(String value){
        this.operatorOrLiteral = value;
    }

    public Node(Node left, String operation, Node right){
        this.operatorOrLiteral = operation;
        this.left = left;
        this.right = right;
    }

    public Node(int literal1, String operation, int literal2){
        this(new Node(Integer.toString(literal1)), operation, new Node(Integer.toString(literal2)));
    }

    public Node(Node left, String operation, int literal2) {
        this(left, operation, new Node(Integer.toString(literal2)));
    }

    public Node(int literal1, String operation, Node right) {
        this(new Node(Integer.toString(literal1)), operation, right);
    }

    public int evaluate(){
        if(isLiteral()) {
            return Integer.parseInt(operatorOrLiteral);
        }

        switch (operatorOrLiteral) {
            case "*": return left.evaluate() * right.evaluate();
            case "/": return left.evaluate() / right.evaluate();
            case "-": return left.evaluate() - right.evaluate();
            case "+": return left.evaluate() + right.evaluate();
            default: throw new IllegalArgumentException(operatorOrLiteral + " is not recognised");
        }
    }

    private boolean isLiteral() {
        return left == null && right == null;
    }

    public String toString() {
        if(isLiteral()) {
            return operatorOrLiteral;
        }

        return "(" + left.toString() + operatorOrLiteral + right.toString() + ")";
    }
}

一些代码 - 迭代

或者如上所述@David Sanders，您可以使用树遍历。

使用二叉树在整数上编码中缀算术表达式

2 个答案: