Build Binary Expression Tree From Infix Expression

Build Binary Expression Tree From Infix Expression - Problem

Build Binary Expression Tree From Infix Expression

Imagine you're a compiler engineer tasked with converting mathematical expressions into a tree structure for efficient evaluation! 🌳

A binary expression tree is a special kind of binary tree where:

Leaf nodes contain operands (numbers)
Internal nodes contain operators (+, -, *, /)
Each internal node has exactly two children

Given an infix expression string s containing operands, operators, and parentheses, your goal is to construct a valid binary expression tree that represents this expression.

Key Rules:

🎯 Order of operations matters: parentheses first, then *//, then +/-
📖 In-order traversal of your tree should reproduce the original expression (without parentheses)
🔢 Operands must appear in the same order in both input and tree traversal

For example: "2*3/(2-1)+1" should produce a tree that evaluates correctly following mathematical precedence rules!

Input & Output

example_1.py — Basic Addition

$ Input: s = "2+3"

› Output: TreeNode('+', TreeNode('2'), TreeNode('3'))

💡 Note: Simple addition creates a tree with '+' as root and '2', '3' as children. In-order traversal gives '2+3'.

example_2.py — Precedence Example

$ Input: s = "2*3+1"

› Output: TreeNode('+', TreeNode('*', TreeNode('2'), TreeNode('3')), TreeNode('1'))

💡 Note: Multiplication has higher precedence than addition, so '2*3' forms the left subtree, then '+' combines it with '1'.

example_3.py — Parentheses Override

$ Input: s = "2*(3+1)"

› Output: TreeNode('*', TreeNode('2'), TreeNode('+', TreeNode('3'), TreeNode('1')))

💡 Note: Parentheses force '3+1' to be evaluated first, making it the right subtree of the multiplication.

Constraints

1 ≤ s.length ≤ 1000
s consists of digits, '+', '-', '*', '/', '(', and ')'
Operands are positive integers
The expression is guaranteed to be valid
No leading zeros in operands

Visualization

Tap to expand

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a stack-based approach inspired by the shunting-yard algorithm. We maintain two stacks - one for operands (tree nodes) and one for operators. As we scan the expression, we handle operator precedence by comparing the current operator with the stack top, building subtrees when necessary. This approach processes the expression in O(n) time with a single pass, efficiently handling parentheses and operator precedence to construct the binary expression tree.

Common Approaches

✓ Stack-Based Expression Parser

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

This approach uses two stacks - one for operands and one for operators - along with precedence rules to build the expression tree. When we encounter operators, we compare precedence and build subtrees accordingly.

Stack-Based Expression Parser — Algorithm Steps

Initialize two stacks: operand stack and operator stack
Scan expression from left to right
If operand: push to operand stack
If '(': push to operator stack
If ')': pop and build trees until '('
If operator: compare precedence and pop higher/equal precedence operators
Build remaining trees from stacks

Visualization

Tap to expand

Step-by-Step Walkthrough

Process '2'

Push operand '2' to operand stack

Process '*'

Push operator '*' to operator stack

Process '3'

Push operand '3' to operand stack

Process '+'

'+' has lower precedence than '*', so build '*' tree first

Code -

solution.c — C

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

struct TreeNode {
    char* val;
    struct TreeNode* left;
    struct TreeNode* right;
};

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

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

void printTree(struct TreeNode* node) {
    if (node->left == NULL && node->right == NULL) {
        printf("TreeNode('%s')", node->val);
        return;
    }
    printf("TreeNode('%s', ", node->val);
    if (node->left) {
        printTree(node->left);
    } else {
        printf("null");
    }
    printf(", ");
    if (node->right) {
        printTree(node->right);
    } else {
        printf("null");
    }
    printf(")");
}

struct TreeNode* expTree(char* s) {
    static struct TreeNode* operands[1000];
    static char operators[1000];
    int operandTop = -1;
    int operatorTop = -1;
    
    int i = 0;
    int len = strlen(s);
    
    while (i < len) {
        char c = s[i];
        
        if (isdigit(c)) {
            char num[100] = {0};
            int numIdx = 0;
            while (i < len && isdigit(s[i])) {
                num[numIdx++] = s[i];
                i++;
            }
            operands[++operandTop] = createNode(num);
            i--;
        } else if (c == '(') {
            operators[++operatorTop] = c;
        } else if (c == ')') {
            while (operatorTop >= 0 && operators[operatorTop] != '(') {
                char op = operators[operatorTop--];
                struct TreeNode* right = operands[operandTop--];
                struct TreeNode* left = operands[operandTop--];
                
                char opStr[2] = {op, '\0'};
                struct TreeNode* root = createNode(opStr);
                root->left = left;
                root->right = right;
                operands[++operandTop] = root;
            }
            operatorTop--; // Remove '('
        } else if (c == '+' || c == '-' || c == '*' || c == '/') {
            while (operatorTop >= 0 && operators[operatorTop] != '(' &&
                   precedence(operators[operatorTop]) >= precedence(c)) {
                char op = operators[operatorTop--];
                struct TreeNode* right = operands[operandTop--];
                struct TreeNode* left = operands[operandTop--];
                
                char opStr[2] = {op, '\0'};
                struct TreeNode* root = createNode(opStr);
                root->left = left;
                root->right = right;
                operands[++operandTop] = root;
            }
            operators[++operatorTop] = c;
        }
        i++;
    }
    
    while (operatorTop >= 0) {
        char op = operators[operatorTop--];
        struct TreeNode* right = operands[operandTop--];
        struct TreeNode* left = operands[operandTop--];
        
        char opStr[2] = {op, '\0'};
        struct TreeNode* root = createNode(opStr);
        root->left = left;
        root->right = right;
        operands[++operandTop] = root;
    }
    
    return operandTop >= 0 ? operands[operandTop] : NULL;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = '\0'; // Remove newline
    
    struct TreeNode* result = expTree(s);
    printTree(result);
    printf("\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the expression with constant time operations for each character

✓ Linear Growth

Space Complexity

O(n)

Space for operand and operator stacks, plus tree nodes

⚡ Linearithmic Space

24.4K Views

Medium-High 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

Stack-Based Expression Parser — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler