Leetcode 2236: Root Equals Sum of Children

Input: The input consists of a binary tree with exactly three nodes: a root node, a left child, and a right child. Each node contains an integer value.

Example: Input: root = [7, 3, 4]

Constraints:

• The binary tree always has three nodes: root, left child, and right child.

• -100 <= Node.val <= 100

Output: Return a boolean value indicating whether the value of the root node is equal to the sum of the values of its two children.

Example: Output: true

Constraints:

• The output should be either true or false.

Goal: Check if the sum of the values of the left and right children equals the value of the root node.

Steps:

• 1. Access the value of the root node.

• 2. Access the values of the left and right child nodes.

• 3. Compute the sum of the left and right child node values.

• 4. Compare the computed sum with the value of the root node.

• 5. Return true if they are equal; otherwise, return false.

Goal: The binary tree structure is fixed with exactly three nodes, and all node values fall within the specified range.

Steps:

• The tree will always consist of three nodes: root, left child, and right child.

• Node values are integers within the range -100 to 100.

Assumptions:

• The binary tree input will always be valid with three nodes.

• No additional nodes or structures are present in the input.

• Input: Input: root = [7, 3, 4]

• Explanation: The value of the root is 7, and the sum of the left and right children is 3 + 4 = 7. Since they are equal, the output is true.

• Input: Input: root = [8, 5, 2]

• Explanation: The value of the root is 8, and the sum of the left and right children is 5 + 2 = 7. Since they are not equal, the output is false.

Approach: The approach involves simple arithmetic comparisons to validate the relationship between the root and its children.

Observations:

• The tree is small with only three nodes, so the logic is straightforward.

• The problem only requires basic comparison of integer values.

• Accessing and comparing node values directly should be sufficient to solve this problem efficiently.

Steps:

• 1. Retrieve the values of the root, left child, and right child.

• 2. Compute the sum of the left and right child node values.

• 3. Compare the computed sum to the root node value.

• 4. Return true if they match; otherwise, return false.

Empty Inputs:

• Not applicable, as the input always contains three nodes.

Large Inputs:

• Not applicable, as the input size is fixed to three nodes.

Special Values:

• All node values are zeros, e.g., root = [0, 0, 0].

• The root value is negative, and its children sum to match it.

Constraints:

• Ensure comparisons handle both negative and positive integers correctly.

bool checkTree(TreeNode* root) {
    return (root->left->val)+(root->right->val)==root->val;
}

1 : Function Definition

bool checkTree(TreeNode* root) {

Defines the 'checkTree' function that takes a pointer to the root of a binary tree and returns a boolean value.

2 : Return Statement

    return (root->left->val)+(root->right->val)==root->val;

Returns 'true' if the sum of the values of the left and right children of the root node equals the root's value; otherwise, returns 'false'.

Best Case: O(1)

Average Case: O(1)

Worst Case: O(1)

Description: The time complexity is constant because the binary tree always contains exactly three nodes.

Best Case: O(1)

Worst Case: O(1)

Description: The solution uses constant space as no additional memory is required beyond the input.

Leetcode 2236: Root Equals Sum of Children

Explore →