Smallest Subtree with all the Deepest Nodes

Smallest Subtree with all the Deepest Nodes - Problem

Given the root of a binary tree, your task is to find the smallest subtree that contains all the deepest nodes in the tree.

The depth of a node is defined as the shortest distance from the root to that node. The deepest nodes are those nodes that have the maximum depth among all nodes in the tree.

A subtree of a node consists of that node and all its descendants. You need to return the root of the smallest such subtree.

Example: If the deepest nodes are leaves at depth 3, and they have different parents, you need to find their lowest common ancestor that forms the smallest subtree containing all of them.

Input & Output

example_1.py — Python

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

› Output: [2]

💡 Note: The deepest nodes are 7 and 4 at depth 3. The smallest subtree containing both is rooted at node 2, so we return node 2.

example_2.py — Python

$ Input: root = [1]

› Output: [1]

💡 Note: The tree has only one node, so it's both the deepest and the answer.

example_3.py — Python

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

› Output: [2]

💡 Note: The deepest node is 2 at depth 2. The smallest subtree containing it is just node 2 itself.

Constraints

The number of nodes in the tree will be in the range [1, 500]
-500 ≤ Node.val ≤ 500
The values of the nodes in the tree are unique

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a single DFS traversal that simultaneously calculates subtree depths and identifies the answer node. The key insight is that the smallest subtree containing all deepest nodes is always the lowest common ancestor (LCA) of those nodes. By comparing left and right subtree depths at each node, we can determine if the current node is the LCA (equal depths) or if we need to recurse deeper.

Common Approaches

✓ Multiple DFS Traversals

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

This approach uses three separate tree traversals: first to find the maximum depth, second to collect all nodes at maximum depth, and third to find the lowest common ancestor of these deepest nodes.

One-Pass DFS (Optimal)

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

This optimal approach solves the problem in a single DFS traversal by calculating the maximum depth of each subtree and determining the answer node simultaneously. Each recursive call returns both the maximum depth in the subtree and the node that represents the smallest subtree containing all deepest nodes.

Two-Pass DFS with Depth Mapping

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

This approach uses two DFS traversals: the first pass calculates and stores the depth of every node in a hash map, and the second pass uses this depth information to efficiently determine the smallest subtree containing all deepest nodes.

Multiple DFS Traversals — Algorithm Steps

First DFS: Find the maximum depth in the tree
Second DFS: Collect all nodes that are at the maximum depth
Third DFS: Find the lowest common ancestor of all deepest nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Maximum Depth

First DFS traversal calculates the maximum depth of the tree

Collect Deepest Nodes

Second DFS traversal identifies all nodes at the maximum depth

Find LCA

Third DFS traversal finds the lowest common ancestor of all deepest nodes

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

static struct TreeNode* nodeQueue[1000];
static int queueFront, queueRear;

void initQueue() {
    queueFront = queueRear = 0;
}

void enqueue(struct TreeNode* node) {
    nodeQueue[queueRear++] = node;
}

struct TreeNode* dequeue() {
    return nodeQueue[queueFront++];
}

bool isQueueEmpty() {
    return queueFront == queueRear;
}

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

struct TreeNode* buildTreeFromArray(char arr[][10], int size) {
    if (size == 0 || strcmp(arr[0], "null") == 0) {
        return NULL;
    }
    
    struct TreeNode* root = createNode(atoi(arr[0]));
    initQueue();
    enqueue(root);
    int i = 1;
    
    while (!isQueueEmpty() && i < size) {
        struct TreeNode* node = dequeue();
        
        if (i < size && strcmp(arr[i], "null") != 0) {
            node->left = createNode(atoi(arr[i]));
            enqueue(node->left);
        }
        i++;
        
        if (i < size && strcmp(arr[i], "null") != 0) {
            node->right = createNode(atoi(arr[i]));
            enqueue(node->right);
        }
        i++;
    }
    
    return root;
}

int findMaxDepth(struct TreeNode* node) {
    if (!node) return 0;
    int leftDepth = findMaxDepth(node->left);
    int rightDepth = findMaxDepth(node->right);
    return 1 + (leftDepth > rightDepth ? leftDepth : rightDepth);
}

void collectDeepest(struct TreeNode* node, int depth, int maxDepth, 
                   struct TreeNode** result, int* count) {
    if (!node) return;
    if (depth == maxDepth) {
        result[(*count)++] = node;
    }
    collectDeepest(node->left, depth + 1, maxDepth, result, count);
    collectDeepest(node->right, depth + 1, maxDepth, result, count);
}

bool isTarget(struct TreeNode* node, struct TreeNode** targets, int count) {
    for (int i = 0; i < count; i++) {
        if (targets[i] == node) return true;
    }
    return false;
}

struct TreeNode* findLCA(struct TreeNode* node, struct TreeNode** targets, int count) {
    if (!node || isTarget(node, targets, count)) return node;
    
    struct TreeNode* left = findLCA(node->left, targets, count);
    struct TreeNode* right = findLCA(node->right, targets, count);
    
    if (left && right) return node;
    return left ? left : right;
}

struct TreeNode* subtreeWithAllDeepest(struct TreeNode* root) {
    if (!root) return NULL;
    
    int maxDepth = findMaxDepth(root);
    
    static struct TreeNode* deepestNodes[1000];
    int count = 0;
    collectDeepest(root, 1, maxDepth, deepestNodes, &count);
    
    return findLCA(root, deepestNodes, count);
}

void printTreeArray(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    static int result[1000];
    int resultSize = 0;
    
    initQueue();
    enqueue(root);
    
    while (!isQueueEmpty()) {
        struct TreeNode* node = dequeue();
        if (node) {
            result[resultSize++] = node->val;
        }
    }
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    static char arr[1000][10];
    int size = 0;
    
    if (strcmp(input, "[]") != 0) {
        // Remove brackets
        char* content = input + 1;
        content[strlen(content) - 1] = '\0';
        
        if (strlen(content) > 0) {
            char* token = strtok(content, ",");
            while (token != NULL) {
                // Remove whitespace
                while (*token == ' ') token++;
                char* end = token + strlen(token) - 1;
                while (end > token && *end == ' ') {
                    *end = '\0';
                    end--;
                }
                strcpy(arr[size++], token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    struct TreeNode* root = buildTreeFromArray(arr, size);
    struct TreeNode* resultRoot = subtreeWithAllDeepest(root);
    printTreeArray(resultRoot);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate DFS traversals, each O(n), but still linear overall

✓ Linear Growth

Space Complexity

O(h + d)

O(h) for recursion stack plus O(d) for storing deepest nodes, where d is number of deepest nodes

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Multiple DFS Traversals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler