Print Binary Tree - Practice Coding Problems

Print Binary Tree - Problem

📊 Binary Tree Matrix Visualization

Given the root of a binary tree, create a visually appealing string matrix that represents the tree structure. Think of it as creating a "pretty print" layout where each node is positioned perfectly to show the tree's hierarchical structure.

🎯 Your Mission:

Create an m × n matrix where m = height + 1 and n = 2^(height+1) - 1
Place the root node in the center of the top row
For each node at position res[r][c]:
- Left child goes to res[r+1][c - 2^(height-r-1)]
- Right child goes to res[r+1][c + 2^(height-r-1)]
Fill empty cells with empty strings ""

The result is a beautiful matrix representation that maintains the binary tree's visual structure, perfect for debugging or educational purposes!

Input & Output

example_1.py — Simple Binary Tree

$ Input: root = [1,2] Tree structure: 1 / 2

› Output: [["" "1" ""], ["2" "" ""]]

💡 Note: Height = 1, so matrix is 2×3. Root '1' goes to center [0][1], left child '2' goes to [1][0] using the positioning formula.

example_2.py — Complete Binary Tree

$ Input: root = [1,2,3,null,4] Tree structure: 1 / \ 2 3 \ 4

› Output: [["" "" "" "1" "" "" ""], ["" "2" "" "" "" "3" ""], ["" "" "4" "" "" "" ""]]

💡 Note: Height = 2, matrix is 3×7. Each level uses different offset: root at [0][3], level 1 with offset 2, level 2 with offset 1.

example_3.py — Single Node

$ Input: root = [1] Tree structure: 1

› Output: [["1"]]

💡 Note: Edge case: single node tree has height 0, resulting in a 1×1 matrix with just the root value.

Constraints

The number of nodes in the tree is in the range [1, 2¹⁰]
-99 ≤ Node.val ≤ 99
The depth of the tree will be in range [0, 9]

Visualization

Tap to expand

Understanding the Visualization

Measure Family

Calculate tree height to determine matrix size needed

Find Center

Place root (grandparent) at the center of the top row

Position Children

Each parent's children are positioned symmetrically with calculated spacing

Maintain Balance

Mathematical formula ensures no overlaps and perfect visual balance

Key Takeaway

🎯 Key Insight: The mathematical positioning formula ensures perfect tree visualization by using exponentially decreasing spacing at each level, maintaining the binary tree's hierarchical structure in matrix form.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal approach uses recursive DFS to traverse the tree and fill matrix positions using the mathematical formula. Key insight: positioning follows a pattern where each level's offset is 2^(height-level-1), ensuring perfect spacing and no overlaps.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS with Matrix Filling	O(n + m×n)	O(m×n + h)	Calculate tree height first, then use DFS to fill matrix positions recursively

Recursive DFS with Matrix Filling — Algorithm Steps

Calculate the height of the binary tree using DFS
Initialize the result matrix with dimensions (height+1) × (2^(height+1)-1)
Start DFS from root at position [0][(n-1)/2]
For each node, calculate left and right child positions using the formula
Recursively fill positions for all nodes in the tree

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Height

First pass: traverse tree to find height = 2

Initialize Matrix

Create 3×7 matrix filled with empty strings

Place Root

Root goes to center: position [0][3]

Calculate Children

Left child: [1][3-2^1] = [1][1], Right: [1][3+2^1] = [1][5]

Continue Recursively

Repeat for all nodes using the positioning formula

Code -

solution.c — C

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

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

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

void fillMatrix(struct TreeNode* node, char*** result, int row, int col, int height) {
    if (!node) return;
    
    result[row][col] = (char*)malloc(12 * sizeof(char));
    sprintf(result[row][col], "%d", node->val);
    
    int offset = (int)pow(2, height - row - 1);
    if (node->left) {
        fillMatrix(node->left, result, row + 1, col - offset, height);
    }
    if (node->right) {
        fillMatrix(node->right, result, row + 1, col + offset, height);
    }
}

char*** printTree(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    int height = getHeight(root);
    int width = (int)pow(2, height + 1) - 1;
    *returnSize = height + 1;
    *returnColumnSizes = (int*)malloc((*returnSize) * sizeof(int));
    
    char*** result = (char***)malloc((*returnSize) * sizeof(char**));
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = width;
        result[i] = (char**)malloc(width * sizeof(char*));
        for (int j = 0; j < width; j++) {
            result[i][j] = (char*)malloc(1 * sizeof(char));
            strcpy(result[i][j], "");
        }
    }
    
    fillMatrix(root, result, 0, (width - 1) / 2, height);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m×n)

O(n) to calculate height and traverse tree, plus O(m×n) to initialize matrix

✓ Linear Growth

Space Complexity

O(m×n + h)

O(m×n) for result matrix plus O(h) for recursion stack depth

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

847 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

📊 Binary Tree Matrix Visualization

🎯 Your Mission:

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive DFS with Matrix Filling — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler