Design an Expression Tree With Evaluate Function

Design an Expression Tree With Evaluate Function - Problem

Array Math Stack Tree Design Binary Tree Medium

Given the postfix tokens of an arithmetic expression, build and return the binary expression tree that represents this expression.

Postfix notation is a notation for writing arithmetic expressions in which the operands (numbers) appear before their operators. For example, the postfix tokens of the expression 4*(5-(7+2)) are represented in the array postfix = ["4","5","7","2","+","-","*"].

The class Node is an interface you should use to implement the binary expression tree. The returned tree will be tested using the evaluate function, which is supposed to evaluate the tree's value.

A binary expression tree is a kind of binary tree used to represent arithmetic expressions. Each node of a binary expression tree has either zero or two children. Leaf nodes (nodes with 0 children) correspond to operands (numbers), and internal nodes (nodes with two children) correspond to the operators '+' (addition), '-' (subtraction), '*' (multiplication), and '/' (division).

It's guaranteed that no subtree will yield a value that exceeds 10⁹ in absolute value, and all the operations are valid (i.e., no division by zero).

Follow up: Could you design the expression tree such that it is more modular? For example, is your design able to support additional operators without making changes to your existing evaluate implementation?

Input & Output

Example 1 — Basic Expression

$ Input: postfix = ["3","4","+","2","*"]

› Output: 14

💡 Note: The expression is (3 + 4) * 2 = 7 * 2 = 14. First we add 3 and 4, then multiply by 2.

Example 2 — Division and Subtraction

$ Input: postfix = ["4","5","+","2","*"]

› Output: 18

💡 Note: The expression is (4 + 5) * 2 = 9 * 2 = 18. First we add 4 and 5 to get 9, then multiply by 2.

Example 3 — Single Number

$ Input: postfix = ["15"]

› Output: 15

💡 Note: Single operand case: the tree has only one node containing 15, so the result is 15.

Constraints

1 ≤ postfix.length ≤ 100
postfix[i] is either an integer or one of '+', '-', '*', '/'
All integers are in range [-100, 100]
The given expression is always valid
The result and all intermediate calculations fit in 32-bit integers

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 Apple 12

The key insight is using a stack to build the expression tree from postfix notation. When we encounter operands, we create leaf nodes. When we encounter operators, we pop two nodes from the stack as children and create a new internal node. The optimal approach uses modular design with abstract Node interface for easy extensibility. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force Stack Construction

⏱️ Time: O(n) Space: O(n)

Process postfix tokens using a stack. For operands, create leaf nodes. For operators, pop two nodes as children and create internal node. The single remaining node is the root.

Optimized Stack with Modular Design

⏱️ Time: O(n) Space: O(n)

Process postfix tokens using stack but with abstract Node interface that separates node creation from evaluation. This allows easy addition of new operators without changing evaluation logic.

Brute Force Stack Construction — Algorithm Steps

Create stack to hold nodes
Process each token: if operand create leaf, if operator create internal node with two children
Pop final node as root

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Operands

Push leaf nodes for numbers onto stack

Process Operators

Pop two nodes, create operator node with them as children

Final Tree

Stack contains root of complete expression tree

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct TreeNode {
    char val[20];
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

TreeNode* createNode(char* val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    strcpy(node->val, val);
    node->left = NULL;
    node->right = NULL;
    return node;
}

int evaluate(TreeNode* node) {
    if (isdigit(node->val[0]) || (node->val[0] == '-' && strlen(node->val) > 1)) {
        return atoi(node->val);
    }
    
    int leftVal = evaluate(node->left);
    int rightVal = evaluate(node->right);
    
    if (strcmp(node->val, "+") == 0) return leftVal + rightVal;
    if (strcmp(node->val, "-") == 0) return leftVal - rightVal;
    if (strcmp(node->val, "*") == 0) return leftVal * rightVal;
    if (strcmp(node->val, "/") == 0) return leftVal / rightVal;
    
    return 0;
}

TreeNode* solution(char postfix[][20], int size) {
    TreeNode* stack[1000];
    int top = -1;
    
    for (int i = 0; i < size; i++) {
        TreeNode* node = createNode(postfix[i]);
        
        if (strcmp(postfix[i], "+") == 0 || strcmp(postfix[i], "-") == 0 || 
            strcmp(postfix[i], "*") == 0 || strcmp(postfix[i], "/") == 0) {
            node->right = stack[top--];
            node->left = stack[top--];
        }
        
        stack[++top] = node;
    }
    
    return stack[0];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char postfix[100][20];
    int size = 0;
    
    // Parse JSON array format
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end) {
        start++; // Skip [
        *end = '\0'; // Terminate at ]
        
        char* token = strtok(start, ",");
        while (token && size < 100) {
            // Skip spaces
            while (*token == ' ') token++;
            
            // Remove quotes
            if (*token == '"') {
                token++;
                char* quote_end = strchr(token, '"');
                if (quote_end) *quote_end = '\0';
            }
            
            if (strlen(token) > 0) {
                strcpy(postfix[size++], token);
            }
            token = strtok(NULL, ",");
        }
    }
    
    TreeNode* root = solution(postfix, size);
    printf("%d\n", evaluate(root));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n tokens, each operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

Stack stores up to n nodes in worst case, plus tree structure uses O(n) space

⚡ Linearithmic Space

31.5K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Stack Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler