refactor 162

Author: fishercoder1534

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

@@ -2,71 +2,83 @@
 
 /**
  * 162. Find Peak Element
- *
- * A peak element is an element that is greater than its neighbors.
- Given an input array where num[i] ≠ num[i+1], find a peak element and return its index.
+
+ A peak element is an element that is greater than its neighbors.
+
+ Given an input array nums, where nums[i] ≠ nums[i+1], find a peak element and return its index.
+
  The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.
- You may imagine that num[-1] = num[n] = -∞.
- For example, in array [1, 2, 3, 1], 3 is a peak element and your function should return the index number 2.*/
+
+ You may imagine that nums[-1] = nums[n] = -∞.
+
+ Example 1:
+ Input: nums = [1,2,3,1]
+ Output: 2
+ Explanation: 3 is a peak element and your function should return the index number 2.
+
+ Example 2:
+ Input: nums = [1,2,1,3,5,6,4]
+ Output: 1 or 5
+ Explanation: Your function can return either index number 1 where the peak element is 2,
+ or index number 5 where the peak element is 6.
+
+ Note:
+ Your solution should be in logarithmic complexity.
+ */
 
 public class _162 {
 
+  public static class Solution1 {
     /**
-     * On discuss, this post has very good explanation about an O(logn) solution:
-     * https://discuss.leetcode.com/topic/29329/java-solution-and-explanation-using-invariants
-     * 
+     * credit: https://discuss.leetcode.com/topic/29329/java-solution-and-explanation-using-invariants
+     *
      * Basically, we need to keep this invariant:
      * nums[left] > nums[left-1], then we could return left as the result
      * or nums[right] > nums[right+1], then we could return right as the result
+     *
+     * Time: O(Ologn)
      */
-    public static int findPeakElement_Ologn(int[] nums) {
-
-        if (nums == null || nums.length == 0) {
-            return 0;
-        }
-        int left = 0;
-        int right = nums.length - 1;
-        while (left + 1 < right) {
-            int mid = left + (right - left) / 2;
-            if (nums[mid] < nums[mid + 1]) {
-                left = mid;
-            } else {
-                right = mid;
-            }
+    public int findPeakElement(int[] nums) {
+      if (nums == null || nums.length == 0) {
+        return 0;
+      }
+      int left = 0;
+      int right = nums.length - 1;
+      while (left + 1 < right) {
+        int mid = left + (right - left) / 2;
+        if (nums[mid] < nums[mid + 1]) {
+          left = mid;
+        } else {
+          right = mid;
         }
-        return (left == nums.length - 1 || nums[left] > nums[left + 1]) ? left : right;
-
-    }
-
-    public static void main(String... strings) {
-//        int[] nums = new int[]{1,2};
-//        int[] nums = new int[]{1};
-        int[] nums = new int[]{1, 2, 3, 1};
-//        System.out.println(findPeakElement(nums));
-        System.out.println(findPeakElement_Ologn(nums));
+      }
+      return (left == nums.length - 1 || nums[left] > nums[left + 1]) ? left : right;
     }
+  }
 
+  public static class Solution2 {
     /**
      * My original O(n) solution.
      */
-    public static int findPeakElement(int[] nums) {
-        if (nums == null || nums.length == 0) {
-            return 0;
-        }
-        int n = nums.length;
-        int result = 0;
-        for (int i = 0; i < n; i++) {
-            if (i == 0 && n > 1 && nums[i] > nums[i + 1]) {
-                result = i;
-                break;
-            } else if (i == n - 1 && i > 0 && nums[i] > nums[i - 1]) {
-                result = i;
-                break;
-            } else if (i > 0 && i < n - 1 && nums[i] > nums[i - 1] && nums[i] > nums[i + 1]) {
-                result = i;
-                break;
-            }
+    public int findPeakElement(int[] nums) {
+      if (nums == null || nums.length == 0) {
+        return 0;
+      }
+      int n = nums.length;
+      int result = 0;
+      for (int i = 0; i < n; i++) {
+        if (i == 0 && n > 1 && nums[i] > nums[i + 1]) {
+          result = i;
+          break;
+        } else if (i == n - 1 && i > 0 && nums[i] > nums[i - 1]) {
+          result = i;
+          break;
+        } else if (i > 0 && i < n - 1 && nums[i] > nums[i - 1] && nums[i] > nums[i + 1]) {
+          result = i;
+          break;
         }
-        return result;
+      }
+      return result;
     }
+  }
 }

src/test/java/com/fishercoder/_162Test.java

@@ -0,0 +1,40 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._162;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _162Test {
+  private static _162.Solution1 solution1;
+  private static _162.Solution2 solution2;
+  private static int[] nums;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _162.Solution1();
+    solution2 = new _162.Solution2();
+  }
+
+  @Test
+  public void test1() {
+    nums = new int[] {1, 2};
+    assertEquals(1, solution1.findPeakElement(nums));
+    assertEquals(1, solution2.findPeakElement(nums));
+  }
+
+  @Test
+  public void test2() {
+    nums = new int[] {1};
+    assertEquals(0, solution1.findPeakElement(nums));
+    assertEquals(0, solution2.findPeakElement(nums));
+  }
+
+  @Test
+  public void test3() {
+    nums = new int[] {1, 2, 3, 1};
+    assertEquals(2, solution1.findPeakElement(nums));
+    assertEquals(2, solution2.findPeakElement(nums));
+  }
+}