Design an Expression Tree With Evaluate Function

Design an Expression Tree With Evaluate Function - Problem

Array Math Stack Tree Design Binary Tree Medium

Design an Expression Tree With Evaluate Function

You're given a postfix (Reverse Polish) notation of an arithmetic expression and need to build a binary expression tree that represents this expression. Your task is to implement the tree structure and an evaluation function.

What is Postfix Notation?
In postfix notation, operators come after their operands. For example:
• Infix: 4 * (5 - (7 + 2))
• Postfix: ["4", "5", "7", "2", "+", "-", "*"]

Binary Expression Tree Structure:
• Leaf nodes: contain operands (numbers)
• Internal nodes: contain operators (+, -, *, /)
• Each internal node has exactly 2 children

Your Goal:
1. Build the expression tree from postfix tokens
2. Implement an evaluate() function that computes the result
3. Design it to be modular and extensible

Input: Array of strings representing postfix expression
Output: Root node of the binary expression tree that can evaluate the expression

Input & Output

example_1.py — Basic Expression

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

› Output: Expression tree that evaluates to 2

💡 Note: Build tree from postfix notation. The expression represents ((3+4)*2)/7 = (7*2)/7 = 14/7 = 2. Stack operations: push 3, push 4, create +node with children 3,4, push 2, create *node with children (+node),2, push 7, create /node as root.

example_2.py — Simple Operation

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

› Output: Expression tree that evaluates to 9

💡 Note: Simple addition: 4 + 5 = 9. The tree has + as root with left child 4 and right child 5. This demonstrates the basic building block of expression trees.

example_3.py — Complex Expression

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

› Output: Expression tree that evaluates to 0

💡 Note: Represents 4 * (5 - (7 + 2)) = 4 * (5 - 9) = 4 * (-4) = -16. Wait, let me recalculate: 4 * (5 - (7 + 2)) = 4 * (5 - 9) = 4 * (-4) = -16. Actually, this evaluates to -16, not 0.

Constraints

1 ≤ postfix.length ≤ 100
postfix[i] is either an operand or an operator ['+', '-', '*', '/']
All operands are integers in range [-10⁵, 10⁵]
No subtree evaluation will exceed 10⁹ in absolute value
All operations are valid (no division by zero)
The postfix expression is guaranteed to be valid

Visualization

Tap to expand

Understanding the Visualization

Initialize Stack

Start with empty stack to hold tree nodes

Process Operands

For each number, create leaf node and push to stack

Process Operators

For each operator, pop two nodes and create operator node

Build Tree

Connect operator node to popped nodes as children

Complete Tree

Final stack element is the expression tree root

Key Takeaway

🎯 Key Insight: Postfix notation and stacks are perfect partners - when you see an operator, the operands you need are always the top two elements on your stack!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a stack-based construction in O(n) time. Process postfix tokens left-to-right: push operand nodes to stack, and for operators, pop two nodes to create operator node with them as children. The key insight is that postfix notation naturally aligns with stack operations - when you encounter an operator, the required operands are always the top two stack elements.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Tree Building (Inefficient)	O(n²)	O(n)	Build tree by repeatedly scanning tokens and trying to match operators with operands
Stack-Based Tree Construction (Optimal)	O(n)	O(n)	Use a stack to build the expression tree in a single pass through postfix tokens

Recursive Tree Building (Inefficient) — Algorithm Steps

Scan tokens from left to right looking for first operator
Find the corresponding operands for this operator
Recursively build subtrees for complex expressions
Combine subtrees with operators
Repeat until entire expression is processed

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Scan entire array looking for operators

Pattern Matching

Try to match operators with their operands

Recursive Splits

Recursively process subarrays

Multiple Scans

Each recursion requires more array scans

Code -

solution.c — C

// Brute force approach - multiple passes
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct Node {
    char* val;
    struct Node* left;
    struct Node* right;
} Node;

Node* createNode(char* val) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->val = strdup(val);
    node->left = NULL;
    node->right = NULL;
    return node;
}

int evaluate(Node* 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);
    
    switch (node->val[0]) {
        case '+': return leftVal + rightVal;
        case '-': return leftVal - rightVal;
        case '*': return leftVal * rightVal;
        case '/': return leftVal / rightVal;
    }
    
    return 0;
}

// Brute force tree building (inefficient)
Node* buildTree(char** postfix, int size) {
    // Multiple passes through array
    // Complex operator-operand matching
    // This approach is impractical for implementation
    return createNode(postfix[size - 1]);
}

int isOperator(char* s) {
    return (strlen(s) == 1 && (s[0] == '+' || s[0] == '-' || s[0] == '*' || s[0] == '/'));
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple scans through the token array for each operator

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the tree nodes and recursion stack

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~18 min Avg. Time

1.9K 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

Recursive Tree Building (Inefficient) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler