Count Univalue Subtrees

Count Univalue Subtrees - Problem

Given the root of a binary tree, return the number of uni-value subtrees.

A uni-value subtree means all nodes of the subtree have the same value.

Example:

Input: root = [5,1,5,5,5,null,5]
Output: 4
Explanation: There are 4 uni-value subtrees

Input & Output

Example 1 — Mixed Tree with 4 Uni-value Subtrees

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

› Output: 4

💡 Note: The four uni-value subtrees are: three leaf nodes with value 5, and the right subtree rooted at 5 (which contains only node 5). The subtree rooted at node 1 is not uni-value because it contains both 1 and 5.

Example 2 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: A single node is always a uni-value subtree by itself.

Example 3 — All Same Values

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

› Output: 7

💡 Note: All nodes have the same value, so every subtree is uni-value. Total 7 nodes = 7 uni-value subtrees.

Constraints

The number of nodes in the tree is in the range [1, 1000]
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12

The key insight is to use post-order DFS traversal to check uniformity bottom-up. A subtree is uniform only if both children are uniform and have the same value as the parent. Best approach is DFS Post-Order with Time: O(n), Space: O(h).

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force - Check Every Subtree

⏱️ Time: O(n²) Space: O(h)

Visit each node and for each node, perform a separate traversal to check if all nodes in its subtree have the same value. Count all subtrees that pass this test.

DFS Post-Order Traversal

⏱️ Time: O(n) Space: O(h)

Use post-order traversal to visit children before parent. For each node, check if both children are uniform and have same value as parent. Count valid subtrees in one pass.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

TreeNode* createNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = node->right = NULL;
    return node;
}

int countUnivalSubtrees;

bool isUnival(TreeNode* root) {
    if (!root) return true;
    
    bool leftUnival = isUnival(root->left);
    bool rightUnival = isUnival(root->right);
    
    // Check if current subtree is unival
    if (leftUnival && rightUnival) {
        // Check if left child has same value (if exists)
        if (root->left && root->left->val != root->val) {
            return false;
        }
        // Check if right child has same value (if exists)
        if (root->right && root->right->val != root->val) {
            return false;
        }
        // If we reach here, current subtree is unival
        countUnivalSubtrees++;
        return true;
    }
    
    return false;
}

int countUnivalueSubtrees(TreeNode* root) {
    countUnivalSubtrees = 0;
    isUnival(root);
    return countUnivalSubtrees;
}

TreeNode* buildTreeFromArray(char* input) {
    if (!input || strlen(input) <= 2) return NULL;
    
    // Skip '[' and find first value
    char* ptr = input + 1;
    while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
    
    if (*ptr == ']') return NULL;
    
    // Parse root value
    bool negative = false;
    if (*ptr == '-') {
        negative = true;
        ptr++;
    }
    
    int rootVal = 0;
    while (*ptr && isdigit(*ptr)) {
        rootVal = rootVal * 10 + (*ptr - '0');
        ptr++;
    }
    if (negative) rootVal = -rootVal;
    
    TreeNode* root = createNode(rootVal);
    
    // Use queue for level-order construction
    TreeNode** queue = (TreeNode**)malloc(10000 * sizeof(TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        TreeNode* current = queue[front++];
        
        // Skip to next value
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr == ']' || !*ptr) break;
        
        // Parse left child
        if (strncmp(ptr, "null", 4) == 0) {
            ptr += 4;
        } else {
            negative = false;
            if (*ptr == '-') {
                negative = true;
                ptr++;
            }
            
            int val = 0;
            while (*ptr && isdigit(*ptr)) {
                val = val * 10 + (*ptr - '0');
                ptr++;
            }
            if (negative) val = -val;
            
            current->left = createNode(val);
            queue[rear++] = current->left;
        }
        
        // Skip to next value
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr == ']' || !*ptr) break;
        
        // Parse right child
        if (strncmp(ptr, "null", 4) == 0) {
            ptr += 4;
        } else {
            negative = false;
            if (*ptr == '-') {
                negative = true;
                ptr++;
            }
            
            int val = 0;
            while (*ptr && isdigit(*ptr)) {
                val = val * 10 + (*ptr - '0');
                ptr++;
            }
            if (negative) val = -val;
            
            current->right = createNode(val);
            queue[rear++] = current->right;
        }
    }
    
    free(queue);
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    TreeNode* root = buildTreeFromArray(input);
    int result = countUnivalueSubtrees(root);
    
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~15 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