Abstract Syntax Tree Builder - Problem

Build a simple Abstract Syntax Tree (AST) parser for a mini expression language. Your parser should handle:

Variables: Single letter identifiers (a-z)
Numbers: Integer literals (0-9)
Arithmetic: Addition (+), subtraction (-), multiplication (*)
Function calls: Functions with single arguments like f(x)
Parentheses: For grouping expressions

The input is a string expression, and you should return the root of the AST as a nested structure. Each node should have a type and appropriate fields (value for literals, left/right for operators, name/arg for functions).

Expression Grammar:

expr := term (('+' | '-') term)*
term := factor (('*') factor)*
factor := number | variable | function | '(' expr ')'

Input & Output

Example 1 — Basic Arithmetic

$ Input: expression = "a + b"

› Output: {"type":"operator","value":"+","left":{"type":"variable","value":"a"},"right":{"type":"variable","value":"b"}}

💡 Note: Simple addition creates an operator node with '+' value, left child 'a' (variable), right child 'b' (variable)

Example 2 — Operator Precedence

$ Input: expression = "a + b * c"

› Output: {"type":"operator","value":"+","left":{"type":"variable","value":"a"},"right":{"type":"operator","value":"*","left":{"type":"variable","value":"b"},"right":{"type":"variable","value":"c"}}}

💡 Note: Multiplication has higher precedence than addition, so b*c forms a subtree that becomes the right child of the + operator

Example 3 — Function Call

$ Input: expression = "f(x)"

› Output: {"type":"function","name":"f","arg":{"type":"variable","value":"x"}}

💡 Note: Function call creates a function node with name 'f' and arg pointing to variable node 'x'

Constraints

1 ≤ expression.length ≤ 1000
Expression contains only: a-z, 0-9, +, -, *, (, )
Expression is guaranteed to be valid
Function names are single letters
Numbers are single digits 0-9

Visualization

Tap to expand

Asked in

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

The key insight is to use recursive descent parsing with proper grammar rules to handle operator precedence naturally. The optimal approach tokenizes the input first, then uses a recursive parser that mirrors the expression grammar. Time: O(n), Space: O(n).

Common Approaches

✓ Character-by-Character Parsing

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

Scan through the expression repeatedly to identify operators, then recursively parse left and right subexpressions by finding matching parentheses and operator precedence through string operations.

Tokenization + Recursive Descent

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

Convert the expression into tokens (numbers, operators, identifiers), then use a recursive descent parser that follows the expression grammar to build the AST efficiently in one pass.

Character-by-Character Parsing — Algorithm Steps

Scan entire expression to find the lowest precedence operator not in parentheses
Split the expression at this operator into left and right parts
Recursively parse left and right subexpressions using the same approach
Handle base cases like numbers, variables, and function calls with string matching

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Operator

Scan entire expression to find lowest precedence operator outside parentheses

Split Expression

Split at operator position into left and right subexpressions

Recursive Parse

Repeat same process on each subexpression until base cases

Code -

solution.c — C

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

typedef struct ASTNode {
    char type[20];
    char value[50];
    char name[50];
    struct ASTNode* left;
    struct ASTNode* right;
    struct ASTNode* arg;
} ASTNode;

ASTNode* createNode(const char* type) {
    ASTNode* node = malloc(sizeof(ASTNode));
    strcpy(node->type, type);
    node->value[0] = '\0';
    node->name[0] = '\0';
    node->left = NULL;
    node->right = NULL;
    node->arg = NULL;
    return node;
}

ASTNode* parse(char* expr);

ASTNode* solution(char* expression) {
    return parse(expression);
}

ASTNode* parse(char* expr) {
    int len = strlen(expr);
    if (len == 0) return NULL;
    
    // Find lowest precedence operator
    int parenCount = 0;
    int opPos = -1;
    for (int i = len - 1; i >= 0; i--) {
        if (expr[i] == ')') parenCount++;
        else if (expr[i] == '(') parenCount--;
        else if (parenCount == 0 && (expr[i] == '+' || expr[i] == '-')) {
            opPos = i;
            break;
        }
    }
    
    if (opPos == -1) {
        parenCount = 0;
        for (int i = len - 1; i >= 0; i--) {
            if (expr[i] == ')') parenCount++;
            else if (expr[i] == '(') parenCount--;
            else if (parenCount == 0 && expr[i] == '*') {
                opPos = i;
                break;
            }
        }
    }
    
    if (opPos != -1) {
        ASTNode* node = createNode("operator");
        node->value[0] = expr[opPos];
        node->value[1] = '\0';
        
        char left[100], right[100];
        strncpy(left, expr, opPos);
        left[opPos] = '\0';
        strcpy(right, expr + opPos + 1);
        
        node->left = parse(left);
        node->right = parse(right);
        return node;
    }
    
    // Handle parentheses
    if (expr[0] == '(' && expr[len-1] == ')') {
        char inner[100];
        strncpy(inner, expr + 1, len - 2);
        inner[len-2] = '\0';
        return parse(inner);
    }
    
    // Function call
    char* parenPos = strchr(expr, '(');
    if (parenPos && expr[len-1] == ')') {
        ASTNode* node = createNode("function");
        strncpy(node->name, expr, parenPos - expr);
        node->name[parenPos - expr] = '\0';
        
        char arg[100];
        strncpy(arg, parenPos + 1, len - (parenPos - expr) - 2);
        arg[len - (parenPos - expr) - 2] = '\0';
        node->arg = parse(arg);
        return node;
    }
    
    // Number or variable
    int isNumber = 1;
    for (int i = 0; i < len; i++) {
        if (!isdigit(expr[i])) {
            isNumber = 0;
            break;
        }
    }
    
    ASTNode* node = createNode(isNumber ? "number" : "variable");
    strcpy(node->value, expr);
    return node;
}

void printNode(ASTNode* node) {
    if (!node) {
        printf("null");
        return;
    }
    
    printf("{\"type\":\"%s\"", node->type);
    if (strlen(node->value) > 0) printf(",\"value\":\"%s\"", node->value);
    if (strlen(node->name) > 0) printf(",\"name\":\"%s\"", node->name);
    if (node->left) {
        printf(",\"left\":");
        printNode(node->left);
    }
    if (node->right) {
        printf(",\"right\":");
        printNode(node->right);
    }
    if (node->arg) {
        printf(",\"arg\":");
        printNode(node->arg);
    }
    printf("}");
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    
    ASTNode* result = solution(expression);
    printNode(result);
    printf("\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each node (O(n)), we scan the entire expression (O(n)) to find operators and match parentheses (O(n))

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursive calls create O(n) stack depth, each storing O(n) substring copies

⚠ Quadratic Space

34.5K Views

Medium Frequency

~35 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

Abstract Syntax Tree Builder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler