思路

减法思路吧
题目如果是找一个最近的数，那找到X在哪就好了。
但是X不一定在数组内，所以要对二分法改一点。

一般的二分法，就是返回找到后的索引，找不到就返回-1。
所以这里可以变成：找到了就返回索引，找不到就返回左右指针(就是x左边的数和x右边的数了)。

到这里，就找到X(或者X的邻居)了。
接下来用双指针扫描就好了：

1.两个指针L, R指向X的位置或者它的邻居
2.按照题目要求往左或者往右移动指针
3.结束条件就是左右指针差为K

总的来说，思路如上，不过玛德好多坑啊，可能是太菜了，好多边界条件，可能会有简化版本，欢迎讨论。

代码

public class FindKClosestElements {
	
	public int[] binarySearch(int[] arr, int l, int r, int x) {
		if(l==r) {
			return new int[] {l};
		}
				
		int m=l+(r-l)/2;
		
		if(x>arr[m]) {
			l=m+1;
			if(l>arr.length-1) {
				return new int[] {arr.length-1};
			}
			if(arr[l]>x) {
				return new int[] {l-1,l};
			}
		}else if(x<arr[m]) {
			r=m-1;
			if(r<0) {
				return new int[] {0};
			}
			if(arr[r]<x) {
				return new int[] {r,r+1};
			}
		}else {
			return new int[] {m};
		}
		int[] res=binarySearch(arr,l,r,x);
		return res;
	}
	
	 public List<Integer> findClosestElements(int[] arr, int k, int x) {
	        int[] nearest=binarySearch(arr, 0, arr.length-1, x);
	        int l=nearest[0];
	        int r=nearest[0];

	        if(nearest.length>=2) {
	        	if(arr[nearest[1]]-x<x-arr[nearest[0]]) {
	        		l=nearest[1];
	        		r=nearest[1];
	        	}
	        }
	        while(r-l<k-1&&!(l==0&&r==arr.length-1)) {
	        	if(l==0) {
	        		r++;
	        		continue;
	        	}
	        	if(r==arr.length-1) {
	        		l--;
	        		continue;
	        	}
	        	if(arr[r+1]-x<x-arr[l-1]) {
	        		r++;
	        		continue;
	        	}else {
	        		l--;
	        	}
	        }
	        
	        List<Integer> res=new ArrayList<Integer>();
	        for(int i=l;i<=r;i++) {
	        	res.add(arr[i]);
	        }
	        return res;
	        
	    }
	 
	 public static void main(String[] args) {
		int[] arr=new int[] {1,1,1,10,10,10};
		System.out.println(new FindKClosestElements().findClosestElements(arr, 1, 9));
	}
}