Find K Closest Elements

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 closer to x than an integer b if:

|a - x| < |b - x|, or
|a - x| == |b - x| and a < b

Input & Output

Example 1 — 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,4]. Distances: |1-3|=2, |2-3|=1, |3-3|=0, |4-3|=1, |5-3|=2. Elements 2,3,4 have distances 1,0,1 respectively, and 1 has distance 2, so we take [1,2,3,4].

Example 2 — Target Not in Array

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

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

💡 Note: The 4 closest elements to -1 are the first 4 elements. Distances: |1-(-1)|=2, |2-(-1)|=3, |3-(-1)|=4, |4-(-1)|=5, |5-(-1)|=6. The smallest 4 distances correspond to elements [1,2,3,4].

Example 3 — Tie Breaking

$ Input: arr = [1,1,1,10,10,10], k = 1, x = 9

› Output: [10]

💡 Note: Both 1 and 10 have distance |1-9|=8 and |10-9|=1 respectively to x=9. Since |10-9|=1 < |1-9|=8, we choose 10.

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 35 f Facebook 28 M Microsoft 22

The key insight is to leverage the sorted property of the array. We can use binary search to find x's position in O(log n), then expand a window with two pointers to get the k closest elements in O(k) time. Best approach is Two Pointers with Binary Search: Time O(log n + k), Space O(1).

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Brute Force with Sorting

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

Create pairs of (distance, value) for each element, sort by distance (with tie-breaking), then extract the first k values.

Sliding Window Approach

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

Start with a window of size k, then slide it by comparing the distances of elements at both ends. Keep the window that minimizes the maximum distance to x.

Two Pointers with Binary Search

⏱️ Time: O(log n + k) Space: O(1)

Use binary search to find the insertion point of x, then use two pointers to expand left and right, always choosing the closer element until we have k elements.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* solution(int* arr, int arrSize, int k, int x, int* returnSize) {
    *returnSize = k;
    int n = arrSize;
    
    // Binary search to find insertion point
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] < x) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    // Now left is the insertion point
    // Initialize two pointers
    int l = left - 1, r = left;
    
    // Expand window to get k elements
    int* result = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        if (l < 0) {
            // Only right side available
            result[i] = arr[r];
            r++;
        } else if (r >= n) {
            // Only left side available
            result[i] = arr[l];
            l--;
        } else {
            // Compare distances
            int leftDist = abs_val(arr[l] - x);
            int rightDist = abs_val(arr[r] - x);
            if (leftDist < rightDist || (leftDist == rightDist && arr[l] < arr[r])) {
                result[i] = arr[l];
                l--;
            } else {
                result[i] = arr[r];
                r++;
            }
        }
    }
    
    qsort(result, k, sizeof(int), compare);
    return result;
}

static int arr[1000];
static int arrSize = 0;

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[arrSize++] = (int)strtol(p, &p, 10);
    }
    
    int k, x;
    scanf("%d", &k);
    scanf("%d", &x);
    
    int returnSize;
    int* result = solution(arr, arrSize, k, x, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

High Frequency

~25 min Avg. Time

3.2K 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