Root Equals Sum of Children - Practice Coding Problems

Root Equals Sum of Children - Problem

You are given the root of a binary tree that consists of exactly 3 nodes: the root, its left child, and its right child.

Return true if the value of the root is equal to the sum of the values of its two children, or false otherwise.

Input & Output

Example 1 — Root Equals Sum

$ Input: root = [10,4,6]

› Output: true

💡 Note: Root value 10 equals the sum of its children: 4 + 6 = 10

Example 2 — Root Not Equal Sum

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

› Output: false

💡 Note: Root value 5 does not equal the sum of its children: 3 + 1 = 4 ≠ 5

Example 3 — Negative Values

$ Input: root = [1,1,0]

› Output: true

💡 Note: Root value 1 equals the sum: 1 + 0 = 1

Constraints

The tree consists of exactly 3 nodes: root, left child, and right child
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input Tree

Binary tree with exactly 3 nodes: [10,4,6]

Process

Check if root.val == left.val + right.val

Output

Return true if equal, false otherwise

Key Takeaway

🎯 Key Insight: With exactly 3 nodes, we can directly compare the root value with the sum of its children in constant time

Asked in

M Microsoft 15 a Amazon 12

The key insight is that with exactly 3 nodes, we can directly access the root and both children to compare values. Best approach is direct comparison with null safety checks. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Direct Value Comparison	O(1)	O(1)	Directly compare root value with sum of left and right child values
Single Null Check with Comparison	O(1)	O(1)	Add defensive null checking before comparing values

Direct Value Comparison — Algorithm Steps

Step 1: Access root value
Step 2: Get left child value and right child value
Step 3: Compare root.val with left.val + right.val

Visualization

Tap to expand

Step-by-Step Walkthrough

Access Values

Get root.val, left.val, and right.val

Calculate Sum

Compute left.val + right.val

Compare

Check if root.val equals the sum

Code -

solution.c — C

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

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

bool solution(struct TreeNode* root) {
    if (!root || !root->left || !root->right) {
        return false;
    }
    return root->val == root->left->val + root->right->val;
}

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;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [root,left,right] format
    int vals[3];
    int count = 0;
    char* token = strtok(line, "[,]\n");
    while (token != NULL && count < 3) {
        vals[count++] = atoi(token);
        token = strtok(NULL, "[,]\n");
    }
    
    struct TreeNode* root = createNode(vals[0]);
    root->left = createNode(vals[1]);
    root->right = createNode(vals[2]);
    
    bool result = solution(root);
    printf(result ? "true\n" : "false\n");
    
    free(root->left);
    free(root->right);
    free(root);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only accessing 3 nodes with constant operations

✓ Linear Growth

Space Complexity

O(1)

No additional data structures needed

✓ Linear Space

26.4K Views

Medium Frequency

~5 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Value Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler