Cousins in Binary Tree

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

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

✓ Brute Force (Separate DFS)

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

Perform two separate depth-first searches to find the depth and parent of each target node, then compare the results to determine if they're cousins.

Single Pass BFS (Optimal)

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

Perform a single breadth-first search traversal, processing nodes level by level. Stop as soon as both target nodes are found and immediately determine if they're cousins.

Brute Force (Separate DFS) — Algorithm Steps

Create a helper function to find depth and parent of a given value
Call this function twice - once for x and once for y
Compare the results: same depth but different parents means they're cousins
Handle edge cases where nodes don't exist

Visualization

Tap to expand

Step-by-Step Walkthrough

First DFS

Search for node x, recording its depth and parent

Second DFS

Search for node y, recording its depth and parent

Compare Results

Check if same depth but 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 {
    int depth;
    struct TreeNode* parent;
} NodeInfo;

NodeInfo findDepthAndParent(struct TreeNode* node, int target, struct TreeNode* parent, int depth) {
    NodeInfo result = {-1, NULL};
    
    if (!node) return result;
    
    if (node->val == target) {
        result.depth = depth;
        result.parent = parent;
        return result;
    }
    
    NodeInfo leftResult = findDepthAndParent(node->left, target, node, depth + 1);
    if (leftResult.depth != -1) return leftResult;
    
    return findDepthAndParent(node->right, target, node, depth + 1);
}

bool isCousins(struct TreeNode* root, int x, int y) {
    NodeInfo xInfo = findDepthAndParent(root, x, NULL, 0);
    NodeInfo yInfo = findDepthAndParent(root, y, NULL, 0);
    
    return xInfo.depth == yInfo.depth && xInfo.parent != yInfo.parent;
}

int main() {
    // Example usage
    struct TreeNode* root = malloc(sizeof(struct TreeNode));
    root->val = 1;
    root->left = malloc(sizeof(struct TreeNode));
    root->right = malloc(sizeof(struct TreeNode));
    root->left->val = 2;
    root->right->val = 3;
    root->left->left = malloc(sizeof(struct TreeNode));
    root->left->left->val = 4;
    root->left->right = NULL;
    root->right->left = NULL;
    root->right->right = NULL;
    
    printf("%s\n", isCousins(root, 4, 3) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two separate DFS traversals, each potentially visiting all n nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ 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

Brute Force (Separate DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler