Closest Binary Search Tree Value - Practice Coding Problems

Closest Binary Search Tree Value - Problem

Given the root of a binary search tree and a target value, find the value in the BST that is closest to the target.

The goal is to minimize the absolute difference between any node's value and the target. If there are multiple nodes with the same minimum distance, return the smallest value.

Example: If your BST contains values [1, 3, 6, 8] and target is 4.5, both 3 and 6 are distance 1.5 away, so return 3 (the smaller value).

Input & Output

example_1.py — Basic Case

$ Input: root = [4,2,6,1,3], target = 3.714286

› Output: 4

💡 Note: The values 3 and 4 are both close to the target. Distance from 3: |3 - 3.714286| = 0.714286. Distance from 4: |4 - 3.714286| = 0.285714. Since 4 is closer, we return 4.

example_2.py — Tie Breaking

$ Input: root = [1,null,3], target = 2.0

› Output: 1

💡 Note: Both 1 and 3 are exactly distance 1.0 from target 2.0. According to the problem, we return the smaller value, which is 1.

example_3.py — Single Node

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

› Output: 5

💡 Note: Tree contains only one node with value 5, so that must be the closest value regardless of target.

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at the root node (city center) and set it as current closest

Smart Navigation

At each intersection, choose direction based on target: left for smaller values, right for larger

Track Best Option

Update closest value whenever we find a better candidate during our journey

Efficient Path

Reach the answer in O(height) steps instead of visiting every node

Key Takeaway

🎯 Key Insight: BST property eliminates half the search space at each step, making this problem solvable in O(log n) time for balanced trees - much better than checking every node!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must visit all n nodes in the tree to ensure we find the closest value

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, which can be O(n) in worst case

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
0 ≤ Node.val ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹
It's guaranteed that there will be only one unique value closest to the target

Asked in

G Google 45 a Amazon 38 f Facebook 25 ⊞ Microsoft 22

The optimal solution leverages the Binary Search Tree property to navigate efficiently toward the closest value. Instead of visiting all nodes (O(n)), we make smart decisions at each step: go left if target is smaller, right if larger. This reduces time complexity to O(height) which is O(log n) for balanced trees. The key insight is that BST structure guides us directly to the answer, just like binary search on a sorted array.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Visit All Nodes)	O(n)	O(h)	Traverse entire tree and track the closest value found
Binary Search Tree Property (Optimal)	O(h)	O(1)	Leverage BST structure to efficiently navigate toward the closest value

Brute Force (Visit All Nodes) — Algorithm Steps

Initialize closest value as root's value and minimum difference
Traverse all nodes using DFS (any order)
For each node, calculate |node.val - target|
Update closest if difference is smaller, or if same difference but smaller value
Return the closest value after visiting all nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Initialize closest value with root's value

Visit All Nodes

Use DFS to visit every node in the tree

Calculate Distance

For each node, compute |node.val - target|

Update Closest

Update if distance is smaller or same distance but smaller value

Code -

solution.c — C

#include <stdlib.h>
#include <math.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int closest;
double minDiff;

void dfs(struct TreeNode* node, double target) {
    if (!node) return;
    
    double distance = fabs(node->val - target);
    
    if (distance < minDiff || (distance == minDiff && node->val < closest)) {
        closest = node->val;
        minDiff = distance;
    }
    
    dfs(node->left, target);
    dfs(node->right, target);
}

int closestValue(struct TreeNode* root, double target) {
    closest = root->val;
    minDiff = fabs(root->val - target);
    
    dfs(root, target);
    return closest;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must visit all n nodes in the tree to ensure we find the closest value

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, which can be O(n) in worst case

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
0 ≤ Node.val ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹
It's guaranteed that there will be only one unique value closest to the target

67.2K Views

High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Visit All Nodes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler