Most Frequent Subtree Sum - Practice Coding Problems

Most Frequent Subtree Sum - Problem

You are given the root of a binary tree and need to find the most frequent subtree sum(s). A subtree sum is calculated by adding up all the values of nodes in a subtree rooted at a particular node (including the node itself).

Your task is to return all subtree sums that appear most frequently. If there's a tie between multiple sums having the same highest frequency, return all of them in any order.

Example: If a tree has subtree sums [2, -3, 4, 2, -3, 2], then the sum 2 appears 3 times (most frequent), so we return [2]. If both 2 and -3 appeared 3 times each, we'd return [2, -3].

This problem combines tree traversal with frequency counting - a common pattern in coding interviews!

Input & Output

example_1.py — Basic Tree

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

› Output: [2, -3, 4]

💡 Note: Subtree sums are: Node 5: 5+2+(-3)+4=8, Node 2: 2, Node -3: -3+4=1, Node 4: 4. Each sum appears once, so all are most frequent.

example_2.py — Repeated Sums

$ Input: root = [5,2,-5]

› Output: [2]

💡 Note: Subtree sums are: Node 5: 5+2+(-5)=2, Node 2: 2, Node -5: -5. Sum 2 appears twice (most frequent), so return [2].

example_3.py — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Only one node with value 1, so subtree sum is 1, appearing once. Return [1].

Visualization

Tap to expand

Understanding the Visualization

Start at Leaves

Begin with leaf nodes (people with no children) - their subtree sum is just their own value

Move Up Levels

For each parent node, add their value to the sum of all their children's subtree sums

Track Frequencies

Keep count of how many times each subtree sum appears using a hash map

Find Maximum

Return all sums that appear most frequently in the tree

Key Takeaway

🎯 Key Insight: Post-order traversal ensures we calculate children's sums before parents, making each subtree sum calculation efficient in O(1) time per node.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(n)

Hash map for frequencies plus O(h) recursion stack where h is tree height

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
Follow up: Can you solve it without using extra space for the frequency map?

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal solution uses post-order DFS traversal to calculate subtree sums efficiently. Each node's subtree sum equals its value plus the sums of its left and right subtrees. We use a hash map to track frequencies and find the most frequent sums in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass DFS with Hash Map (Optimal)	O(n)	O(n)	Calculate subtree sums and count frequencies in single post-order traversal
Brute Force (Separate Traversals)	O(n²)	O(n)	Calculate each subtree sum separately, then count frequencies

One-Pass DFS with Hash Map (Optimal) — Algorithm Steps

Start post-order DFS from root node
For each node, recursively calculate left and right subtree sums
Calculate current subtree sum: node.val + leftSum + rightSum
Update frequency count for this sum in hash map
Track maximum frequency seen so far
Return all sums that have the maximum frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Left Subtree

Recursively calculate left subtree sum

Visit Right Subtree

Recursively calculate right subtree sum

Process Current Node

Sum = node.val + leftSum + rightSum

Update Frequencies

Track frequency and max frequency in hash map

Code -

solution.c — C

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

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

#define MAX_NODES 10000

struct FreqEntry {
    int sum;
    int freq;
};

struct FreqEntry freqMap[MAX_NODES];
int freqCount = 0;
int maxFreq = 0;

int dfs(struct TreeNode* node) {
    if (!node) return 0;
    
    // Post-order: calculate left and right subtree sums first
    int leftSum = dfs(node->left);
    int rightSum = dfs(node->right);
    
    // Calculate current subtree sum
    int subtreeSum = node->val + leftSum + rightSum;
    
    // Update frequency count
    int found = 0;
    for (int i = 0; i < freqCount; i++) {
        if (freqMap[i].sum == subtreeSum) {
            freqMap[i].freq++;
            if (freqMap[i].freq > maxFreq) {
                maxFreq = freqMap[i].freq;
            }
            found = 1;
            break;
        }
    }
    
    if (!found) {
        freqMap[freqCount].sum = subtreeSum;
        freqMap[freqCount].freq = 1;
        if (1 > maxFreq) {
            maxFreq = 1;
        }
        freqCount++;
    }
    
    return subtreeSum;
}

int* findFrequentTreeSum(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    // Reset global variables
    freqCount = 0;
    maxFreq = 0;
    
    // Start DFS traversal
    dfs(root);
    
    // Count results
    int resultCount = 0;
    for (int i = 0; i < freqCount; i++) {
        if (freqMap[i].freq == maxFreq) {
            resultCount++;
        }
    }
    
    // Allocate and fill result array
    int* result = (int*)malloc(resultCount * sizeof(int));
    *returnSize = resultCount;
    
    int idx = 0;
    for (int i = 0; i < freqCount; i++) {
        if (freqMap[i].freq == maxFreq) {
            result[idx++] = freqMap[i].sum;
        }
    }
    
    return result;
}

int main() {
    // Parse input and create tree
    // struct TreeNode* root = parseTree();
    // int returnSize;
    // int* result = findFrequentTreeSum(root, &returnSize);
    // Print result
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(n)

Hash map for frequencies plus O(h) recursion stack where h is tree height

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
Follow up: Can you solve it without using extra space for the frequency map?

76.3K Views

Medium Frequency

~18 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass DFS with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler