Univalued Binary Tree

Univalued Binary Tree - Problem

A binary tree is uni-valued if every node in the tree has the same value.

Given the root of a binary tree, return true if the given tree is uni-valued, or false otherwise.

Input & Output

Example 1 — All Same Values

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

› Output: true

💡 Note: All nodes have value 1, so the tree is uni-valued

Example 2 — Different Values

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

› Output: false

💡 Note: One node has value 5 while others have value 2, so not uni-valued

Example 3 — Single Node

$ Input: root = [1]

› Output: true

💡 Note: A single node tree is always uni-valued

Constraints

The number of nodes in the tree is in the range [0, 100].
0 ≤ Node.val ≤ 99

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that all nodes must have the same value as the root. Best approach is DFS with early termination - compare each node with the root's value during traversal. Time: O(n), Space: O(h)

Common Approaches

✓ BFS - Level Order Traversal

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

Perform breadth-first search using a queue, comparing each node's value with the root's value level by level.

Brute Force - Compare All Nodes

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

First traverse the entire tree to collect all node values into a list, then iterate through the list to verify all values are identical.

DFS - One Pass Comparison

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

Perform depth-first search and compare each node's value with the root's value. Return false immediately if any node differs.

BFS - Level Order Traversal — Algorithm Steps

Step 1: Initialize queue with root and store target value
Step 2: Process each level, comparing nodes with target
Step 3: Return false immediately if any node differs

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root in queue, store target value

Process Levels

Check each node against target, add children to queue

Early Return

Return false on first mismatch

Code -

solution.c — C

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

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

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

bool solution(struct TreeNode* root) {
    if (!root) {
        return true;
    }
    
    int targetVal = root->val;
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (node->val != targetVal) {
            return false;
        }
        
        if (node->left) {
            queue[rear++] = node->left;
        }
        if (node->right) {
            queue[rear++] = node->right;
        }
    }
    
    return true;
}

struct TreeNode* buildTree(int* arr, int* isNull, int size) {
    if (size == 0 || isNull[0]) {
        return NULL;
    }
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && !isNull[i]) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && !isNull[i]) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

void parseArray(const char* str, int* arr, int* isNull, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "null", 4) == 0) {
            arr[*size] = 0;
            isNull[*size] = 1;
            p += 4;
        } else {
            arr[*size] = (int)strtol(p, (char**)&p, 10);
            isNull[*size] = 0;
        }
        (*size)++;
    }
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = '\0';
    
    int arr[1000];
    int isNull[1000];
    int size;
    
    parseArray(input, arr, isNull, &size);
    
    struct TreeNode* root = buildTree(arr, isNull, size);
    bool result = solution(root);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node once, may terminate early on mismatch

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum tree width

✓ Linear Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS - Level Order Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler