Tree Pretty Printer - Problem

Implement a function to display a binary tree in a visually readable format on the console with proper spacing and branch lines.

The output should show the tree structure with:

Node values displayed clearly
Branch connections using ASCII characters (|, -, +)
Proper indentation to show the tree levels
Left and right child positioning

For a null node, do not display anything at that position. The tree should be readable and maintain proper hierarchical structure.

Input & Output

Example 1 — Basic Binary Tree

$ Input: root = [3,9,20,null,null,15,7]

› Output: 3 / \ 9 20 / \ 15 7

💡 Note: Tree with root 3, left child 9, right child 20. Node 20 has children 15 and 7. Display shows proper indentation and branch connections.

Example 2 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Single node tree displays just the value with no connections needed.

Example 3 — Left-Heavy Tree

$ Input: root = [1,2,null,3,null]

› Output: 1 / 2 | 3

💡 Note: Tree grows only to the left, showing vertical connections down the left side.

Constraints

The number of nodes in the tree is in the range [0, 2000]
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12 G Google 8

The key insight is to use systematic tree traversal (BFS or DFS) combined with calculated spacing to create a visually readable tree display. The level-order formatting approach processes each tree level systematically with consistent indentation. Time: O(n), Space: O(w) where w is maximum tree width.

Common Approaches

✓ Level-Order Formatting

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

Traverse the tree level by level using BFS queue, formatting each level with proper indentation and spacing between nodes.

Recursive String Building

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

Recursively traverse the tree and build a 2D character grid to represent the tree structure. Calculate positions for each node and draw connecting lines manually.

Level-Order Formatting — Algorithm Steps

Step 1: Use BFS queue to process nodes level by level
Step 2: Calculate indentation based on tree height and level
Step 3: Format each level with consistent spacing
Step 4: Build output string line by line

Visualization

Tap to expand

Step-by-Step Walkthrough

BFS Traversal

Use queue to visit nodes level by level

Calculate Spacing

Determine indentation and spacing based on tree height

Format Levels

Build each level string with proper spacing

Combine Output

Join all formatted levels into final result

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int getHeight(struct TreeNode* node) {
    if (!node) return 0;
    int leftHeight = getHeight(node->left);
    int rightHeight = getHeight(node->right);
    return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}

char* solution(struct TreeNode* root) {
    if (!root) {
        char* result = (char*)malloc(1);
        result[0] = '\0';
        return result;
    }
    
    int height = getHeight(root);
    char* result = (char*)malloc(10000);
    strcpy(result, "");
    
    struct TreeNode* queue[1000];
    int levels[1000];
    int front = 0, rear = 0;
    
    queue[rear] = root;
    levels[rear] = 0;
    rear++;
    
    int currentLevel = 0;
    char levelStr[1000] = "";
    int nodeCount = 0;
    
    while (front < rear) {
        struct TreeNode* node = queue[front];
        int level = levels[front];
        front++;
        
        if (level != currentLevel) {
            if (strlen(levelStr) > 0) {
                // Add indentation
                for (int i = 0; i < (height - currentLevel) * 2; i++) {
                    char temp[10000];
                    strcpy(temp, result);
                    strcpy(result, " ");
                    strcat(result, temp);
                }
                strcat(result, levelStr);
                strcat(result, "\n");
            }
            
            strcpy(levelStr, "");
            currentLevel = level;
            nodeCount = 0;
        }
        
        if (nodeCount > 0) {
            strcat(levelStr, "    ");
        }
        
        char nodeStr[20];
        sprintf(nodeStr, "%d", node->val);
        strcat(levelStr, nodeStr);
        nodeCount++;
        
        if (node->left || node->right) {
            if (node->left) {
                queue[rear] = node->left;
                levels[rear] = level + 1;
                rear++;
            }
            if (node->right) {
                queue[rear] = node->right;
                levels[rear] = level + 1;
                rear++;
            }
        }
    }
    
    if (strlen(levelStr) > 0) {
        for (int i = 0; i < (height - currentLevel) * 2; i++) {
            char temp[10000];
            strcpy(temp, result);
            strcpy(result, " ");
            strcat(result, temp);
        }
        strcat(result, levelStr);
    }
    
    return result;
}

struct TreeNode* buildTreeFromArray(int* arr, int size) {
    if (size == 0 || arr[0] == -1) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -1) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    int arr[100];
    int size = 0;
    
    char* token = strtok(input + 1, ",]");
    while (token != NULL) {
        while (*token == ' ') token++;
        
        if (strstr(token, "null")) {
            arr[size++] = -1;
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, ",]");
    }
    
    struct TreeNode* root = buildTreeFromArray(arr, size);
    char* result = solution(root);
    printf("%s", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes (maximum width of tree level)

✓ Linear Space

23.0K Views

Medium Frequency

~30 min Avg. Time

890 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

Tree Pretty Printer - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Level-Order Formatting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler