「力扣」第 658 题：找到 K 个最接近的元素

功德无量
169 阅读8分钟

（这个方法建议直接看后面的手写分析，懂得思路了以后，自己拿纸和笔推导一下，就很清楚了，我写的比较啰嗦，可能看起来比较累，如果那里卡住了，再来找相应的地方检察一下，可能是这个题解比较合适的阅读方法。）

我们再分析一个 x 不在数组中的例子，例如：

数组 arr = [0, 1, 2, 3, 3, 4, 7, 7, 8]，k = 3，x = 5。数组中一共 9 个数，保留 3 个数，则需要删除 6 个数，这里 6 = len(arr) - k。

1、因为 5 - 0 > 8 - 5，所以将 0 删去； 2、因为 5 - 1 > 8 - 5，所以将 1 删去； 3、因为 5 - 2 = 8 - 5，根据题目意思，保留左边的 2 ，所以将 8 删去； 4、因为 5 - 2 > 7 - 5，所以将 2 删去； 5、因为 5 - 3 = 7 - 5，根据题目意思，保留左边的 3 ，所以将 7 删去； 6、因为 5 - 2 = 7 - 5，根据题目意思，保留左边的 3 ，所以将 7 删去；

已经删除了 6 个数，剩下的 [3, 3, 4] 就是最接近 5 的 3 个数。

参考代码 1：

import java.util.ArrayList;
import java.util.List;

public class Solution {

    public List<Integer> findClosestElements(int[] arr, int k, int x) {
        int size = arr.length;

        int left = 0;
        int right = size - 1;

        int removeNums = size - k;
        while (removeNums > 0) {
            if (x - arr[left] <= arr[right] - x) {
                right--;
            } else {
                left++;
            }
            removeNums--;
        }

        List<Integer> res = new ArrayList<>();
        for (int i = left; i < left + k; i++) {
            res.add(arr[i]);
        }
        return res;
    }
}

from typing import List


class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        # 排除法（双指针）
        size = len(arr)
        left = 0
        right = size - 1

        # 我们要排除掉 size - k 这么多元素
        remove_nums = size - k
        while remove_nums:
            # 调试语句
            # print(left, right, k)
            # 注意：这里等于号的含义，题目中说，差值相等的时候取小的
            # 因此相等的时候，尽量缩小右边界
            if x - arr[left] <= arr[right] - x:
                right -= 1
            else:
                left += 1
            remove_nums -= 1
        return arr[left:left + k]

复杂度分析：

  • 时间复杂度：O(N)，这里 N 是数组的长度。
  • 空间复杂度：O(1)，只使用了常数个额外的辅助空间。

题目中说有序数组，又易知：

1、题目要求返回的是区间，并且是连续区间；

2、区间长度是固定的，并且 k 的值为正数，且总是小于给定排序数组的长度，即 k 的值“不违规”；

因此，只要我们找到了左边界的索引，从左边界开始数 k 个数，返回就好了。我们把这件事情定义为“寻找最优区间”，“寻找最优区间”等价于“寻找最优区间的左边界”。因此本题使用二分查找法在有序数组中定位含有 k 个元素的连续子区间的左边界，即使用二分法找“最优区间的左边界”。

方法二：二分查找最优区间的左边界

（这个方法建议直接看后面的手写分析，懂得思路了以后，自己拿纸和笔推导一下，就很清楚了，我写的比较啰嗦，可能看起来比较累，如果那里卡住了，再来找相应的地方检察一下，可能是这个题解比较合适的阅读方法。）

由排除法，我们知道：

“排除法”的结论：（这个结论对于这道问题来说非常重要，可以说是解题的关键）

如果 x 的值就在长度为 size 区间内（不一定相等），要得到 size - 1 个符合题意的最接近的元素，此时看左右边界：

1、如果左边界与 x 的差值的绝对值较小，删除右边界；
2、如果右边界与 x 的差值的绝对值较小，删除左边界；
3、如果左、右边界与 x 的差值的绝对值相等，删除右边界。

讨论“最优区间的左边界”的取值范围：

首先我们讨论左区间的取值范围，使用具体的例子，就很很清楚地找到规律：

1、假设一共有 5 个数，[0, 1, 2, 3, 4]，找 3 个数，左边界最多到 2；

2、假设一共有 8 个数，[0, 1, 2, 3, 4, 5, 6, 7]，找 5 个数，左边界最多到 3。

因此，“最优区间的左边界”的索引的搜索区间为 [0, size - k]，注意，这个区间的左右都是闭区间，都能取到。

定位左区间的索引，有一点技巧性，但并不难理解。由排除法的结论，我们先从 [0, size - k] 这个区间的任意一个位置（用二分法就是当前候选区间的中位数）开始，定位一个长度为 (k + 1) 的区间，根据这个区间是否包含 x 开展讨论。

1、如果区间包含 x，我们尝试删除 1 个元素，好让区间发生移动，便于定位“最优区间的左边界”的索引；
2、如果区间不包含 x，就更简单了，我们尝试把区间进行移动，以试图包含 x，但也有可能区间移动不了（极端情况下）。

