Question

我如何使用递归来简化表达式树？例如：

我尝试了一些不同的东西，但我无法弄清楚如何以一种能够简化它的方式递归树。感谢。

public static LinkedBinaryTree<String> simplify(LinkedBinaryTree<String> tree) throws IllegalArgumentException {
    // TODO: Implement this method
    if (!isArithmeticExpression(tree) || tree == null) {
        throw new IllegalArgumentException("Invalid arithmetic expression or Tree is null");
    }

    return simplify(tree.root(), tree);
}

public static LinkedBinaryTree<String> simplify(Position<String> p, LinkedBinaryTree<String> tree) {
    //      if (tree.isExternal(p)) {
    //          return tree;
    //      }
    if (isAlphaNumeric(p.getElement())) {

    }

    if (p.getElement().equals("+") || p.getElement().equals("+") || p.getElement().equals("+")) {

    }

    String element = p.getElement();
    char charLeft = tree.left(p).getElement().charAt(0);
    char charRight = tree.right(p).getElement().charAt(0);
    String stringLeft = tree.left(p).getElement();
    String stringRight = tree.right(p).getElement();

    //      if (stringLeft.equals("+") || stringLeft.equals("-") || stringLeft.equals("*")) {
    //          simplify(tree.left(p), tree);
    //      }

    //      if (!(Character.isLetter(charLeft) || Character.isDigit(charLeft))) {
    //          
    //      }

    return null;

}

Answer 1

这是一些伪代码，它会让你朝着正确的方向前进！

public int calculate() {
    return calculateNode(rootNode)
}

private int calculateNode(Node node) {
    if (node.isOperator()){
        int operandLeft = calculateNode(node.leftChild();
        int operandRight = calculateNode(node.leftChild();
        return node.getOperator().operateOn(operandLeft, operandRight);
    } else {
        return node.getValue()      
    }
}

函数calculate()意味着整个树上的函数是递归的集合。

递归函数calculateNode(Node node)的重要之处在于看到when-a-node-is-a-number的结束条件，但有时候为了实现递归函数应该调用自身也很棘手可以这么说，一次拨打两次。

Answer 2

这只是一个例子，但您可以根据自己的需要进一步调整：

int simplify(Node root) {

    if(root == null) {
        return 0;
    }
    int result;

    switch (root.value) {
        case "-":
            result = simplify(root.left) - simplify(root.right);
            break;
        case "+":
            result = simplify(root.left) + simplify(root.right);
            break;
        default:
            return Integer.parseInt(root.value);

    }
    return result;
}

所以我的想法是通过你的tree，你可以在这里找到两个案例：

节点的值是一个操作数，在这种情况下，您在应用给定操作数时递归地转到右侧和左侧节点。
节点的值是数字，然后您只需返回它的值。

如何使用递归简化算术表达式树？

2 个答案: