LC 658. 找到 K 个最接近的元素

题目描述

这是 LeetCode 上的 658. 找到 K 个最接近的元素 ，难度为 中等。

给定一个排序好的数组 arr，两个整数 k 和 x ，从数组中找到最靠近 x（两数之差最小）的 k 个数。

返回的结果必须要是按升序排好的。

整数 a 比整数 b 更接近 x 需要满足：

  • |a - x| < |b - x| 或者
  • |a - x| == |b - x| 且 a < b

示例 1：

1
2
3
输入：arr = [1,2,3,4,5], k = 4, x = 3

输出：[1,2,3,4]

示例 2：
1
2
3
输入：arr = [1,2,3,4,5], k = 4, x = -1

输出：[1,2,3,4]

提示：

  • $1 <= k <= arr.length$
  • $1 <= arr.length <= 10^4$
  • arr 按升序排列
  • $-10^4 <= arr[i], x <= 10^4$

二分 + 双指针

容易想到先通过「二分」找到与 x 差值最小的位置 idx，然后从 idx 开始使用「双指针」往两边进行拓展（初始化左端点 $i = idx - 1$，右端点 $j = idx + 1$），含义为 $[i + 1, j - 1]$ 范围内子数组为候选区间，不断根据两边界与 x 的差值关系进行扩充，直到候选区间包含 $k$ 个数。

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Solution {
    public List<Integer> findClosestElements(int[] arr, int k, int x) {
        int n = arr.length, l = 0, r = n - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (arr[mid] <= x) l = mid;
            else r = mid - 1;
        }
        r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r;
        int i = r - 1, j = r + 1;
        while (j - i - 1 < k) {
            if (i >= 0 && j < n) {
                if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++;
                else i--;
            } else if (i >= 0) {
                i--;
            } else {
                j++;
            }
        }
        List<Integer> ans = new ArrayList<>();
        for (int p = i + 1; p <= j - 1; p++) ans.add(arr[p]);
        return ans;
    }
}

C++ 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Solution {
public:
    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        int n = arr.size(), l = 0, r = n - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (arr[mid] <= x) l = mid;
            else r = mid - 1;
        }
        r = (r + 1 < n && abs(arr[r + 1] - x) < abs(arr[r] - x)) ? r + 1 : r;
        int i = r - 1, j = r + 1;
        while (j - i - 1 < k) {
            if (i >= 0 && j < n) {
                if (abs(arr[j] - x) < abs(arr[i] - x)) j++;
                else i--;
            } else if (i >= 0) {
                i--;
            } else {
                j++;
            }
        }
        vector<int> ans;
        for (int p = i + 1; p <= j - 1; p++) ans.push_back(arr[p]);
        return ans;
    }
};

Python 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        n = len(arr)
        l, r = 0, n - 1
        while l < r:
            mid = l + r + 1 >> 1
            if arr[mid] <= x: l = mid
            else: r = mid - 1
        r = r + 1 if r + 1 < n and abs(arr[r + 1] - x) < abs(arr[r] - x) else r
        i, j = r - 1, r + 1
        while j - i - 1 < k:
            if i >= 0 and j < n:
                if abs(arr[j] - x) < abs(arr[i] - x):
                    j += 1
                else:
                    i -= 1
            elif i >= 0:
                i -= 1
            else:
                j += 1
        return arr[i + 1:j]

TypeScript 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function findClosestElements(arr: number[], k: number, x: number): number[] {
    let n = arr.length, l = 0, r = n - 1
    while (l < r) {
        const mid = l + r + 1 >> 1
        if (arr[mid] <= x) l = mid
        else r = mid - 1
    }
    r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r
    let i = r - 1, j = r + 1
    while (j - i - 1 < k) {
        if (i >= 0 && j < n) {
            if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++
            else i--
        } else if (i >= 0) {
            i--
        } else {
            j++
        }
    }
    return arr.slice(i + 1, j);
};

  • 时间复杂度：查找分割点复杂度为 $O(\log{n})$；从分割点往两边拓展复杂度为 $O(k)$。整体复杂度为 $O(\log{n} + k)$
  • 空间复杂度：$O(1)$

最后

这是我们「刷穿 LeetCode」系列文章的第 No.658 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。