Cousins in Binary Tree II - Practice Coding Problems

Cousins in Binary Tree II - Problem

Given the root of a binary tree, your task is to transform each node by replacing its value with the sum of all its cousins' values.

What are cousins? Two nodes in a binary tree are considered cousins if they satisfy two conditions:

They are at the same depth (same level) in the tree
They have different parents

The depth of a node is defined as the number of edges in the path from the root to that node. The root has depth 0.

Goal: Return the root of the modified tree where each node's value is replaced by the sum of its cousins' values. If a node has no cousins, its value becomes 0.

Example: If nodes A and B are cousins with values 3 and 7, and node C is also their cousin with value 2, then A's new value becomes 7+2=9, B's new value becomes 3+2=5, and C's new value becomes 3+7=10.

Input & Output

example_1.py — Basic Tree

$ Input: root = [5,4,9,1,10,null,7]

› Output: [0,0,0,7,7,null,11]

💡 Note: Root (5) has no cousins → 0. Level 1 nodes (4,9) have no cousins → both 0. Level 2: nodes 1,10 are cousins of 7, so 1→7, 10→7. Node 7 is cousin of 1,10, so 7→1+10=11.

example_2.py — Smaller Tree

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

› Output: [0,0,0]

💡 Note: Root (3) has no cousins → 0. Nodes 1 and 2 are at the same level but are siblings (same parent), not cousins → both 0.

example_3.py — Single Node

$ Input: root = [1]

› Output: [0]

💡 Note: Single node tree - the root has no cousins, so its value becomes 0.

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁴
Tree structure: The tree can be any valid binary tree structure

Asked in

The optimal approach uses single-pass BFS to process the tree level by level. For each level, calculate the total sum of the next level, then for each parent node, compute cousin sums by subtracting sibling sums from the level total. This achieves O(n) time and O(w) space complexity where w is the maximum tree width.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS for Each Node)	O(n²)	O(h)	For each node, traverse entire tree to find cousins and sum their values
Optimal One-Pass BFS with Parent Tracking	O(n)	O(w)	Single BFS traversal processing level by level, calculating cousin sums on-the-fly using parent node tracking

Brute Force (DFS for Each Node) — Algorithm Steps

For each node in the tree, determine its depth and parent
Traverse the entire tree to find all nodes at the same depth
Filter out siblings (nodes with same parent) to get cousins
Sum the values of all cousin nodes
Replace current node's value with the cousin sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Target Node

Choose a node to find cousins for

Full Tree Traversal

Search entire tree to find nodes at same depth

Filter Siblings

Remove nodes with same parent as target

Sum Cousin Values

Add up values of remaining cousin nodes

Code -

solution.c — C

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

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

typedef struct {
    int depth;
    struct TreeNode* parent;
} DepthParent;

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

void getAllNodes(struct TreeNode* node, struct TreeNode** nodes, int* count) {
    if (!node) return;
    nodes[(*count)++] = node;
    getAllNodes(node->left, nodes, count);
    getAllNodes(node->right, nodes, count);
}

struct TreeNode* replaceValueInTree(struct TreeNode* root) {
    if (!root) return root;
    
    struct TreeNode* allNodes[1000];
    int originalValues[1000];
    int nodeCount = 0;
    
    getAllNodes(root, allNodes, &nodeCount);
    
    // Store original values
    for (int i = 0; i < nodeCount; i++) {
        originalValues[i] = allNodes[i]->val;
    }
    
    for (int i = 0; i < nodeCount; i++) {
        DepthParent targetInfo = getDepthParent(root, allNodes[i], NULL, 0);
        int cousinSum = 0;
        
        for (int j = 0; j < nodeCount; j++) {
            if (i == j) continue;
            DepthParent otherInfo = getDepthParent(root, allNodes[j], NULL, 0);
            
            if (otherInfo.depth == targetInfo.depth && otherInfo.parent != targetInfo.parent) {
                cousinSum += originalValues[j];
            }
        }
        allNodes[i]->val = cousinSum;
    }
    
    return root;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we traverse the entire tree to find cousins

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear 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