[N-0] refactor 540

Author: fishercoder1534

README.md

@@ -136,7 +136,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |542|[01 Matrix](https://leetcode.com/problems/01-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_542.java) | O(m*n) |O(n) | Medium | BFS
 |541|[Reverse String II](https://leetcode.com/problems/reverse-string-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_541.java) | O(n) |O(1) | Easy | String
 |540|[Single Element in a Sorted Array](https://leetcode.com/problems/single-element-in-a-sorted-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_540.java) | O(n) |O(1) | Medium | 
-|539|[Minimum Time Difference](https://leetcode.com/problems/minimum-time-difference/)|[Solution](../master/src/main/java/com/fishercoder/solutions/MinimumTimeDifference.java) | O(n) |O(1) | Medium | String
+|539|[Minimum Time Difference](https://leetcode.com/problems/minimum-time-difference/)|[Solution](../master/src/main/java/com/fishercoder/solutions/MinimumTimeDifference.java) | O(logn) |O(1) | Medium | String
 |538|[Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_538.java) | O(n) |O(h) | Easy | Tree
 |537|[Complex Number Multiplication](https://leetcode.com/problems/complex-number-multiplication/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_537.java) | O(1) |O(1) | Medium | Math, String
 |536|[Construct Binary Tree from String](https://leetcode.com/problems/construct-binary-tree-from-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_536.java) | O(n) |O(h) | Medium | Recursion, Stack

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

@@ -1,7 +1,11 @@
 package com.fishercoder.solutions;
 
 /**
- * Given a sorted array consisting of only integers where every element appears twice except for one element which appears once. Find this single element that appears only once.
+ * 540. Single Element in a Sorted Array
+ *
+ * Given a sorted array consisting of only integers where every
+ * element appears twice except for one element which appears once.
+ * Find this single element that appears only once.
 
  Example 1:
  Input: [1,1,2,3,3,4,4,8,8]
@@ -12,13 +16,33 @@
  Note: Your solution should run in O(log n) time and O(1) space.
  */
 public class _540 {
-//  TODO:  Could be optimized to O(logn) by using binary search
-    public int singleNonDuplicate(int[] nums) {
-        int result = 0;
-        for (int i = 0; i < nums.length; i++) {
-            result ^= nums[i];
+    public static class Solution1 {
+        public int singleNonDuplicate(int[] nums) {
+            int result = 0;
+            for (int i = 0; i < nums.length; i++) {
+                result ^= nums[i];
+            }
+            return result;
         }
-        return result;
     }
 
+    public static class Solution2 {
+        public int singleNonDuplicate(int[] nums) {
+            int start = 0;
+            int end = nums.length - 1;
+            while (start < end) {
+                int mid = start + (end - start) / 2;
+                if (nums[mid] != nums[mid + 1] && nums[mid] != nums[mid - 1]) {
+                    return nums[mid];
+                } else if (nums[mid] == nums[mid + 1] && mid % 2 == 0) {
+                    start = mid + 1;
+                } else if (nums[mid] == nums[mid - 1] && mid % 2 == 1) {
+                    start = mid + 1;
+                } else {
+                    end = mid - 1;
+                }
+            }
+            return nums[start];
+        }
+    }
 }

src/test/java/com/fishercoder/_540Test.java

@@ -1,51 +1,40 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._540;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static junit.framework.Assert.assertEquals;
 
 public class _540Test {
-    private static _540 test;
-    private static int expected;
-    private static int actual;
+    private static _540.Solution1 solution1;
+    private static _540.Solution2 solution2;
     private static int[] nums;
 
     @BeforeClass
     public static void setup() {
-        test = new _540();
-    }
-
-    @Before
-    public void setupForEachTest() {
-        expected = 0;
-        actual = 0;
-        nums = new int[1000];
+        solution1 = new _540.Solution1();
+        solution2 = new _540.Solution2();
     }
 
     @Test
     public void test1() {
         nums = new int[]{1, 1, 2, 3, 3, 4, 4, 8, 8};
-        expected = 2;
-        actual = test.singleNonDuplicate(nums);
-        assertEquals(expected, actual);
+        assertEquals(2, solution1.singleNonDuplicate(nums));
+        assertEquals(2, solution2.singleNonDuplicate(nums));
     }
 
     @Test
     public void test2() {
         nums = new int[]{3, 3, 7, 7, 10, 11, 11};
-        expected = 10;
-        actual = test.singleNonDuplicate(nums);
-        assertEquals(expected, actual);
+        assertEquals(10, solution1.singleNonDuplicate(nums));
+        assertEquals(10, solution2.singleNonDuplicate(nums));
     }
 
     @Test
     public void test3() {
         nums = new int[]{1, 1, 2};
-        expected = 2;
-        actual = test.singleNonDuplicate(nums);
-        assertEquals(expected, actual);
+        assertEquals(2, solution1.singleNonDuplicate(nums));
+        assertEquals(2, solution2.singleNonDuplicate(nums));
     }
 }