Closest Binary Search Tree Value II

Closest Binary Search Tree Value II - Problem

Two Pointers Stack Tree Depth-First Search Binary Search Tree Heap (Priority Queue) Binary Tree Hard

You're given the root of a binary search tree, a target value, and an integer k. Your task is to find the k values in the BST that are closest to the target.

Think of it as finding your k nearest neighbors in a sorted tree structure! The beauty of this problem lies in leveraging the BST's sorted property to efficiently locate the closest values without examining every single node.

Key Points:

You may return the answer in any order
You're guaranteed to have exactly one unique set of k closest values
"Closest" means smallest absolute difference: |node.val - target|

Example: If target=3.714286 and k=2 in BST [4,2,5,1,3], the two closest values are [4,3] since |4-3.714286|=0.285714 and |3-3.714286|=0.714286 are the smallest differences.

Input & Output

example_1.py — Basic Case

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

› Output: [4,3]

💡 Note: The node values in the BST are [1,2,3,4,5]. The distances to target 3.714286 are: |1-3.714286|=2.714286, |2-3.714286|=1.714286, |3-3.714286|=0.714286, |4-3.714286|=0.285714, |5-3.714286|=1.285714. The 2 closest values are 4 and 3.

example_2.py — Single Node

$ Input: root = [1], target = 0.000000, k = 1

› Output: [1]

💡 Note: There's only one node in the BST, so we return its value. Distance is |1-0|=1.

example_3.py — All Nodes Required

$ Input: root = [3,1,4,null,2], target = 2.5, k = 4

› Output: [2,3,1,4]

💡 Note: All nodes in the BST are [1,2,3,4]. Distances to target 2.5: |1-2.5|=1.5, |2-2.5|=0.5, |3-2.5|=0.5, |4-2.5|=1.5. Since k=4, we return all nodes. Note that 2 and 3 are equidistant, so either ordering is acceptable.

Constraints

The number of nodes in the tree is n where 1 ≤ n ≤ 10⁴
0 ≤ Node.val ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹
1 ≤ k ≤ n
It's guaranteed that there is only one unique set of k values in the BST that are closest to the target

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses inorder traversal to get a sorted array, then applies two pointers expanding from the insertion point to find the k closest values. This leverages the BST's sorted property for O(n) time complexity while maintaining clarity and efficiency.

Common Approaches

✓ Brute Force (Collect All + Sort)

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

The simplest approach: perform inorder traversal to collect all node values, calculate distances to target for each value, sort by distance, and return the first k values. This works but doesn't leverage the BST's sorted property.

Inorder + Sliding Window

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

This approach combines inorder traversal with a sliding window technique. We maintain a deque of size k representing the current k closest values. As we traverse, we add/remove values from both ends of the deque to maintain the k closest values efficiently.

Two Pointers on Inorder Array

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

This approach leverages the BST property by first performing an inorder traversal to get a sorted array. Then, we find the insertion point of the target and use two pointers expanding outward to collect the k closest values. This is more efficient than sorting by distance.

Brute Force (Collect All + Sort) — Algorithm Steps

Perform inorder traversal to collect all node values
Calculate absolute difference between each value and target
Sort values by their distance to target
Return the first k values from sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Inorder Traversal

Visit all nodes in sorted order and collect values

Calculate Distances

Compute |value - target| for each collected value

Sort by Distance

Sort all values by their distance to target

Take First K

Return the first k values from sorted list

Code -

solution.c — C

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

int isPrime(int n) {
    if (n < 2) return 0;
    if (n == 2) return 1;
    if (n % 2 == 0) return 0;
    for (int i = 3; i * i <= n; i += 2) {
        if (n % i == 0) return 0;
    }
    return 1;
}

void solution(int left, int right, int* result) {
    int* primes = (int*)malloc(10000 * sizeof(int));
    int count = 0;
    
    for (int num = left; num <= right; num++) {
        if (isPrime(num)) {
            primes[count++] = num;
        }
    }
    
    if (count < 2) {
        result[0] = -1;
        result[1] = -1;
        free(primes);
        return;
    }
    
    int minGap = INT_MAX;
    result[0] = -1;
    result[1] = -1;
    
    for (int i = 0; i < count - 1; i++) {
        for (int j = i + 1; j < count; j++) {
            int gap = primes[j] - primes[i];
            if (gap < minGap) {
                minGap = gap;
                result[0] = primes[i];
                result[1] = primes[j];
                break; // Since primes are sorted, first j with min gap will have smallest num1
            }
        }
    }
    
    free(primes);
}

int main() {
    int left, right;
    scanf("%d", &left);
    scanf("%d", &right);
    
    int result[2];
    solution(left, right, result);
    
    printf("[%d,%d]\n", result[0], result[1]);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for traversal + O(n log n) for sorting

✓ Linear Growth

Space Complexity

O(n)

O(n) to store all node values in array

⚡ Linearithmic Space

67.9K Views

High Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Collect All + Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler