Boundary of Binary Tree - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin at the root node - this is always part of the boundary

Left Boundary

Go down the leftmost path, adding nodes as we descend (pre-order)

Collect Leaves

Gather all leaf nodes from left to right using in-order traversal

Right Boundary

Go up the rightmost path, adding nodes as we backtrack (post-order)

Key Takeaway

🎯 Key Insight: Use a single DFS with boundary flags - left boundary in pre-order, leaves in in-order, right boundary in post-order for optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Only one recursion stack of height h, where h is the tree height

✓ Linear Space

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)

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

Approach	Time	Space	Notes
✓ Brute Force (Multiple Tree Traversals)	O(3n) = O(n)	O(3h) = O(h)	Perform separate complete tree traversals for each boundary component
Single DFS Traversal (Optimal)	O(n)	O(h)	Collect all boundary components in one intelligent DFS traversal

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Traverse entire tree to identify and collect left boundary nodes
Traverse entire tree again to collect all leaf nodes from left to right
Traverse entire tree a third time to collect right boundary nodes
Combine all three lists, handling duplicates manually
Return the final boundary list

Visualization

Tap to expand

Step-by-Step Walkthrough

First Traversal

Complete tree traversal to find left boundary nodes

Second Traversal

Another complete tree traversal to collect all leaves

Third Traversal

Final complete tree traversal to find right boundary nodes

Combine Results

Merge three separate lists while handling duplicates

Code -

solution.c — C

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

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

void findLeftBoundary(struct TreeNode* node, int isBoundary, int* result, int* size) {
    if (!node || (!node->left && !node->right)) return;
    if (isBoundary) result[(*size)++] = node->val;
    if (node->left) {
        findLeftBoundary(node->left, isBoundary, result, size);
        findLeftBoundary(node->right, 0, result, size);
    } else {
        findLeftBoundary(node->right, isBoundary, result, size);
    }
}

void findLeaves(struct TreeNode* node, int* result, int* size) {
    if (!node) return;
    if (!node->left && !node->right) {
        result[(*size)++] = node->val;
        return;
    }
    findLeaves(node->left, result, size);
    findLeaves(node->right, result, size);
}

void findRightBoundary(struct TreeNode* node, int isBoundary, int* result, int* size) {
    if (!node || (!node->left && !node->right)) return;
    if (node->right) {
        findRightBoundary(node->left, 0, result, size);
        findRightBoundary(node->right, isBoundary, result, size);
    } else {
        findRightBoundary(node->left, isBoundary, result, size);
    }
    if (isBoundary) result[(*size)++] = node->val;
}

int* boundaryOfBinaryTree(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int* result = (int*)malloc(1000 * sizeof(int));
    if (!root->left && !root->right) {
        result[0] = root->val;
        *returnSize = 1;
        return result;
    }
    
    result[(*returnSize)++] = root->val;
    findLeftBoundary(root->left, 1, result, returnSize);
    findLeaves(root, result, returnSize);
    findRightBoundary(root->right, 1, result, returnSize);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(3n) = O(n)

Three separate complete tree traversals, each taking O(n) time

✓ Linear Growth

Space Complexity

O(3h) = O(h)

Three separate recursion stacks, each using O(h) space where h is tree height

✓ Linear Space

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)

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Tree Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler