Cousins in Binary Tree II

Cousins in Binary Tree II - Problem

Given the root of a binary tree, replace the value of each node in the tree with the sum of all its cousins' values.

Two nodes of a binary tree are cousins if they have the same depth with different parents.

Return the root of the modified tree.

Note: The depth of a node is the number of edges in the path from the root node to it.

Input & Output

Example 1 — Basic Tree

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

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

💡 Note: Root has no cousins (0). Level 1: nodes 4,9 have no cousins since they're the only nodes at that level (0,0). Level 2: node 1 has cousin 7 (value 7), node 10 has cousin 7 (value 7), node 7 has cousins 1,10 (sum = 11).

Example 2 — Single Node

$ Input: root = [3]

› Output: [0]

💡 Note: Single node has no cousins, so its value becomes 0.

Example 3 — Complete Binary Tree

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

› Output: [0,0,0,16,16,16,16]

💡 Note: Level 2: all nodes (4,5,6,7) are cousins of each other. Each gets sum of the other three: 4+5+6+7-own_value. Node 4: 22-6=16, similar for others.

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁴

Visualization

Tap to expand

Asked in

M Meta 15 a Amazon 12 M Microsoft 8 🍎 Apple 6

The key insight is to use BFS to process each level at once, calculating cousin sums as: level_sum - sibling_sum. The optimal BFS approach processes the tree in O(n) time with O(w) space where w is the maximum width.

Common Approaches

✓ BFS Level-by-Level Processing

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

Process the tree level by level using BFS. For each level, first calculate the total sum, then for each node subtract its sibling's values to get the cousin sum.

DFS with Level Tracking

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

First traverse the tree to group nodes by their depth level. Then for each node, find its cousins (same level, different parent) and sum their original values.

BFS Level-by-Level Processing — Algorithm Steps

Step 1: BFS traversal level by level
Step 2: For each level, calculate total sum of all nodes
Step 3: For each node, cousin sum = level sum - sibling sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Level Traversal

Process tree level by level using BFS queue

Level Sum

Calculate total sum of all nodes at current level

Cousin Calculation

For each node: cousin sum = level sum - sibling sum

Code -

solution.c — C

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

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

static struct TreeNode* queue[100000];
static struct TreeNode* currentLevel[10000];
static struct TreeNode* nextLevel[10000];
static int* values[10000];
static int nodeCount = 0;

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* solution(struct TreeNode* root) {
    if (!root) return NULL;
    
    root->val = 0;
    
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        int levelSize = rear - front;
        int currentCount = 0, nextCount = 0;
        
        // Collect current level and their children
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = queue[front + i];
            currentLevel[currentCount++] = node;
            if (node->left) nextLevel[nextCount++] = node->left;
            if (node->right) nextLevel[nextCount++] = node->right;
        }
        
        // Calculate total sum of next level
        int levelSum = 0;
        for (int i = 0; i < nextCount; i++) {
            levelSum += nextLevel[i]->val;
        }
        
        // Update children values and add to queue
        for (int i = 0; i < currentCount; i++) {
            struct TreeNode* node = currentLevel[i];
            int siblingSum = 0;
            if (node->left) siblingSum += node->left->val;
            if (node->right) siblingSum += node->right->val;
            
            int cousinSum = levelSum - siblingSum;
            
            if (node->left) {
                node->left->val = cousinSum;
                queue[rear++] = node->left;
            }
            if (node->right) {
                node->right->val = cousinSum;
                queue[rear++] = node->right;
            }
        }
        
        front += levelSize;
    }
    
    return root;
}

struct TreeNode* parseArray(char* line) {
    if (line[1] == ']') return NULL;
    
    // Parse first value
    char* ptr = line + 1;
    while (*ptr == ' ') ptr++;
    
    int rootVal = 0;
    while (*ptr >= '0' && *ptr <= '9') {
        rootVal = rootVal * 10 + (*ptr - '0');
        ptr++;
    }
    
    struct TreeNode* root = createNode(rootVal);
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (*ptr && front < rear) {
        struct TreeNode* node = queue[front++];
        
        // Skip comma and whitespace
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        if (!*ptr || *ptr == ']') break;
        
        // Parse left child
        if (*ptr == 'n') {
            ptr += 4; // skip "null"
        } else {
            int val = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                val = val * 10 + (*ptr - '0');
                ptr++;
            }
            node->left = createNode(val);
            queue[rear++] = node->left;
        }
        
        // Skip comma and whitespace
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        if (!*ptr || *ptr == ']') break;
        
        // Parse right child
        if (*ptr == 'n') {
            ptr += 4; // skip "null"
        } else {
            int val = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                val = val * 10 + (*ptr - '0');
                ptr++;
            }
            node->right = createNode(val);
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

void printTree(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    printf("[");
    int front = 0, rear = 0;
    queue[rear++] = root;
    int first = 1;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (!first) printf(",");
        first = 0;
        
        if (node) {
            printf("%d", node->val);
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            printf("null");
        }
    }
    
    printf("]\n");
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    struct TreeNode* root = parseArray(line);
    struct TreeNode* result = solution(root);
    printTree(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single BFS traversal visiting each node exactly once

⚠ Quadratic Growth

Space Complexity

O(w)

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

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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

BFS Level-by-Level Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler