Second Minimum Node In a Binary Tree

Second Minimum Node In a Binary Tree - Problem

Given a non-empty special binary tree consisting of nodes with non-negative values, where each node in this tree has exactly two or zero child nodes. If the node has two child nodes, then this node's value is the smaller value among its two child nodes.

More formally, the property root.val = min(root.left.val, root.right.val) always holds.

Given such a binary tree, you need to output the second minimum value in the set made of all the nodes' values in the whole tree. If no such second minimum value exists, output -1 instead.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: The tree has values {2, 3}. The minimum is 2 and the second minimum is 3.

Example 2 — No Second Minimum

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

› Output: -1

💡 Note: All nodes have the same value 2, so there is no second minimum value.

Example 3 — Larger Tree

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

› Output: 5

💡 Note: The tree has values {2, 5, 7}. The minimum is 2 and the second minimum is 5.

Constraints

The number of nodes in the tree is in the range [1, 25].
1 ≤ Node.val ≤ 2³¹ - 1
root.val == min(root.left.val, root.right.val) for each internal node of the tree.

Visualization

Tap to expand

Asked in

Li LinkedIn 15 a Amazon 12 G Google 8

The key insight is that the root is always the minimum value due to the tree property. We only need to find the smallest value greater than the root. The optimal approach uses DFS with a single variable to track the second minimum in O(n) time and O(h) space.

Common Approaches

✓ Collect All Values

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

Visit every node in the tree and collect all values in a set. Convert to sorted list and return the second element if it exists. This approach doesn't utilize the special property of the tree.

DFS with Pruning

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

Since the root is always the minimum value due to the tree property, we only need to find the smallest value greater than root. We can prune branches that don't lead to potential second minimum values.

Single Pass Optimized

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

Since root is always minimum, we just need to find the smallest value that's greater than root. Use a single variable to track this during traversal, updating it whenever we find a smaller candidate.

Collect All Values — Algorithm Steps

Perform DFS/BFS traversal of the entire tree
Add all node values to a set to avoid duplicates
Convert set to sorted list
Return second element if list has at least 2 elements, otherwise -1

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Traversal

Visit every node and collect values

Remove Duplicates

Use set to keep only unique values

Sort and Pick

Sort values and return second element

Code -

solution.c — C

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

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

struct ValueSet {
    int* values;
    int count;
    int capacity;
};

struct TreeNode* build_tree(int* arr, int len) {
    if (len == 0 || arr[0] == INT_MIN) {
        return NULL;
    }
    
    struct TreeNode* root = malloc(sizeof(struct TreeNode));
    root->val = arr[0];
    root->left = NULL;
    root->right = NULL;
    
    struct TreeNode** queue = malloc(len * sizeof(struct TreeNode*));
    queue[0] = root;
    int front = 0, rear = 1;
    int i = 1;
    
    while (front < rear && i < len) {
        struct TreeNode* node = queue[front++];
        
        if (i < len && arr[i] != INT_MIN) {
            node->left = malloc(sizeof(struct TreeNode));
            node->left->val = arr[i];
            node->left->left = NULL;
            node->left->right = NULL;
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < len && arr[i] != INT_MIN) {
            node->right = malloc(sizeof(struct TreeNode));
            node->right->val = arr[i];
            node->right->left = NULL;
            node->right->right = NULL;
            queue[rear++] = node->right;
        }
        i++;
    }
    
    free(queue);
    return root;
}

void dfs(struct TreeNode* node, struct ValueSet* set) {
    if (!node) return;
    
    // Check if value already exists
    int exists = 0;
    for (int i = 0; i < set->count; i++) {
        if (set->values[i] == node->val) {
            exists = 1;
            break;
        }
    }
    
    if (!exists) {
        if (set->count >= set->capacity) {
            set->capacity *= 2;
            set->values = realloc(set->values, set->capacity * sizeof(int));
        }
        set->values[set->count++] = node->val;
    }
    
    dfs(node->left, set);
    dfs(node->right, set);
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* root_arr, int len) {
    struct TreeNode* root = build_tree(root_arr, len);
    
    if (!root) {
        return -1;
    }
    
    struct ValueSet set;
    set.capacity = 100;
    set.values = malloc(set.capacity * sizeof(int));
    set.count = 0;
    
    dfs(root, &set);
    
    qsort(set.values, set.count, sizeof(int), compare);
    
    int result = set.count >= 2 ? set.values[1] : -1;
    free(set.values);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse the array from input like [2,2,3] or [2,2,5,null,null,5,7]
    int* arr = malloc(1000 * sizeof(int));
    int len = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find opening bracket
    if (*ptr) ptr++; // Skip '['
    
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++; // Skip whitespace and commas
        if (*ptr == ']') break;
        
        if (strncmp(ptr, "null", 4) == 0) {
            arr[len++] = INT_MIN; // Use INT_MIN to represent null
            ptr += 4;
        } else {
            char* end;
            arr[len++] = strtol(ptr, &end, 10);
            ptr = end;
        }
    }
    
    int result = solution(arr, len);
    printf("%d\n", result);
    
    free(arr);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Visit all n nodes O(n) plus sorting unique values O(k log k) where k ≤ n

✓ Linear Growth

Space Complexity

O(n)

Set to store unique values and recursion stack for DFS

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

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

Collect All Values — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler