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.

Visualization

Tap to expand

Understanding the Visualization

Initialize Stacks

Set up operand stack (for numbers/subtrees) and operator stack (for +,-,*,/,parentheses)

Process Operands

When we encounter numbers, create tree nodes and push to operand stack

Handle Operators

Compare precedence with stack top - build trees for higher/equal precedence operators first

Manage Parentheses

Push '(' to stack, when ')' is found, build trees until we reach the matching '('

Final Assembly

Process remaining operators in stack to complete the expression tree

Key Takeaway

🎯 Key Insight: Using two stacks with operator precedence rules allows us to build the expression tree in a single pass, naturally handling the mathematical order of operations while constructing the correct tree structure.

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

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

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

Approach	Time	Space	Notes
✓ Stack-Based Expression Parser	O(n)	O(n)	Use two stacks to handle operators and operands with precedence rules

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;
}

struct TreeNode* expTree(char* s) {
    struct TreeNode** operands = (struct TreeNode**)malloc(1000 * sizeof(struct TreeNode*));
    char* operators = (char*)malloc(1000 * sizeof(char));
    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;
    }
    
    struct TreeNode* result = operandTop >= 0 ? operands[operandTop] : NULL;
    free(operands);
    free(operators);
    return result;
}

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

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Stack-Based Expression Parser — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler