Expression Tree Evaluator - Problem

Given an infix mathematical expression as a string, build an expression tree and evaluate it to return the final result.

The expression contains:

Single-digit integers (0-9)
Four operators: +, -, *, /
Parentheses ( and ) for grouping

Follow standard operator precedence: * and / have higher precedence than + and -. Operations of the same precedence are evaluated left to right.

Return the evaluated result as an integer (truncate any decimal part).

Input & Output

Example 1 — Basic Arithmetic

$ Input: expression = "3+2*4"

› Output: 11

💡 Note: Following precedence: 2*4 = 8, then 3+8 = 11. The multiplication is evaluated first due to higher precedence.

Example 2 — Parentheses Override

$ Input: expression = "(3+2)*4"

› Output: 20

💡 Note: Parentheses change precedence: (3+2) = 5, then 5*4 = 20. Addition is evaluated first due to parentheses.

Example 3 — Division with Truncation

$ Input: expression = "7/2+1"

› Output: 4

💡 Note: Division first: 7/2 = 3 (truncated), then 3+1 = 4. Integer division truncates the decimal part.

Constraints

1 ≤ expression.length ≤ 1000
expression consists of digits 0-9, operators +, -, *, /, and parentheses ( )
All intermediate calculations fit in a 32-bit integer
Division truncates toward zero

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 38 a Amazon 32 A Apple 28

The key insight is building an expression tree where operators become internal nodes and operands become leaves. Higher precedence operators appear deeper in the tree, naturally handling evaluation order. Best approach is recursive descent parsing which directly constructs the tree while parsing. Time: O(n), Space: O(h) where h is expression nesting depth.

Common Approaches

✓ Direct Stack-Based Evaluation

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

Use two stacks (operators and operands) to build and evaluate the expression tree simultaneously. Process operators based on precedence and parentheses directly without converting to postfix.

Recursive Descent Parser

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

Implement a recursive descent parser that directly builds the expression tree while respecting operator precedence. Each precedence level has its own parsing function, creating a clean tree structure.

Simple Left-to-Right Evaluation

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

Convert infix to postfix notation using Shunting Yard algorithm, then evaluate the postfix expression using a stack. This handles precedence correctly but requires two separate phases.

Direct Stack-Based Evaluation — Algorithm Steps

Use two stacks: one for numbers, one for operators
Process each character based on precedence rules
Build tree nodes when popping operators
Evaluate tree nodes immediately

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse with Two Stacks

Operators and operands stacks maintain precedence

Build Tree Nodes

Create tree structure as operators are processed

Evaluate Tree

Traverse tree to compute final result

Code -

solution.c — C

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

#define MAX_SIZE 1000

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

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

int precedence(char* op) {
    if (strcmp(op, "+") == 0 || strcmp(op, "-") == 0) return 1;
    if (strcmp(op, "*") == 0 || strcmp(op, "/") == 0) return 2;
    return 0;
}

TreeNode* applyOperator(char* op, TreeNode* right, TreeNode* left) {
    TreeNode* node = createNode(op);
    node->left = left;
    node->right = right;
    return node;
}

int evaluateTree(TreeNode* node) {
    if (!node) return 0;
    
    if (isdigit(node->val[0])) {
        return node->val[0] - '0';
    }
    
    int leftVal = evaluateTree(node->left);
    int rightVal = evaluateTree(node->right);
    
    switch (node->val[0]) {
        case '+': return leftVal + rightVal;
        case '-': return leftVal - rightVal;
        case '*': return leftVal * rightVal;
        case '/': return leftVal / rightVal;
    }
    
    return 0;
}

TreeNode* buildExpressionTree(char* expr) {
    char operators[MAX_SIZE][2];
    TreeNode* operands[MAX_SIZE];
    int opTop = -1, operandTop = -1;
    
    for (int i = 0; expr[i]; i++) {
        char c = expr[i];
        
        if (isdigit(c)) {
            char digit[2] = {c, '\0'};
            operands[++operandTop] = createNode(digit);
        } else if (c == '(') {
            operators[++opTop][0] = c;
            operators[opTop][1] = '\0';
        } else if (c == ')') {
            while (opTop >= 0 && strcmp(operators[opTop], "(") != 0) {
                TreeNode* right = operands[operandTop--];
                TreeNode* left = operands[operandTop--];
                operands[++operandTop] = applyOperator(operators[opTop--], right, left);
            }
            opTop--; // Remove '('
        } else if (strchr("+-*/", c)) {
            char currentOp[2] = {c, '\0'};
            while (opTop >= 0 && strcmp(operators[opTop], "(") != 0 &&
                   strchr("+-*/", operators[opTop][0]) &&
                   precedence(operators[opTop]) >= precedence(currentOp)) {
                TreeNode* right = operands[operandTop--];
                TreeNode* left = operands[operandTop--];
                operands[++operandTop] = applyOperator(operators[opTop--], right, left);
            }
            strcpy(operators[++opTop], currentOp);
        }
    }
    
    while (opTop >= 0) {
        TreeNode* right = operands[operandTop--];
        TreeNode* left = operands[operandTop--];
        operands[++operandTop] = applyOperator(operators[opTop--], right, left);
    }
    
    return operands[0];
}

int solution(char* expression) {
    TreeNode* root = buildExpressionTree(expression);
    return evaluateTree(root);
}

int main() {
    char expression[MAX_SIZE];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    
    int result = solution(expression);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through expression with constant time stack operations

✓ Linear Growth

Space Complexity

O(n)

Two stacks for operators and operands, tree nodes for expression

⚡ Linearithmic Space

78.0K Views

Medium Frequency

~25 min Avg. Time

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

Expression Tree Evaluator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Stack-Based Evaluation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler