refactor 164

fishercoder1534 · fishercoder1534 · commit 2a885eab8857 · 2018-05-23T07:57:36.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_164.java b/src/main/java/com/fishercoder/solutions/_164.java
@@ -3,137 +3,52 @@
 import java.util.Arrays;
 
 /**
+ * 164. Maximum Gap
+ *
  * Given an unsorted array, find the maximum difference between the successive elements in its sorted form.
- * Try to solve it in linear time/space.
  * Return 0 if the array contains less than 2 elements.
- * You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.
+ *
+ * Example 1:
+ * Input: [3,6,9,1]
+ * Output: 3
+ * Explanation: The sorted form of the array is [1,3,6,9], either
+ *              (3,6) or (6,9) has the maximum difference 3.
+ *
+ * Example 2:
+ * Input: [10]
+ * Output: 0
+ * Explanation: The array contains less than 2 elements, therefore return 0.
+ *
+ * Note:
+ *  You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.
+ *  Try to solve it in linear time/space.
  */
 public class _164 {
-    //brute force
+  public static class Solution1 {
+    /** brute force solution */
     public int maximumGap(int[] nums) {
-        if (nums.length < 2) {
-            return 0;
-        }
-
-        Arrays.sort(nums);
-        int max = Integer.MIN_VALUE;
-        for (int i = 1; i < nums.length; ) {
-            while (i < nums.length && nums[i] == nums[i - 1]) {
-                i++;
-            }
-            if (i == nums.length) {
-                i--;
-                max = (nums[i] - nums[i - 1] > max) ? nums[i] - nums[i - 1] : max;
-                break;
-            } else {
-                max = (nums[i] - nums[i - 1] > max) ? nums[i] - nums[i - 1] : max;
-            }
-            if (nums[i] != nums[i - 1]) {
-                i++;
-            }
-        }
-        return max;
-    }
-
-
-    //http://www.programcreek.com/2014/03/leetcode-maximum-gap-java/
-    class Bucket {
-        int min = -1;
-        int max = -1;
-
-        public Bucket() {
-            this.min = -1;
-            this.max = -1;
-        }
-    }
-
-    //compute interval and multiply by interval to get the index
-    public int maximumGap_from_programcreek_1(int[] nums) {
-        if (nums == null || nums.length < 2) {
-            return 0;
-        }
-
-        int maxNum = nums[0];
-        int minNum = nums[0];
-        for (int i = 0; i < nums.length; i++) {
-            maxNum = Math.max(maxNum, nums[i]);
-            minNum = Math.min(minNum, nums[i]);
-        }
-
-        //initialize bucket array
-        Bucket[] buckets = new Bucket[nums.length + 1];
-        for (int i = 0; i < buckets.length; i++) {
-            buckets[i] = new Bucket();
-        }
-
-        double interval = (double) nums.length / (maxNum - minNum);
-        //distribute the array to different buckets
-        for (int i = 0; i < nums.length; i++) {
-            int index = (int) ((nums[i] - minNum) * interval);
-            if (buckets[index].min == -1) {
-                buckets[index].min = nums[i];
-                buckets[index].max = nums[i];
-            } else {
-                buckets[index].min = Math.min(nums[i], buckets[index].min);
-                buckets[index].max = Math.max(nums[i], buckets[index].max);
-            }
-        }
-
-        //scan through the bucket array to find the maximal gap
-        int result = 0;
-        int prev = buckets[0].max;
-        for (int i = 1; i < buckets.length; i++) {
-            if (buckets[i].min != -1) {
-                result = Math.max(result, buckets[i].min - prev);
-                prev = buckets[i].max;
-            }
-        }
-
-        return result;
-    }
-
-    //compute gap and divide by gap to get the index
-    public int maximumGap_from_programcreek_2(int[] nums) {
-        if (nums == null || nums.length < 2) {
-            return 0;
-        }
-
-        int maxNum = nums[0];
-        int minNum = nums[0];
-        for (int i = 0; i < nums.length; i++) {
-            maxNum = Math.max(maxNum, nums[i]);
-            minNum = Math.min(minNum, nums[i]);
-        }
-
-        //initialize bucket array
-        Bucket[] buckets = new Bucket[nums.length + 1];
-        for (int i = 0; i < buckets.length; i++) {
-            buckets[i] = new Bucket();
-        }
-
-        double gap = (double) (maxNum - minNum) / (nums.length - 1);
-        //distribute the array to different buckets
-        for (int i = 0; i < nums.length; i++) {
-            int index = (int) ((nums[i] - minNum) / gap);
-            if (buckets[index].min == -1) {
-                buckets[index].min = nums[i];
-                buckets[index].max = nums[i];
-            } else {
-                buckets[index].min = Math.min(nums[i], buckets[index].min);
-                buckets[index].max = Math.max(nums[i], buckets[index].max);
-            }
-        }
-
-        //scan through the bucket array to find the maximal gap
-        int result = 0;
-        int prev = buckets[0].max;
-        for (int i = 1; i < buckets.length; i++) {
-            if (buckets[i].min != -1) {
-                result = Math.max(result, buckets[i].min - prev);
-                prev = buckets[i].max;
-            }
-        }
-
-        return result;
+      if (nums.length < 2) {
+        return 0;
+      }
+
+      Arrays.sort(nums);
+      int max = Integer.MIN_VALUE;
+      for (int i = 1; i < nums.length; ) {
+        while (i < nums.length && nums[i] == nums[i - 1]) {
+          i++;
+        }
+        if (i == nums.length) {
+          i--;
+          max = (nums[i] - nums[i - 1] > max) ? nums[i] - nums[i - 1] : max;
+          break;
+        } else {
+          max = (nums[i] - nums[i - 1] > max) ? nums[i] - nums[i - 1] : max;
+        }
+        if (nums[i] != nums[i - 1]) {
+          i++;
+        }
+      }
+      return max;
     }
+  }
 }
diff --git a/src/test/java/com/fishercoder/_164Test.java b/src/test/java/com/fishercoder/_164Test.java
@@ -1,68 +1,35 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._164;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static junit.framework.Assert.assertEquals;
 
 public class _164Test {
-    private static _164 test;
-    private static int expected;
-    private static int actual;
-    private static int[] nums;
-
-    @BeforeClass
-    public static void setup() {
-        test = new _164();
-    }
-
-    @Before
-    public void setupForEachTest() {
-        expected = 0;
-        actual = 0;
-    }
-
-    @Test
-    public void test1() {
-        nums = new int[]{};
-        expected = 0;
-        actual = test.maximumGap(nums);
-        assertEquals(expected, actual);
-
-        actual = test.maximumGap_from_programcreek_1(nums);
-        assertEquals(expected, actual);
-
-        actual = test.maximumGap_from_programcreek_2(nums);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test2() {
-        nums = new int[]{1, 3, 6, 5};
-        expected = 2;
-        actual = test.maximumGap(nums);
-        assertEquals(expected, actual);
-
-        actual = test.maximumGap_from_programcreek_1(nums);
-        assertEquals(expected, actual);
-
-        actual = test.maximumGap_from_programcreek_2(nums);
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    public void test3() {
-        nums = new int[]{1, 100000};
-        expected = 99999;
-        actual = test.maximumGap(nums);
-        assertEquals(expected, actual);
-
-        actual = test.maximumGap_from_programcreek_1(nums);
-        assertEquals(expected, actual);
-
-        actual = test.maximumGap_from_programcreek_2(nums);
-        assertEquals(expected, actual);
-    }
+  private static _164.Solution1 solution1;
+  private static int[] nums;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _164.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    nums = new int[] {};
+    assertEquals(0, solution1.maximumGap(nums));
+  }
+
+  @Test
+  public void test2() {
+    nums = new int[] {1, 3, 6, 5};
+    assertEquals(2, solution1.maximumGap(nums));
+  }
+
+  @Test
+  public void test3() {
+    nums = new int[] {1, 100000};
+    assertEquals(99999, solution1.maximumGap(nums));
+  }
 }
