Closest Binary Search Tree Value

Closest Binary Search Tree Value - Problem

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

If there are multiple values with the same minimum difference, return the smallest value.

Example:

For BST [4,2,5,1,3] and target 3.714286, the closest value is 4.

Input & Output

Example 1 — Basic BST

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

› Output: 4

💡 Note: The differences are: |4-3.714286|=0.286, |2-3.714286|=1.714, |5-3.714286|=1.286, |1-3.714286|=2.714, |3-3.714286|=0.714. The closest value is 4.

Example 2 — Exact Match

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

› Output: 2

💡 Note: Target 2.0 exactly matches node value 2, so return 2.

Example 3 — Tie Breaker

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

› Output: 1

💡 Note: |1-2|=1 and |3-2|=1. Both have same distance, return smaller value 1.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
0 ≤ Node.val ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is to leverage the BST property for efficient navigation. Instead of visiting all nodes, we can navigate directly towards the target while tracking the closest value. The optimal approach uses iterative BST traversal in O(h) time and O(1) space.

Common Approaches

✓ Binary Search Tree Navigation

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

Leverage the BST property where left subtree has smaller values and right subtree has larger values. Navigate towards the target while keeping track of the closest value seen so far.

Brute Force - Traverse All Nodes

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

Use any tree traversal (inorder, preorder, or postorder) to visit all nodes. For each node, calculate the absolute difference with the target and keep track of the closest value seen so far.

Binary Search Tree Navigation — Algorithm Steps

Step 1: Start from root, initialize closest value
Step 2: Compare current node with target
Step 3: Go left if target < node.val, right if target > node.val
Step 4: Update closest if current node is closer

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Compare 4 with target 3.714, update closest = 4

Navigate Left

Since 3.714 < 4, go left to node 2

Navigate Right

Since 3.714 > 2, go right to node 3, closest remains 4

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.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;
}

struct TreeNode* buildTree(int* arr, int size, int index) {
    if (index >= size || arr[index] == -1) {
        return NULL;
    }
    
    struct TreeNode* node = createNode(arr[index]);
    node->left = buildTree(arr, size, 2 * index + 1);
    node->right = buildTree(arr, size, 2 * index + 2);
    return node;
}

int solution(struct TreeNode* root, double target) {
    int closest = root->val;
    
    while (root) {
        // Update closest if current node is closer
        double currentDiff = fabs(root->val - target);
        double closestDiff = fabs(closest - target);
        
        if (currentDiff < closestDiff || 
           (currentDiff == closestDiff && root->val < closest)) {
            closest = root->val;
        }
        
        // Navigate based on BST property
        if (target < root->val) {
            root = root->left;
        } else if (target > root->val) {
            root = root->right;
        } else {
            break;  // Exact match found
        }
    }
    
    return closest;
}

int parseArray(char* line, int* arr) {
    int size = 0;
    char* ptr = line;
    
    // Skip opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr) {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',' || *ptr == '\t') ptr++;
        
        if (*ptr == ']' || *ptr == '\0') break;
        
        // Check for null
        if (strncmp(ptr, "null", 4) == 0) {
            arr[size++] = -1;
            ptr += 4;
        } else {
            // Parse number
            char* end;
            int val = strtol(ptr, &end, 10);
            if (ptr != end) {
                arr[size++] = val;
                ptr = end;
            } else {
                ptr++;
            }
        }
    }
    
    return size;
}

int main() {
    char line1[1000];
    char line2[1000];
    
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    // Parse array
    int arr[1000];
    int size = parseArray(line1, arr);
    
    // Parse target
    double target = atof(line2);
    
    // Build tree
    struct TreeNode* root = buildTree(arr, size, 0);
    
    // Find closest value
    int result = solution(root, target);
    
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(h)

Visit nodes along one path from root to leaf, h is tree height

✓ Linear Growth

Space Complexity

O(1)

Only use constant extra space for variables

✓ Linear Space

58.2K Views

Medium Frequency

~15 min Avg. Time

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

Binary Search Tree Navigation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler