Equal Tree Partition - Practice Coding Problems

Equal Tree Partition - Problem

Imagine you have a binary tree where each node contains a numerical value. Your task is to determine if you can split this tree into two separate trees by removing exactly one edge, such that both resulting trees have equal sum of node values.

Think of it like dividing a family tree into two branches where both sides have equal "wealth" (sum of values). You need to find the perfect cut point!

Goal: Return true if such a partition exists, false otherwise.

Example: If you have a tree with total sum 10, you need to find an edge that when removed, creates one subtree with sum 5 and another with sum 5.

Input & Output

example_1.py — Basic Equal Partition

$ Input: root = [5,10,10,null,null,2,3]

› Output: true

💡 Note: We can remove the edge between node 5 and node 10 (right child). This creates two trees: one with sum 15 (containing 5 and left subtree 10) and another with sum 15 (containing right subtree with 10,2,3). Both sums are equal.

example_2.py — Impossible Partition

$ Input: root = [1,2,10,null,null,2,20]

› Output: false

💡 Note: Total sum is 35, which is odd. Since we need two equal parts, and 35 cannot be divided evenly into two integers, no equal partition exists.

example_3.py — Single Node

$ Input: root = [0]

› Output: false

💡 Note: A single node tree has no edges to remove, so no partition is possible.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
Note: Removing an edge splits the tree into exactly two components

Visualization

Tap to expand

Understanding the Visualization

Calculate Total Weight

Sum all node values to get the total tree weight

Find Half-Weight Subtree

Look for a subtree with exactly half the total weight

Validate Cut Point

Ensure the subtree isn't the entire tree (can't cut above root)

Key Takeaway

🎯 Key Insight: If any subtree has sum = total_sum/2, removing the edge to its parent creates two trees with equal sums!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal approach uses two-pass tree traversal: first calculate and store all subtree sums, then check if any subtree has sum equal to total_sum/2. This creates an equal partition when that subtree is removed. Time complexity: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass with Subtree Sums	O(n)	O(n)	First pass calculates all subtree sums, second pass checks for equal partition
Brute Force (Check Every Edge)	O(n²)	O(h)	Try removing each edge and calculate sums of resulting subtrees

Two-Pass with Subtree Sums — Algorithm Steps

First pass: Calculate total sum of entire tree
Store subtree sums in a hash set during traversal
Second pass: For each subtree sum, check if it equals total_sum/2
If found, verify it's not the entire tree
Return true if valid partition exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Sums

Traverse tree and store each subtree sum

Find Target

Look for sum equal to total_sum/2

Validate

Ensure it's not the entire tree

Code -

solution.c — C

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

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

#define MAX_NODES 10000
int subtreeSums[MAX_NODES];
int sumCount = 0;
struct TreeNode* originalRoot;

int calculateSums(struct TreeNode* node) {
    if (!node) return 0;
    
    int leftSum = calculateSums(node->left);
    int rightSum = calculateSums(node->right);
    int currentSum = node->val + leftSum + rightSum;
    
    if (node != originalRoot && sumCount < MAX_NODES) {
        subtreeSums[sumCount++] = currentSum;
    }
    
    return currentSum;
}

bool containsSum(int target) {
    for (int i = 0; i < sumCount; i++) {
        if (subtreeSums[i] == target) {
            return true;
        }
    }
    return false;
}

bool checkEqualTree(struct TreeNode* root) {
    if (!root) return false;
    
    originalRoot = root;
    sumCount = 0;
    
    int totalSum = calculateSums(root);
    
    if (totalSum % 2 == 1) {
        return false;
    }
    
    int target = totalSum / 2;
    return containsSum(target);
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the tree, each taking O(n) time

✓ Linear Growth

Space Complexity

O(n)

Hash set stores up to n subtree sums plus recursion stack

⚡ Linearithmic Space

28.1K Views

Medium Frequency

~18 min Avg. Time

892 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

Two-Pass with Subtree Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler