K Closest Points to Origin - Practice Coding Problems

K Closest Points to Origin - Problem

Array Math Divide and Conquer Geometry Sorting Heap (Priority Queue) Quickselect Medium

K Closest Points to Origin

Imagine you're a drone operator standing at the center of a coordinate system (origin at (0, 0)). You have a list of points scattered across the 2D plane, and you need to identify the K closest points to your position.

Given an array points where points[i] = [xi, yi] represents a point on the X-Y plane and an integer k, return the k closest points to the origin.

The distance is calculated using the Euclidean distance formula: √((x₁ - x₂)² + (y₁ - y₂)²). Since we're measuring from the origin (0, 0), this simplifies to √(x² + y²).

Note: You may return the answer in any order. The answer is guaranteed to be unique (except for the order).

Example: If points = [[1,1],[2,2],[3,3]] and k = 2, return [[1,1],[2,2]] since these are the 2 closest points to origin.

Input & Output

example_1.py — Basic Case

$ Input: points = [[1,1],[2,2],[3,3]], k = 2

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

💡 Note: The distances from origin are: [1,1]→√2≈1.41, [2,2]→√8≈2.83, [3,3]→√18≈4.24. The 2 closest points are [1,1] and [2,2].

example_2.py — Mixed Quadrants

$ Input: points = [[3,3],[5,-1],[-2,4]], k = 2

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

💡 Note: Distances: [3,3]→√18≈4.24, [5,-1]→√26≈5.10, [-2,4]→√20≈4.47. The 2 closest are [-2,4] and [3,3]. Order doesn't matter in result.

example_3.py — All Points

$ Input: points = [[0,1],[1,0]], k = 2

› Output: [[0,1],[1,0]]

💡 Note: Both points have the same distance √1=1 from origin. Since k=2 and we have exactly 2 points, return both. This shows the edge case where k equals the number of points.

Visualization

Tap to expand

Understanding the Visualization

Monitor Aircraft Positions

Each aircraft reports its position [x,y]. Calculate distance using d² = x² + y² (skip square root for efficiency).

Maintain Priority List

Keep a priority list of K aircraft. Use max-heap so the farthest aircraft in your priority list is always on top.

Update Priority Dynamically

When a new aircraft appears, if it's closer than your current farthest priority aircraft, replace the farthest one.

Emergency Landing Clearance

Your final priority list contains the K closest aircraft ready for emergency landing clearance.

Key Takeaway

🎯 Key Insight: Max-heap keeps the "worst" of our K best candidates at the top, making it extremely efficient to decide whether to include new candidates or not!

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

We process n points, and for each point we may do a heap operation (insert/replace) that takes O(log k) time since heap size is at most k.

⚡ Linearithmic

Space Complexity

O(k)

We only store at most k points in the heap at any time, plus O(k) for the result array.

✓ Linear Space

Constraints

1 ≤ k ≤ points.length ≤ 10⁴
-10⁴ ≤ x_i, y_i ≤ 10⁴
The answer is guaranteed to be unique (except for the order that it is in)

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22 Apple 18 U Uber 15

The optimal approach uses a max-heap of size K to efficiently track the closest points. Instead of sorting all n points (O(n log n)), we maintain only k points in memory and achieve O(n log k) time complexity. The key insight is using a max-heap so the farthest of our k closest points is always at the top, making it easy to replace when we find a closer point.

Common Approaches

Approach	Time	Space	Notes
✓ Max-Heap of Size K (Optimal)	O(n log k)	O(k)	Maintain a max-heap of size K to track only the closest points
Min-Heap Approach	O(n + k log n)	O(n)	Use a min-heap to efficiently find K smallest distances

Max-Heap of Size K (Optimal) — Algorithm Steps

Initialize an empty max-heap (priority on distance)
For each point, calculate its squared distance
If heap size < K, add the point to heap
If heap size = K and current point is closer than heap top, replace heap top
Return all points from the heap

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Points One by One

For each point, calculate distance and decide if it belongs in our K closest

Maintain Heap Size K

If heap not full, add point. If full and current point closer than max, replace max

Extract Result

All points remaining in heap are the K closest points

Code -

solution.c — C

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

typedef struct {
    int dist;
    int x, y;
} PointDist;

// Max-heap implementation
void heapifyDown(PointDist heap[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < n && heap[left].dist > heap[largest].dist)
        largest = left;
    if (right < n && heap[right].dist > heap[largest].dist)
        largest = right;
    
    if (largest != i) {
        PointDist temp = heap[i];
        heap[i] = heap[largest];
        heap[largest] = temp;
        heapifyDown(heap, n, largest);
    }
}

void heapifyUp(PointDist heap[], int i) {
    int parent = (i - 1) / 2;
    if (parent >= 0 && heap[parent].dist < heap[i].dist) {
        PointDist temp = heap[i];
        heap[i] = heap[parent];
        heap[parent] = temp;
        heapifyUp(heap, parent);
    }
}

int** kClosest(int** points, int pointsSize, int* pointsColSize, int k, int* returnSize, int** returnColumnSizes) {
    PointDist *heap = (PointDist *)malloc(k * sizeof(PointDist));
    int heapSize = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        int x = points[i][0], y = points[i][1];
        int distSq = x * x + y * y;
        
        if (heapSize < k) {
            heap[heapSize].dist = distSq;
            heap[heapSize].x = x;
            heap[heapSize].y = y;
            heapifyUp(heap, heapSize);
            heapSize++;
        } else if (heap[0].dist > distSq) {
            heap[0].dist = distSq;
            heap[0].x = x;
            heap[0].y = y;
            heapifyDown(heap, heapSize, 0);
        }
    }
    
    // Prepare result
    int **result = (int **)malloc(k * sizeof(int *));
    *returnColumnSizes = (int *)malloc(k * sizeof(int));
    *returnSize = k;
    
    for (int i = 0; i < k; i++) {
        result[i] = (int *)malloc(2 * sizeof(int));
        result[i][0] = heap[i].x;
        result[i][1] = heap[i].y;
        (*returnColumnSizes)[i] = 2;
    }
    
    free(heap);
    return result;
}

int main() {
    int points[][2] = {{1,1},{2,2},{3,3}};
    int *pointsArray[3];
    for (int i = 0; i < 3; i++) {
        pointsArray[i] = points[i];
    }
    
    int k = 2;
    int returnSize, *returnColumnSizes;
    int **result = kClosest(pointsArray, 3, NULL, k, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

We process n points, and for each point we may do a heap operation (insert/replace) that takes O(log k) time since heap size is at most k.

⚡ Linearithmic

Space Complexity

O(k)

We only store at most k points in the heap at any time, plus O(k) for the result array.

✓ Linear Space

Constraints

1 ≤ k ≤ points.length ≤ 10⁴
-10⁴ ≤ x_i, y_i ≤ 10⁴
The answer is guaranteed to be unique (except for the order that it is in)

89.7K Views

High Frequency

~15 min Avg. Time

2.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

Max-Heap of Size K (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler