Cousins in Binary Tree - Practice Coding Problems

Cousins in Binary Tree - Problem

Imagine you're at a family reunion and need to identify cousins in a family tree! Given a binary tree where each node represents a family member with a unique value, and two specific values x and y, determine if these two people are cousins.

Two nodes in a binary tree are considered cousins if they satisfy both conditions:

They are at the same depth (same generation level)
They have different parents (not siblings)

The root node is at depth 0, and each level down increases the depth by 1. Return true if the nodes with values x and y are cousins, false otherwise.

Example: In a family tree, if two people are at the same generation level but have different parents, they're cousins!

Input & Output

example_1.py — Basic cousin relationship

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

› Output: false

💡 Note: Nodes 4 and 3 are at different depths (4 is at depth 2, 3 is at depth 1), so they cannot be cousins.

example_2.py — Same level, different parents

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

› Output: true

💡 Note: Nodes 5 and 4 are both at depth 2 (same level) and have different parents (3 and 2 respectively), making them cousins.

example_3.py — Same level, same parent (siblings)

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

› Output: false

💡 Note: Nodes 2 and 3 are at the same depth but have the same parent (1), making them siblings, not cousins.

Constraints

The number of nodes in the tree is in the range [2, 100]
1 ≤ Node.val ≤ 100
Each node has a unique value
x ≠ y
x and y are guaranteed to exist in the tree

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin traversal from the family patriarch/matriarch

Process Each Generation

Examine all family members at each generation level

Track Parents

Keep record of who belongs to which family branch

Identify Cousins

When both targets found at same level with different parents, they're cousins!

Key Takeaway

🎯 Key Insight: Use BFS to process family members generation by generation, stopping as soon as both targets are found to determine their cousin relationship efficiently.

Asked in

f Facebook 15 a Amazon 12 ⊞ Microsoft 8 G Google 6

The optimal solution uses a single BFS traversal processing nodes level by level. When both target nodes are found at the same level with different parents, they are cousins. This approach has O(n) time complexity with early termination and uses O(w) space where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass BFS (Optimal)	O(n)	O(w)	Use BFS to traverse level by level, finding both nodes in one pass
Brute Force (Separate DFS)	O(n)	O(h)	Find each node's depth and parent separately using two DFS traversals

Single Pass BFS (Optimal) — Algorithm Steps

Use a queue to perform BFS traversal level by level
For each level, track nodes and their parents
When processing a level, check if both x and y are found
If both found at same level with different parents, they're cousins
Stop search as soon as both nodes are found or level is complete

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root node and null parent

Process Level 1

Check each node at current level for targets x and y

Process Level 2

Continue to next level, tracking parents of each node

Found Both Targets

Both x and y found at same level - check if different parents

Code -

solution.c — C

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

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

typedef struct {
    struct TreeNode* node;
    struct TreeNode* parent;
} NodeParent;

typedef struct {
    NodeParent* data;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = malloc(sizeof(Queue));
    q->data = malloc(sizeof(NodeParent) * capacity);
    q->front = 0;
    q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, struct TreeNode* node, struct TreeNode* parent) {
    q->data[q->rear].node = node;
    q->data[q->rear].parent = parent;
    q->rear++;
}

NodeParent dequeue(Queue* q) {
    return q->data[q->front++];
}

int queueSize(Queue* q) {
    return q->rear - q->front;
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

bool isCousins(struct TreeNode* root, int x, int y) {
    if (!root) return false;
    
    Queue* queue = createQueue(1000);
    enqueue(queue, root, NULL);
    
    while (!isEmpty(queue)) {
        int levelSize = queueSize(queue);
        struct TreeNode* xParent = NULL;
        struct TreeNode* yParent = NULL;
        
        for (int i = 0; i < levelSize; i++) {
            NodeParent pair = dequeue(queue);
            
            if (pair.node->val == x) {
                xParent = pair.parent;
            } else if (pair.node->val == y) {
                yParent = pair.parent;
            }
            
            if (pair.node->left) {
                enqueue(queue, pair.node->left, pair.node);
            }
            if (pair.node->right) {
                enqueue(queue, pair.node->right, pair.node);
            }
        }
        
        if (xParent && yParent) {
            return xParent != yParent;
        }
        
        if (xParent || yParent) {
            return false;
        }
    }
    
    return false;
}

int main() {
    printf("true\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single BFS traversal, visiting each node at most once

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree

✓ Linear Space

67.9K Views

Medium Frequency

~15 min Avg. Time

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

Single Pass BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler