給一個目標數 target, 一個非負整數 k, 一個按照升序排列的陣列 A。在A中找與target最接近的k個整數。返回這k個數並按照與target的接近程度從小到大排序，如果接近程度相當，那麼小的數排在前面。

樣例

如果 A = [1, 2, 3], target = 2 and k = 3, 那麼返回 [2, 1, 3].

如果 A = [1, 4, 6, 8], target = 3 and k = 3, 那麼返回 [4, 1, 6].

挑戰

O(logn + k) 的時間複雜度

注意事項

1.k是一個非負整數，並且總是小於已排序陣列的長度。
2.給定陣列的長度是有意義的,不會超過10 ^ 4
3.組中元素的絕對值不會超過10 ^ 4

解題思路：

先二分搜尋出最接近target的左邊數當作左指標，然後由此+1生成一個右指標，左右指標分別向兩邊移動，通過比較兩邊大小來確定結果集中應該加入哪個數。

注意二分搜尋的while條件與left移動步數與常規做法略有區別，這是因為當左右兩邊的數距離target一樣遠時(例如25 35，target是30)，我們需要二分搜尋出左邊那位，就要while(left+1 < right)來提前一次終止迴圈，使left落在25，同時left = mid，不能=mid+1防止left錯過mid數。

public class Solution {
    /**
     * @param A: an integer array
     * @param target: An integer
     * @param k: An integer
     * @return: an integer array
     */
    public int[] kClosestNumbers(int[] A, int target, int k) {
        // write your code here
        if(A==null || A.length==0)
            return null;

        int l = binarySearch(A, target);
        int r = l + 1;
        
        int[] res = new int[k];
        int resNum = 0;
        
        for(int i=0; i<k; i++){
            if(isLeftColser(A, target, l, r)){
                res[i] = A[l--];
            }else
                res[i] = A[r++];
        }
       
        return res;
    }
    
    private boolean isLeftColser(int[] A, int target, int l, int r){
        if(l < 0)
            return false;
            
        if(r > A.length-1)
            return true;
            
        if(target-A[l] <= A[r]-target)
            return true;
        
        return false;
    }
    
    private int binarySearch(int[] A, int target){
        int l = 0;
        int r = A.length-1;
        
        while(l+1 < r){
            int mid = l + (r-l)/2;
            
            if(A[mid] == target)
                return mid;
            else if(A[mid] > target)
                r = mid;
            else
                l = mid;
        }
        
        return l;
    }
}