add 658

Author: fishercoder1534

README.md

@@ -23,6 +23,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
 |659|[Split Array into Consecutive Subsequences](https://leetcode.com/problems/split-array-into-consecutive-subsequences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_659.java) | O(n) | O(n) | Medium | HashMap
+|658|[Find K Closest Elements](https://leetcode.com/problems/find-k-closest-elements/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_658.java) | O(n) | O(1) | Medium |
 |657|[Judge Route Circle](https://leetcode.com/problems/judge-route-circle/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_657.java) | O(n) | O(1) | Easy | 
 |654|[Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_654.java) | O(n^2) | O(n) | Medium | Tree
 |653|[Two Sum IV - Input is a BST](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_653.java) |  |  | Easy | Tree

src/main/java/com/fishercoder/solutions/_658.java

@@ -0,0 +1,72 @@
+package com.fishercoder.solutions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 658. Find K Closest Elements
+ *
+ * Given a sorted array, two integers k and x,
+ * find the k closest elements to x in the array.
+ * The result should also be sorted in ascending order.
+ * If there is a tie, the smaller elements are always preferred.
+
+ Example 1:
+ Input: [1,2,3,4,5], k=4, x=3
+ Output: [1,2,3,4]
+
+ Example 2:
+ Input: [1,2,3,4,5], k=4, x=-1
+ Output: [1,2,3,4]
+
+ Note:
+ The value k is positive and will always be smaller than the length of the sorted array.
+ Length of the given array is positive and will not exceed 104
+ Absolute value of elements in the array and x will not exceed 104
+ */
+public class _658 {
+    public List<Integer> findClosestElements(List<Integer> arr, int k, int x) {
+        List<Integer> result = new ArrayList<>();
+        int index = findInsertPosition(arr, x);
+        int right = 0;
+        if (arr.get(index) == x) {
+            result.add(arr.get(index));
+            right = index + 1;
+            k--;
+        } else {
+            right = index;
+        }
+        int left = index - 1;
+        while (k-- > 0) {
+            if (left >= 0 && right < arr.size()) {
+                if (x - arr.get(left) <= arr.get(right) - x) {
+                    result.add(0, arr.get(left--));
+                } else {
+                    result.add(result.size(), arr.get(right++));
+                }
+            } else if (left >= 0) {
+                result.add(0, arr.get(left--));
+            } else if (right < arr.size()) {
+                result.add(result.size(), arr.get(right++));
+            }
+        }
+        return result;
+    }
+
+    private int findInsertPosition(List<Integer> arr, int x) {
+        if (arr == null || arr.size() == 0) return 0;
+        int len = arr.size();
+        for (int i = 0; i < len; i++) {
+            if (arr.get(0) > x) {
+                return 0;
+            } else if (arr.get(len-1) < x) {
+                return len;
+            } else if (arr.get(i) < x && arr.get(i+1) > x) {
+                return i+1;
+            } else if (arr.get(i) == x) {
+                return i;
+            }
+        }
+        return len;
+    }
+}

src/test/java/com/fishercoder/_658Test.java

@@ -0,0 +1,51 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._658;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+
+public class _658Test {
+    private static _658 test;
+    private static List<Integer> arr;
+    private static List<Integer> expected;
+    private static int k;
+    private static int x;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _658();
+    }
+
+    @Test
+    public void test1(){
+        k = 4;
+        x = 3;
+        expected = new ArrayList<>(Arrays.asList(1,2,3,4));
+        arr = new ArrayList<>(Arrays.asList(1,2,3,4,5));
+        assertEquals(expected, test.findClosestElements(arr, k, x));
+    }
+
+    @Test
+    public void test2(){
+        k = 4;
+        x = -1;
+        expected = new ArrayList<>(Arrays.asList(1,2,3,4));
+        arr = new ArrayList<>(Arrays.asList(1,2,3,4,5));
+        assertEquals(expected, test.findClosestElements(arr, k, x));
+    }
+
+    @Test
+    public void test3(){
+        k = 3;
+        x = 5;
+        arr = new ArrayList<>(Arrays.asList(0,0,1,2,3,3,4,7,7,8));
+        expected = new ArrayList<>(Arrays.asList(3,3,4));
+        assertEquals(expected, test.findClosestElements(arr, k, x));
+    }
+}