设计带解析函数的表达式树

// LeetCode 1628: Design an Expression Tree With Evaluate Function
// Java solution using streams is not typical but here is an approach for demonstration

import java.util.*;
import java.util.function.Function;
import java.util.stream.*;

// Interface for the Node class
interface Node {
    public int evaluate();
}

// Abstract class representing a tree node
abstract class TreeNode implements Node {
    protected TreeNode left;
    protected TreeNode right;
    
    public TreeNode(TreeNode left, TreeNode right) {
        this.left = left;
        this.right = right;
    }
}

// Implementation of operand nodes
class OperandNode extends TreeNode {
    private int value;
    
    public OperandNode(int value) {
        super(null, null);
        this.value = value;
    }
    
    @Override
    public int evaluate() {
        return this.value;
    }
}

// Implementation of operator nodes
class OperatorNode extends TreeNode {
    private char operator;
    
    public OperatorNode(char operator, TreeNode left, TreeNode right) {
        super(left, right);
        this.operator = operator;
    }
    
    @Override
    public int evaluate() {
        int leftVal = left.evaluate();
        int rightVal = right.evaluate();
        switch (operator) {
            case '+': return leftVal + rightVal;
            case '-': return leftVal - rightVal;
            case '*': return leftVal * rightVal;
            case '/': return leftVal / rightVal;
            default: throw new UnsupportedOperationException("Invalid operator");
        }
    }
}

// Expression tree class
class TreeBuilder {
    public Node buildTree(String[] postfix) {
        Deque<TreeNode> stack = new ArrayDeque<>();
        Arrays.stream(postfix).forEach(token -> {
            if (isOperator(token)) {
                TreeNode right = stack.pop();
                TreeNode left = stack.pop();
                stack.push(new OperatorNode(token.charAt(0), left, right));
            } else {
                stack.push(new OperandNode(Integer.parseInt(token)));
            }
        });
        return stack.pop();
    }
    
    private boolean isOperator(String token) {
        return "+-*/".contains(token);
    }
}

// Usage example
public class Main {
    public static void main(String[] args) {
        String[] postfix = {"3", "4", "+", "2", "*", "7", "/"};
        TreeBuilder builder = new TreeBuilder();
        Node root = builder.buildTree(postfix);
        System.out.println(root.evaluate()); // Output should be 2
    }
}