Univalued Binary Tree - Practice Coding Problems

Univalued Binary Tree - Problem

Univalued Binary Tree

Imagine you have a binary tree where every node contains a value. A uni-valued binary tree is one where every single node has the exact same value - like a perfectly uniform tree where all nodes share the same identity!

Your task is simple yet elegant: given the root of a binary tree, determine whether this tree is uni-valued. Return true if all nodes have the same value, or false if there's even one node that differs.

This problem tests your ability to traverse a tree structure and check a global property across all nodes. It's a perfect introduction to tree traversal algorithms and a common building block for more complex tree problems.

Input & Output

example_1.py — Simple Univalued Tree

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

› Output: true

💡 Note: All nodes in the tree have the value 1, making this a perfect univalued binary tree.

example_2.py — Mixed Values Tree

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

› Output: false

💡 Note: The tree contains nodes with value 2 and one node with value 5. Since not all nodes have the same value, this is not univalued.

example_3.py — Single Node Tree

$ Input: root = [5]

› Output: true

💡 Note: A tree with only one node is always univalued since there's only one value to consider.

Constraints

The number of nodes in the tree is in the range [1, 100]
0 ≤ Node.val ≤ 99
Follow-up: Can you solve this iteratively using BFS?

Visualization

Tap to expand

Understanding the Visualization

Set Reference

Use the root node's value as the standard uniform everyone should match

Inspect Each Member

Visit each node in the tree and compare its value to the reference

Early Detection

If any node differs from reference, immediately return false

Complete Verification

If all nodes match the reference, the tree is univalued

Key Takeaway

🎯 Key Insight: Instead of comparing every node with every other node (O(n²)), we only need to compare each node with one reference value (the root), achieving optimal O(n) time complexity!

Asked in

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

The optimal solution uses single-pass DFS traversal with O(n) time complexity. Store the root's value as reference and compare each node during traversal. The key insight is that we only need one reference value (root's value) instead of comparing all pairs of nodes.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass DFS (Optimal)	O(n)	O(h)	Traverse tree once, comparing each node with the root value
Brute Force (Compare All Pairs)	O(n²)	O(n)	Compare every node's value with every other node's value

Single Pass DFS (Optimal) — Algorithm Steps

Store the root's value as our reference value
Perform DFS traversal of the tree
At each node, compare its value with the reference
If any node differs from reference, return false immediately
If traversal completes without differences, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Use root's value as reference for all comparisons

DFS Traversal

Visit each node and compare its value with the reference

Early Return

Return false immediately if any node differs from reference

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 dfs(struct TreeNode* node, int targetVal) {
    if (!node) return true;
    
    if (node->val != targetVal) {
        return false;
    }
    
    return dfs(node->left, targetVal) && dfs(node->right, targetVal);
}

bool isUnivalTree(struct TreeNode* root) {
    if (!root) return true;
    return dfs(root, root->val);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node at most once during the DFS traversal

✓ Linear Growth

Space Complexity

O(h)

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

✓ Linear Space

42.5K Views

Medium Frequency

~8 min Avg. Time

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

Single Pass DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler