Find K Closest Elements - Practice Coding Problems

Find K Closest Elements - Problem

Array Two Pointers Binary Search Sliding Window Sorting Heap (Priority Queue) Medium

Given a sorted integer array arr, two integers k and x, return the k closest integers to x in the array. The result should also be sorted in ascending order.

An integer a is considered closer to x than integer b if:
• |a - x| < |b - x| (smaller absolute difference), or
• |a - x| == |b - x| and a < b (same distance but smaller value)

Example: For array [1,2,3,4,5], k=4, and x=3, the answer is [1,2,3,4] because these are the 4 numbers closest to 3.

Input & Output

example_1.py — Basic case

$ Input: arr = [1,2,3,4,5], k = 4, x = 3

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

💡 Note: The 4 closest elements to 3 are 1, 2, 3, and 4. Distance from 3: |1-3|=2, |2-3|=1, |3-3|=0, |4-3|=1, |5-3|=2. Taking the 4 smallest distances gives us [1,2,3,4].

example_2.py — Tie-breaking case

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

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

💡 Note: When x=-1, all elements are on the right side. Distances: |1-(-1)|=2, |2-(-1)|=3, |3-(-1)|=4, |4-(-1)|=5, |5-(-1)|=6. The 4 closest are still [1,2,3,4].

example_3.py — Single element

$ Input: arr = [1,2,3,4,5], k = 1, x = 3

› Output: [3]

💡 Note: When k=1, we only need the single closest element to x=3, which is 3 itself with distance 0.

Visualization

Tap to expand

Understanding the Visualization

Position Yourself

You stand at x=3 on the number line

Measure Distances

Calculate how far each friend is from your position

Find Optimal Window

Since friends are in a line, your k closest friends will be consecutive

Select the Group

Choose the contiguous group of k friends with minimal total distance

Key Takeaway

🎯 Key Insight: Since the array is sorted, the k closest elements always form a contiguous subarray, enabling O(log n) binary search instead of O(n log n) sorting!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with two pointers, O(n-k) iterations maximum

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for pointers

✓ Linear Space

Constraints

1 ≤ k ≤ arr.length
1 ≤ arr.length ≤ 10⁴
arr is sorted in ascending order
-10⁴ ≤ arr[i], x ≤ 10⁴

Asked in

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

The optimal approach uses binary search to find the best starting position for a k-element window, achieving O(log n + k) time complexity. Since the array is sorted, the k closest elements will always form a contiguous subarray, making this much more efficient than sorting all distances.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sliding Window)	O(n)	O(1)	Use sliding window approach to find optimal contiguous subarray of length k
Brute Force (Calculate All Distances)	O(n log n)	O(n)	Calculate distance for each element, sort by distance, and take first k elements
Binary Search (Optimal)	O(log n + k)	O(1)	Use binary search to find the optimal starting position for k-element window

Two Pointers (Sliding Window) — Algorithm Steps

Initialize left and right pointers with window size k
Compare distances of elements at window boundaries
Shrink window from the side with larger distance
Continue until window size equals k

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Start with full array as window

Compare Boundaries

Check distances at left and right boundaries

Shrink Window

Remove element with larger distance

Repeat Until k Elements

Continue until window has exactly k elements

Code -

solution.c — C

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

int* findClosestElements(int* arr, int arrSize, int k, int x, int* returnSize) {
    int left = 0;
    int right = arrSize - 1;
    
    // Shrink window to size k
    while (right - left >= k) {
        // Compare distances at boundaries
        int leftDist = abs(arr[left] - x);
        int rightDist = abs(arr[right] - x);
        
        if (leftDist > rightDist) {
            left++;
        } else {
            right--;
        }
    }
    
    // Return the k elements in the window
    int* result = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        result[i] = arr[left + i];
    }
    
    *returnSize = k;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with two pointers, O(n-k) iterations maximum

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for pointers

✓ Linear Space

Constraints

1 ≤ k ≤ arr.length
1 ≤ arr.length ≤ 10⁴
arr is sorted in ascending order
-10⁴ ≤ arr[i], x ≤ 10⁴

42.3K Views

High Frequency

~18 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 (Sliding Window) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler