Root Equals Sum of Children

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

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

✓ Direct Value Comparison

⏱️ Time: O(1) Space: O(1)

Since we have exactly 3 nodes, we can directly access the root and its two children, then compare the root's value with the sum of the children's values.

Single Null Check with Comparison

⏱️ Time: O(1) Space: O(1)

This approach adds safety by first checking if the tree structure is valid (root and both children exist) before performing the value comparison.

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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