以下的讨论，对于记号 left、right 和 mid 说明如下：

1、left、right 是候选区间的左右边界的索引，根据上面的分析，初始时，left = 0，right = size - k；
2、而 mid 是候选区间的中位数的索引，它的取值可能是

mid = left + (right - left) // 2

也可能是

mid = left + (right - left + 1) // 2

之所以我们选择 mid = left + (right - left) // 2 ，请参考我在「力扣」第 35 题：“搜索插入位置”的题解中的叙述。

后面的文字可能会非常绕，在这里建议读者通读，前后来回看，不太清楚的地方先跳过，且不一定全看我的叙述，看明白一小段，在草稿纸上写写画画一点，卡壳了再看我的叙述，这样就不会太晕。

我们先从最简单的情况开始讨论：

1、如果区间不包含 x：

（1） 区间的右端点在 x 的左边，即 x 比 arr 中最大的元素还要大，因为要去掉 1 个元素，显然去掉左端点，因此“最优区间的左边界”的索引至少是 mid + 1，即 left = mid + 1，因为区间不可能再往左边走了，如图；

image.png

说明：极端情况是此时中位数位于索引 size - k，区间不能右移。

（2）区间的左端点在 x 的左边，即 x 比 arr 中最小的元素还要小，当前的区间左端点的索引至多是 mid，此时 right = mid，因为区间不可能再往右偏了，如图；

image.png

说明：极端情况是此时 mid 位于索引 0，区间不能左移。

2、如果区间包含 x，我们尝试删掉一个元素，以便让区间发生移动，缩小搜索范围：

易知，我们要比较长度为 k + 1 的区间的左右端点的数值与 x 的差值的绝对值。此时这个区间的左边界的索引是 mid，右边界的索引是 mid + k。根据“排除法”的结论，分类讨论如下：

（1）如果右边界与 x 的差值的绝对值较小，左边界收缩，可以肯定的是“最优区间的左边界”的索引 left 至少是 mid + 1，即 left = mid + 1，如图；

image.png

说明：“右边界与 x 的差值绝对值较小”同样适用于 1、（1）情况，因此它们二者可以合并；

（2）如果左边界与 x 的差值的绝对值较小，右边界收缩，此时区间不移动，注意：此时有可能收缩以后的区间就是待求的区间，也有可能整个区间向左移动，这件事情叫做，right = mid 不能排除 mid，如图；

image.png

说明1：这一点比较难想，但实际上也可以不想，根据 2、（1）的结论，左区间收缩的反面即是右区间不收缩，因此，这一分支的逻辑一定是 right = mid。

“实际上也可以不想”的具体原因，同样参考我在「力扣」第 35 题：“搜索插入位置”的题解《特别好用的二分查找法模板（Python 代码、Java 代码）》中的叙述。

说明2：“左边界与 x 的差的绝对值较小”同样适用于 1、（2）情况，因此它们二者可以合并。

（3）如果左、右边界与 x 的差的绝对值相等，删除右边界，结论同 2、（2），也有 right = mid，可以合并到 2、（2）。

以上看晕的朋友们，建议你在草稿纸上写写画画，思路就非常清晰了，并且写出的代码也很简洁。这个代码也不是我原创的，在网上搜了一下，刚开始的时候，一直不能理解下面这段代码的意思。

if x - arr[mid] > arr[mid + k] - x:
    left = mid + 1
else:
    right = mid

写个草稿就清楚多了，原来是并不困难，只是稍显复杂。

image.png

image.png

参考代码 2：

import java.util.ArrayList;
import java.util.List;

public class Solution {

    public List<Integer> findClosestElements(int[] arr, int k, int x) {
        int size = arr.length;

        int left = 0;
        int right = size - k;

        while (left < right) {
            // int mid = left + (right - left) / 2;
            int mid = (left + right) >>> 1;
            // 尝试从长度为 k + 1 的连续子区间删除一个元素
            // 从而定位左区间端点的边界值
            if (x - arr[mid] > arr[mid + k] - x) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }

        List<Integer> res = new ArrayList<>();
        for (int i = left; i < left + k; i++) {
            res.add(arr[i]);
        }
        return res;
    }
}

from typing import List


class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        size = len(arr)
        left = 0
        right = size - k

        while left < right:
            # mid = left + (right - left) // 2
            mid = (left + right) >> 1
            # 尝试从长度为 k + 1 的连续子区间删除一个元素
            # 从而定位左区间端点的边界值
            if x - arr[mid] > arr[mid + k] - x:
                left = mid + 1
            else:
                right = mid
        return arr[left:left + k]

复杂度分析：

  • 时间复杂度：O(\log N + K)，这里 N 是数组的长度，使用二分法的时间复杂度是对数级别的。感谢 @a-wen-u 朋友的指正。
  • 空间复杂度：O(1)，只使用了常数个额外的辅助空间。
avatar
文章
阅读
粉丝