K-D Tree - Problem

Implement a K-D Tree for 2D points that supports efficient spatial queries. A K-D Tree (k-dimensional tree) is a binary tree used for organizing points in k-dimensional space.

Your implementation should support:

Construction: Build the tree from a list of 2D points
Nearest Neighbor Search: Find the closest point to a given query point
Range Query: Find all points within a rectangular region

For this problem, implement the nearest neighbor search functionality. Given a list of 2D points and a query point, return the point from the list that has the minimum Euclidean distance to the query point.

Input & Output

Example 1 — Basic Nearest Neighbor

$ Input: points = [[2,3],[5,4],[9,6],[4,7],[8,1],[7,2]], query = [5,5]

› Output: [5,4]

💡 Note: Calculate distances: (2,3)→3.6, (5,4)→1.0, (9,6)→4.1, (4,7)→2.2, (8,1)→5.7, (7,2)→3.6. Point (5,4) has minimum distance of 1.0

Example 2 — Query at Origin

$ Input: points = [[1,1],[3,3],[-1,-1],[2,-2]], query = [0,0]

› Output: [-1,-1]

💡 Note: Distances from origin: (1,1)→1.41, (3,3)→4.24, (-1,-1)→1.41, (2,-2)→2.83. Both (1,1) and (-1,-1) have same distance 1.41, return first found

Example 3 — Single Point

$ Input: points = [[10,20]], query = [15,25]

› Output: [10,20]

💡 Note: Only one point available, so (10,20) is the nearest neighbor by default with distance √((15-10)² + (25-20)²) = 7.07

Constraints

1 ≤ points.length ≤ 10⁴
points[i].length == 2
query.length == 2
-10⁴ ≤ points[i][j], query[j] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 A Apple 6

The K-D Tree efficiently organizes 2D points by alternating splits on x and y coordinates. For nearest neighbor search, the tree structure allows branch-and-bound pruning to eliminate large regions of space without checking every point. Best approach: Build K-D tree then search with pruning. Time: O(log n) average, Space: O(n)

Common Approaches

✓ Brute Force Linear Search

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

For each point in the list, calculate the Euclidean distance to the query point, keep track of the minimum distance and corresponding point.

K-D Tree Implementation

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

Construct a K-D tree by recursively splitting points alternating between x and y coordinates. For nearest neighbor search, traverse the tree using branch-and-bound pruning to avoid checking unnecessary subtrees.

Brute Force Linear Search — Algorithm Steps

Initialize minimum distance as infinity and closest point as null
Iterate through all points in the list
Calculate Euclidean distance from current point to query point
If distance is smaller than current minimum, update minimum and closest point
Return the closest point found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Query

Query point (5,5) needs closest neighbor

Check All Points

Calculate distance to each of 6 points

Find Minimum

Point (5,4) has smallest distance = 1.0

Code -

solution.c — C

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

int* solution(int points[][2], int pointsSize, int query[2]) {
    if (pointsSize == 0) return NULL;
    
    double minDist = DBL_MAX;
    int* closestPoint = (int*)malloc(2 * sizeof(int));
    
    for (int i = 0; i < pointsSize; i++) {
        // Calculate Euclidean distance
        double dist = sqrt(pow(points[i][0] - query[0], 2) + pow(points[i][1] - query[1], 2));
        if (dist < minDist) {
            minDist = dist;
            closestPoint[0] = points[i][0];
            closestPoint[1] = points[i][1];
        }
    }
    
    return closestPoint;
}

int main() {
    int points[6][2] = {{2,3}, {5,4}, {9,6}, {4,7}, {8,1}, {7,2}};
    int query[2] = {5, 5};
    
    int* result = solution(points, 6, query);
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must check distance to every point in the list

✓ Linear Growth

Space Complexity

O(1)

Only stores minimum distance and closest point variables

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

342 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

K-D Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler