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

具体思想：

很典型的一道滑动窗口，二分题目；

1.固定滑动窗口：

如果采用固定滑动窗口，只需要在整体遍历中，记录区间内得最小值的下标即可；

2.二分思路：

（1）mid二分思路：

如果是二分则采用以下思路：
现在有序数组中寻找x元素，或者第一个大于x的元素；

此时，最优的区间必定会出现在x的附近，大区间的左右边界应为二分结果的左右k个；

之所以是左右k个，而不是左右K/2个，而是因为有可能二分结果位置的左右半边可能有一部分更紧凑；

之后只需要对比左右边界的元素，进行收紧，直至区间为k个即可；

但是注意一下，这种写法具体怎么操作取决于mid的值怎么寻找；

当x值不存在的时候，l会落在大于x的第一个元素上，此时就会产生问题；

例如，两个值2，4，寻找的值是x=3,且k=1，则l的值为4的index，此时按照选择则会选择4，而不是选择1；

所以与其纠结，还不如直接扩大搜索范围，即low和high的范围；

(2) 边界二分：

题解中有一种思路很值得借鉴，其实这道题可以转化为一个二次开口向上的离散点值，寻找最小的k个值；

此时对于非有序序列，可以直接寻找左边界，l=0,r=arr.size()-k;

但是不太能理解这个思路，先存疑；

具体代码：

固定滑动窗口：

class Solution {
public:
    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        if (arr.size() <= k)
            return arr;
        int l = 0, r = k-1;
        int sum = 0;
        int l1 = 0, r1 = k - 1;
        for (int i = 0; i < k; i++) {
            sum += abs(arr[i] - x);
        }
        for (int i = k; i < arr.size(); i++) {
            if (sum > sum + abs(arr[i] - x) - abs(arr[l] - x)) {
                //应该右移;
                sum = sum + abs(arr[i] - x) - abs(arr[l] - x);
                l++;
                r++;
                l1 = l;
                r1 = r;
            }
            else if (sum == sum + abs(arr[i] - x) - abs(arr[l] - x)) {
                l++;
                r++;
            }
            else
                break;
        }
        arr.assign(arr.begin() + l1, arr.begin() + r1 + 1);
        return arr;
    }
};

二分：

中间值二分查找：

class Solution {
public:
    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        if (arr.size() <= k)
            return arr;
        int l = 0, r = arr.size();
        while (l < r) {
            int mid = l + (r - l) / 2;
            if (arr[mid] == x) {
                l = mid;
                break;
            }
            else if (arr[mid] < x) {
                l = mid + 1;
            }
            else {
                r = mid - 1;
            }
        }
        int low = max(l - k , 0);
        int high = min(l + k , int(arr.size()-1));
        while (high - low > k - 1) {
            if (abs(arr[low] - x) > abs(arr[high] - x)) {
                low++;
            }
            else {
                high--;
            }
        }
        arr.assign(arr.begin() + low, arr.begin() + high + 1);
        return arr;
    }
};

左边界搜索：

class Solution{
public:
    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        int left = 0;
        int right = arr.size() - k;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (x - arr[mid] > arr[mid + k] - x) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }

        return vector<int>(arr.begin() + left, arr.begin() + left + k);
    }
};