Closest Binary Search Tree Value II - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Inorder Traversal

Walk through the BST in sorted order to get [1, 2, 3, 4, 5]

Find Insertion Point

Locate where target 3.714 would fit: between 3 and 4

Expand with Two Pointers

Compare distances: |4-3.714|=0.286 vs |3-3.714|=0.714

Collect K Closest

Choose the k=2 values with smallest distances: [4, 3]

Key Takeaway

🎯 Key Insight: Use the BST's sorted property via inorder traversal, then apply two pointers from the insertion point to efficiently find the k closest values in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for inorder traversal + O(log n) for binary search + O(k) for two pointers

✓ Linear Growth

Space Complexity

O(n)

O(n) to store all values in array

⚡ Linearithmic Space

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

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

Approach	Time	Space	Notes
✓ Two Pointers on Inorder Array	O(n)	O(n)	Get sorted array via inorder traversal, then use two pointers to find k closest
Inorder + Sliding Window	O(n)	O(n)	Use inorder traversal with sliding window to maintain k closest values
Brute Force (Collect All + Sort)	O(n log n)	O(n)	Collect all values, sort by distance, take first k

Two Pointers on Inorder Array — Algorithm Steps

Perform inorder traversal to get sorted array of all values
Find the insertion point of target using binary search
Initialize two pointers around the insertion point
Expand pointers outward, choosing closer values until we have k elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Inorder Traversal

Get sorted array: [1, 2, 3, 4, 5]

Find Insertion Point

Binary search for target 3.714 → index 4

Initialize Pointers

i=3 (value 4), j=4 (value 5)

Expand Outward

Compare distances and choose closer values

Code -

solution.c — C

int* closestKValues(struct TreeNode* root, double target, int k, int* returnSize) {
    int* values = malloc(1000 * sizeof(int));
    int size = 0;
    inorder(root, values, &size);
    
    // Find insertion point using binary search
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (values[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    // Initialize two pointers around insertion point
    int i = left - 1, j = left;
    int* result = malloc(k * sizeof(int));
    int idx = 0;
    
    // Expand outward to find k closest values
    for (int count = 0; count < k; count++) {
        if (i >= 0 && (j >= size || target - values[i] <= values[j] - target)) {
            result[idx++] = values[i];
            i--;
        } else {
            result[idx++] = values[j];
            j++;
        }
    }
    
    *returnSize = k;
    free(values);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for inorder traversal + O(log n) for binary search + O(k) for two pointers

✓ Linear Growth

Space Complexity

O(n)

O(n) to store all values in array

⚡ Linearithmic Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers on Inorder Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler