Root Equals Sum of Children - Practice Coding Problems

Root Equals Sum of Children - Problem

You're working with a perfect small binary tree that has exactly 3 nodes: one root node and two children (left and right). Your task is simple but fundamental to tree algorithms!

Given the root of this 3-node binary tree, determine if the root's value equals the sum of its two children's values.

Goal: Return true if root.val == left.val + right.val, otherwise return false.

Example: If the tree looks like [10, 4, 6], then 10 == 4 + 6, so return true.

Input & Output

example_1.py — Balanced Tree

$ Input: [10, 4, 6]

› Output: true

💡 Note: The root value 10 equals the sum of children: 4 + 6 = 10, so return true

example_2.py — Unbalanced Tree

$ Input: [5, 3, 1]

› Output: false

💡 Note: The root value 5 does not equal the sum of children: 3 + 1 = 4 ≠ 5, so return false

example_3.py — Zero Sum Case

$ Input: [1, 1, 0]

› Output: true

💡 Note: The root value 1 equals the sum of children: 1 + 0 = 1, so return true

Constraints

The tree consists of exactly 3 nodes: 1 root + 2 children
Node values are in range [-100, 100]
Both left and right children are guaranteed to exist

Visualization

Tap to expand

Understanding the Visualization

Read Root Value

Access the parent node's value

Read Children Values

Access both left and right child values

Calculate Sum

Add the two children values together

Compare

Check if root equals the sum

Key Takeaway

🎯 Key Insight: With exactly 3 nodes, this becomes a simple arithmetic comparison rather than a complex tree algorithm!

Asked in

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

This problem has a simple O(1) solution since we only need to check if the root value equals the sum of exactly two children. The key insight is that with only 3 nodes guaranteed, we can directly access all values without complex tree traversal algorithms.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Tree Access	O(1)	O(1)	Directly access root and both children values, then compare

Direct Tree Access — Algorithm Steps

Access the root node's value
Access the left child's value
Access the right child's value
Return whether root value equals sum of children values

Visualization

Tap to expand

Step-by-Step Walkthrough

Access Root

Get the root node value

Access Children

Get both left and right child values

Compare

Check if root equals left + right

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

bool checkTree(struct TreeNode* root) {
    // Check if root equals sum of children
    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 input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for [a,b,c]
    int values[3];
    int count = 0;
    char* token = strtok(input, "[],\n ");
    
    while (token != NULL && count < 3) {
        values[count++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    if (count >= 3) {
        struct TreeNode* root = createNode(values[0]);
        root->left = createNode(values[1]);
        root->right = createNode(values[2]);
        
        printf("%s\n", checkTree(root) ? "true" : "false");
    } else {
        printf("false\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

We only access exactly 3 nodes once each

✓ Linear Growth

Space Complexity

O(1)

No additional space needed beyond the input tree

✓ Linear Space

52.0K Views

High Frequency

~5 min Avg. Time

2.4K 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 Tree Access — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler