Boundary of Binary Tree

Boundary of Binary Tree - Problem

Boundary of Binary Tree is a fascinating tree traversal problem that challenges you to trace the perimeter of a binary tree like drawing its outline on paper.

Imagine you're looking at a binary tree from above and want to trace its boundary clockwise starting from the root. The boundary consists of four distinct parts:

🌳 Root node (starting point)
🔽 Left boundary (leftmost path, excluding leaves)
🍃 All leaf nodes (from left to right)
🔼 Right boundary (rightmost path in reverse, excluding leaves)

The left boundary follows these rules: start with root's left child, then keep going left if possible, otherwise go right. Stop before reaching a leaf. The right boundary follows similar rules but on the right side, and we traverse it in reverse order.

Goal: Given a binary tree root, return an array containing the boundary node values in clockwise order.

Input: Root of a binary tree
Output: Array of integers representing boundary values in clockwise order

Input & Output

example_1.py — Standard Binary Tree

$ Input: root = [1,2,3,4,5,6,null,null,null,7,8,null,9,10,null,null,11,null,12,null,13,null,null,14]

› Output: [1,2,4,7,11,12,13,10,9,3]

💡 Note: The boundary traces clockwise: start with root(1), go down left boundary(2,4,7,11), collect leaves(12,13,10,9), then up right boundary(3). Note that leaves are collected left-to-right, and right boundary is in reverse order.

example_2.py — Simple Tree

$ Input: root = [1,2,3,4,5,null,6,7,8,null,9,null,10,null,11]

› Output: [1,2,4,7,8,9,11,10,6,3]

💡 Note: Root(1) → Left boundary(2,4,7) → Leaves left-to-right(8,9,11,10,6) → Right boundary reversed(3). The left boundary stops at 7 since it's not a leaf, and leaves include all nodes without children.

example_3.py — Edge Case: Only Root

$ Input: root = [1]

› Output: [1]

💡 Note: When tree has only root node, the boundary is just the root itself. Root is considered the entire boundary, not a leaf in this context.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-1000 ≤ Node.val ≤ 1000
The root is guaranteed to not be a leaf (unless it's the only node)

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 23 Apple 15

The optimal solution uses a single DFS traversal with boundary flags to collect all boundary components in O(n) time. The key insight is to treat left boundary as pre-order, leaves as in-order, and right boundary as post-order traversal, allowing us to trace the complete boundary clockwise in one pass while using only O(h) space for recursion.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force (Multiple Tree Traversals)

⏱️ Time: O(3n) = O(n) Space: O(3h) = O(h)

This approach performs multiple complete tree traversals to collect each part of the boundary separately. We traverse the entire tree once to find the left boundary, once to find all leaves, and once to find the right boundary, then combine the results.

Single DFS Traversal (Optimal)

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

This optimal approach performs a single DFS traversal while intelligently identifying and collecting boundary nodes. We use flags to track whether we're on the left boundary, right boundary, or collecting leaves, avoiding multiple tree visits.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int *parent;
    int *size;
    int n;
} UnionFind;

UnionFind* createUF(int n) {
    UnionFind *uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->size = (int*)malloc(n * sizeof(int));
    uf->n = n;
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
        uf->size[i] = 1;
    }
    return uf;
}

int find(UnionFind *uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(UnionFind *uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    if (uf->size[px] < uf->size[py]) {
        int temp = px; px = py; py = temp;
    }
    uf->parent[py] = px;
    uf->size[px] += uf->size[py];
}

int getSize(UnionFind *uf, int x) {
    return uf->size[find(uf, x)];
}

int* solution(int** grid, int gridSize, int* gridColSize, int** hits, int hitsSize, int* hitsColSize, int* returnSize) {
    int m = gridSize, n = gridColSize[0];
    int* result = (int*)malloc(hitsSize * sizeof(int));
    *returnSize = hitsSize;
    
    // Create copy of grid
    int** hitGrid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        hitGrid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            hitGrid[i][j] = grid[i][j];
        }
    }
    
    // Apply all hits
    for (int i = 0; i < hitsSize; i++) {
        hitGrid[hits[i][0]][hits[i][1]] = 0;
    }
    
    UnionFind *uf = createUF(m * n + 1);
    int ceiling = m * n;
    int dirs[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    
    // Build initial structure
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            if (hitGrid[r][c] == 1) {
                int idx = r * n + c;
                if (r == 0) unionSets(uf, idx, ceiling);
                
                for (int d = 0; d < 4; d++) {
                    int nr = r + dirs[d][0], nc = c + dirs[d][1];
                    if (nr >= 0 && nr < m && nc >= 0 && nc < n && hitGrid[nr][nc] == 1) {
                        unionSets(uf, idx, nr * n + nc);
                    }
                }
            }
        }
    }
    
    // Work backwards
    for (int i = hitsSize - 1; i >= 0; i--) {
        int r = hits[i][0], c = hits[i][1];
        if (grid[r][c] == 0) {
            result[i] = 0;
            continue;
        }
        
        // Count bricks connected to ceiling before adding this brick back
        int ceilingRoot = find(uf, ceiling);
        int ceilingSizeBefore = (ceilingRoot == ceiling) ? getSize(uf, ceiling) - 1 : 0;
        
        hitGrid[r][c] = 1;
        int idx = r * n + c;
        
        if (r == 0) unionSets(uf, idx, ceiling);
        
        for (int d = 0; d < 4; d++) {
            int nr = r + dirs[d][0], nc = c + dirs[d][1];
            if (nr >= 0 && nr < m && nc >= 0 && nc < n && hitGrid[nr][nc] == 1) {
                unionSets(uf, idx, nr * n + nc);
            }
        }
        
        // Count bricks connected to ceiling after adding this brick back
        int ceilingRootAfter = find(uf, ceiling);
        int ceilingSizeAfter = (ceilingRootAfter == ceiling) ? getSize(uf, ceiling) - 1 : 0;
        
        int fallen = ceilingSizeAfter - ceilingSizeBefore - 1;
        result[i] = fallen > 0 ? fallen : 0;
    }
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(hitGrid[i]);
    }
    free(hitGrid);
    free(uf->parent);
    free(uf->size);
    free(uf);
    
    return result;
}

int main() {
    // Simplified input parsing for testing
    int grid[2][4] = {{1,0,0,0}, {1,1,1,0}};
    int* gridRows[2] = {grid[0], grid[1]};
    int gridColSize[2] = {4, 4};
    
    int hits[1][2] = {{1,0}};
    int* hitsRows[1] = {hits[0]};
    int hitsColSize[1] = {2};
    
    int returnSize;
    int* result = solution(gridRows, 2, gridColSize, hitsRows, 1, hitsColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

73.8K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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