Count Univalue Subtrees - Practice Coding Problems

Count Univalue Subtrees - Problem

Count Univalue Subtrees is a fascinating tree traversal problem that tests your understanding of recursive depth-first search and tree structure analysis.

Given the root of a binary tree, you need to count how many subtrees are "uni-value" - meaning all nodes in that subtree have the exact same value.

Key Points:

A single node is always a uni-value subtree
An empty tree (null node) is not counted
A subtree is uni-value only if ALL its nodes have the same value
You need to check every possible subtree in the tree

Goal: Return the total count of uni-value subtrees found in the entire binary tree.

Input & Output

example_1.py — Basic Tree

$ Input: root = [5,1,5,5,5,null,5]

› Output: 4

💡 Note: The tree has 4 uni-value subtrees: three leaf nodes with value 5, and one subtree with root at the right child of root (containing two nodes with value 5).

example_2.py — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: A single node is always a uni-value subtree by definition, so the answer is 1.

example_3.py — All Same Values

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

› Output: 7

💡 Note: When all nodes have the same value, every possible subtree is uni-value. With 7 nodes, there are 7 different subtrees (each node can be a root of a subtree).

Visualization

Tap to expand

Understanding the Visualization

🏠 Start with Individual Houses

Every single house (leaf node) is automatically a uniform neighborhood

🏘️ Check Small Streets

Look at parent-child relationships - do they form uniform neighborhoods?

🏙️ Build Up to Districts

Continue building upward, checking larger and larger neighborhoods

📊 Count All Discoveries

Sum up all uniform neighborhoods found at every level

Key Takeaway

🎯 Key Insight: The optimal approach processes the tree bottom-up, checking each subtree exactly once. This eliminates redundant work and achieves O(n) time complexity by combining the validation and counting in a single traversal.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once during the DFS traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 1000]
-1000 ≤ Node.val ≤ 1000
Tree nodes can have negative values
An empty tree returns 0

Asked in

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

The optimal solution uses a single-pass DFS with bottom-up processing. By checking children before parents (post-order traversal), we can determine if each subtree is uni-value while counting them in O(n) time. The key insight is returning both the count and uni-value status from each recursive call, eliminating redundant tree traversals.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Subtree)	O(n²)	O(h)	For each node, traverse its entire subtree to check if all values match
Single Pass DFS (Optimal)	O(n)	O(h)	Use bottom-up DFS to check and count uni-value subtrees in one traversal

Brute Force (Check Each Subtree) — Algorithm Steps

Traverse each node in the tree
For each node, perform a separate DFS to check if its subtree is uni-value
Count nodes that have uni-value subtrees
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Root Subtree

Traverse entire tree to check if all nodes have same value

Check Left Subtree

Traverse left subtree again to check uniformity

Check Right Subtree

Traverse right subtree again to check uniformity

Repeat for All Nodes

Continue this process for every node in the tree

Code -

solution.c — C

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

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

bool isUniValue(struct TreeNode* node, int val) {
    if (!node) return true;
    if (node->val != val) return false;
    return isUniValue(node->left, val) && isUniValue(node->right, val);
}

int traverse(struct TreeNode* node) {
    if (!node) return 0;
    
    int count = 0;
    if (isUniValue(node, node->val)) {
        count = 1;
    }
    
    count += traverse(node->left);
    count += traverse(node->right);
    return count;
}

int countUnivalSubtrees(struct TreeNode* root) {
    if (!root) return 0;
    return traverse(root);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse all n nodes to check if subtree is uni-value

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 1000]
-1000 ≤ Node.val ≤ 1000
Tree nodes can have negative values
An empty tree returns 0

76.3K Views

Medium-High 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

Brute Force (Check Each Subtree) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler