Tree Boundary Traversal - Problem

Given a binary tree, print the boundary nodes in anti-clockwise order. The boundary traversal consists of three parts:

1. Left boundary: All nodes on the path from root to the leftmost leaf (excluding the leaf)

2. Leaves: All leaf nodes from left to right

3. Right boundary: All nodes on the path from the rightmost leaf to root (excluding the leaf and root), printed in reverse order

Note: If the root is a leaf node, only print the root. The root should not be printed twice.

Input & Output

Example 1 — Complete Binary Tree

$ Input: root = [1,2,3,4,5,6]

› Output: [1,2,4,5,6,3]

💡 Note: Anti-clockwise boundary: root(1) → left boundary(2) → leaves(4,5,6) → right boundary(3) in reverse

Example 2 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Single node tree: root is the only boundary node

Example 3 — Left Skewed Tree

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

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

💡 Note: Left boundary: 1→2→3, leaf: 4, no right boundary (all nodes are on left boundary)

Constraints

1 ≤ Number of nodes ≤ 10⁴
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 20 G Google 15 f Facebook 12

The key insight is to traverse the boundary in anti-clockwise order: left boundary → leaves → right boundary reversed. The optimal approach uses a single DFS that identifies boundary nodes on-the-fly. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Complete Tree Traversal

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

Perform a complete traversal of the tree to collect all nodes, then identify which nodes belong to left boundary, leaves, and right boundary through separate checks.

Single DFS Traversal

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

Use a single depth-first traversal that determines node boundary status on-the-fly and collects nodes in the correct anti-clockwise order during the traversal itself.

Three Separate DFS Traversals

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

Make three separate depth-first traversals: one for left boundary nodes, one for all leaf nodes, and one for right boundary nodes, then combine results.

Complete Tree Traversal — Algorithm Steps

Step 1: Traverse entire tree and collect all nodes
Step 2: Identify left boundary nodes by checking paths
Step 3: Identify all leaf nodes
Step 4: Identify right boundary nodes by checking paths
Step 5: Combine results avoiding duplicates

Visualization

Tap to expand

Step-by-Step Walkthrough

Full Traversal

Visit every node in the tree and collect all information

Categorize Nodes

Identify which nodes are left boundary, leaves, or right boundary

Combine Results

Merge categories in anti-clockwise order: root + left + leaves + right reversed

Code -

solution.c — C

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

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

struct NodeInfo {
    int val;
    bool isLeftBoundary;
    bool isRightBoundary;
    bool isLeaf;
};

struct NodeInfo allNodes[10000];
int nodeCount = 0;
int result[10000];
int resultSize = 0;

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;
}

void collectNodes(struct TreeNode* node, bool isLeftBoundary, bool isRightBoundary, int rootVal) {
    if (!node) return;
    
    bool isLeaf = !node->left && !node->right;
    allNodes[nodeCount++] = (struct NodeInfo){node->val, isLeftBoundary, isRightBoundary, isLeaf};
    
    bool leftIsLeftBoundary = isLeftBoundary && node->left;
    bool leftIsRightBoundary = isRightBoundary && !node->right && node->left;
    
    bool rightIsLeftBoundary = isLeftBoundary && !node->left && node->right;
    bool rightIsRightBoundary = isRightBoundary && node->right;
    
    collectNodes(node->left, leftIsLeftBoundary, leftIsRightBoundary, rootVal);
    collectNodes(node->right, rightIsLeftBoundary, rightIsRightBoundary, rootVal);
}

int* solution(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return result;
    
    if (!root->left && !root->right) {
        result[0] = root->val;
        *returnSize = 1;
        return result;
    }
    
    nodeCount = 0;
    resultSize = 0;
    collectNodes(root, true, true, root->val);
    
    int leftBoundary[1000], leftSize = 0;
    int leaves[1000], leafSize = 0;
    int rightBoundary[1000], rightSize = 0;
    
    for (int i = 0; i < nodeCount; i++) {
        struct NodeInfo nodeInfo = allNodes[i];
        if (nodeInfo.isLeaf) {
            leaves[leafSize++] = nodeInfo.val;
        } else if (nodeInfo.isLeftBoundary && nodeInfo.val != root->val) {
            leftBoundary[leftSize++] = nodeInfo.val;
        } else if (nodeInfo.isRightBoundary && nodeInfo.val != root->val) {
            rightBoundary[rightSize++] = nodeInfo.val;
        }
    }
    
    result[resultSize++] = root->val;
    for (int i = 0; i < leftSize; i++) {
        result[resultSize++] = leftBoundary[i];
    }
    for (int i = 0; i < leafSize; i++) {
        result[resultSize++] = leaves[i];
    }
    for (int i = rightSize - 1; i >= 0; i--) {
        result[resultSize++] = rightBoundary[i];
    }
    
    *returnSize = resultSize;
    return result;
}

struct TreeNode* buildTreeFromArray(char* input) {
    // Simple implementation for demonstration
    // In a real implementation, you'd parse the JSON array properly
    return createNode(1);  // Placeholder
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    struct TreeNode* root = buildTreeFromArray(input);
    int returnSize;
    int* boundary = solution(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", boundary[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of all n nodes, but with multiple passes to identify boundary types

✓ Linear Growth

Space Complexity

O(n)

Stores all nodes in arrays plus recursion stack depth

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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 Boundary Traversal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Complete Tree Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler