Second Minimum Node In a Binary Tree - Practice Coding Problems

Second Minimum Node In a Binary Tree - Problem

Given a special binary tree with a unique property, find the second smallest value among all nodes in the tree.

This isn't just any binary tree - it has a fascinating constraint: every parent node's value equals the minimum of its two children. More formally, root.val = min(root.left.val, root.right.val) always holds.

Tree Structure Rules:

Each node has either exactly 2 children or 0 children (leaf node)
All values are non-negative integers
Parent nodes always contain the smaller value of their children

Goal: Return the second minimum value in the entire tree, or -1 if no such value exists.

Example: In a tree with values [2, 2, 3], the minimum is 2 and the second minimum is 3.

Input & Output

example_1.py — Basic Tree

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

› Output: 3

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

example_2.py — Complex Tree

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

› Output: 5

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

example_3.py — No Second Minimum

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

› Output: -1

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

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
Each node has either 0 or 2 children

Visualization

Tap to expand

Understanding the Visualization

Root = Tournament Champion

The root has the lowest score (minimum value) in the entire tournament

Explore Different Scores

Only follow tournament paths where participants have higher scores than the champion

Skip Duplicate Champions

If a participant has the same score as the champion, their subtournament won't help us

Find Runner-up

The smallest score greater than the champion's score is our answer

Key Takeaway

🎯 Key Insight: Since the root is guaranteed to be the minimum (champion), we only need to explore subtrees where children have different values, making our search much more efficient!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 5

The optimal solution leverages the special tree property where the root is guaranteed to be the minimum value. We use smart DFS traversal that only explores subtrees where a child's value differs from the root, dramatically reducing the search space from O(n) to often much less in practice.

Common Approaches

Approach	Time	Space	Notes
✓ Smart DFS (Optimal)	O(n)	O(h)	Use tree property: root is minimum, only explore differing children paths
Brute Force (Collect All Values)	O(n log n)	O(n)	Traverse entire tree, collect all values, sort and find second minimum

Smart DFS (Optimal) — Algorithm Steps

Start with root value as the minimum
For each node, if it equals root value, explore both children
If a node's value > root value, it could be our answer
Recursively find the minimum value greater than root
Return the smallest such value found, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Root is Minimum

Root value (2) is guaranteed to be the minimum

Explore Different Values

Only visit subtrees where node value > root value

Prune Early

Skip subtrees that can only contain the minimum

Find Second Min

Return the smallest value > root value

Code -

solution.c — C

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

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

int dfs(struct TreeNode* node, int minVal) {
    if (!node) return -1;
    
    // If current value > minVal, this could be our answer
    if (node->val > minVal) {
        return node->val;
    }
    
    // If current value == minVal, explore children
    int leftMin = dfs(node->left, minVal);
    int rightMin = dfs(node->right, minVal);
    
    // Return the smaller of the two valid candidates
    if (leftMin == -1) return rightMin;
    if (rightMin == -1) return leftMin;
    return leftMin < rightMin ? leftMin : rightMin;
}

int findSecondMinimumValue(struct TreeNode* root) {
    if (!root) return -1;
    return dfs(root, root->val);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we visit all nodes, but often much fewer due to pruning

✓ Linear Growth

Space Complexity

O(h)

O(h) for recursion stack where h is tree height

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Smart DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler