Find All The Lonely Nodes - Practice Coding Problems

Find All The Lonely Nodes - Problem

Imagine exploring a family tree where some children are only children while others have siblings. In this binary tree problem, we need to identify all the lonely nodes - those that are the only child of their parent.

A lonely node is defined as a node that has no siblings (i.e., it's either the only left child or the only right child of its parent). The root node is never considered lonely since it has no parent.

Goal: Given the root of a binary tree, return an array containing the values of all lonely nodes. The order of the result doesn't matter.

Example: In a tree where node 5 has only a left child (node 3), then node 3 is lonely. Similarly, if node 7 has only a right child (node 9), then node 9 is lonely.

Input & Output

example_1.py — Basic Tree

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

› Output: [4]

💡 Note: Node 2 has only one child (node 4), so node 4 is lonely. Node 3 has no children and node 1 has two children, so no other nodes are lonely.

example_2.py — Multiple Lonely Nodes

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

› Output: [6,2]

💡 Note: Node 1 has only left child 6 (so 6 is lonely), and node 3 has only right child 2 (so 2 is lonely).

example_3.py — No Lonely Nodes

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

› Output: []

💡 Note: Root has two children, and the leaf nodes have no children. No node is the only child of its parent.

Constraints

The number of nodes in the tree is in the range [1, 1000]
1 ≤ Node.val ≤ 1000
Each node value is unique

Visualization

Tap to expand

Understanding the Visualization

Start at the Top

Begin your walk from the family patriarch/matriarch at the root of the tree

Check Each Family Unit

At each parent, count their children: 0, 1, or 2 children

Spot Only Children

If a parent has exactly 1 child, that child is lonely (an only child)

Record and Continue

Add the lonely child to your list and continue visiting other family groups

Complete the Walk

After visiting all families once, you have found all only children

Key Takeaway

🎯 Key Insight: Instead of checking each node to find its parent (O(n²)), we reverse the approach and check each parent to identify their only children (O(n)). This single-pass solution is both intuitive and optimal!

Asked in

f Facebook 25 a Amazon 18 G Google 12 ⊞ Microsoft 8

The optimal solution uses a single DFS traversal to identify lonely nodes in O(n) time. During traversal, we check each parent node to see if it has exactly one child (either only left or only right), and add that child to our result. This approach is much more efficient than checking each node's parent separately, avoiding the O(n²) complexity of naive approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS (Single Pass)	O(n)	O(h)	Single tree traversal checking parent-child relationships during DFS

Optimized DFS (Single Pass) — Algorithm Steps

Start DFS traversal from root
For each node, check if it has exactly one child
If yes, add that child's value to result
Continue recursively for left and right subtrees
Return collected lonely nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin traversal from root node

Check Children

At each node, check if it has exactly one child

Add Lonely Node

If one child exists, add it to result

Recurse

Continue DFS on left and right subtrees

Code -

solution.c — C

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

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

void dfs(struct TreeNode* node, int* result, int* returnSize) {
    if (!node) return;
    
    // Check if current node has exactly one child
    if (node->left && !node->right) {
        result[(*returnSize)++] = node->left->val;
    } else if (node->right && !node->left) {
        result[(*returnSize)++] = node->right->val;
    }
    
    // Continue DFS for both subtrees
    dfs(node->left, result, returnSize);
    dfs(node->right, result, returnSize);
}

int* getLonelyNodes(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int* result = (int*)malloc(1000 * sizeof(int)); // Assume max 1000 nodes
    dfs(root, result, returnSize);
    return result;
}

int main() {
    // Parse input and create tree
    int returnSize;
    // int* result = getLonelyNodes(root, &returnSize);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack space where h is the height of the tree

✓ Linear Space

23.8K Views

Medium Frequency

~15 min Avg. Time

892 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

Optimized DFS (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler