refactor 480

fishercoder1534 · fishercoder1534 · commit 16f3398eff6d · 2019-05-07T09:12:30.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_480.java b/src/main/java/com/fishercoder/solutions/_480.java
@@ -35,69 +35,73 @@
  You may assume k is always valid, ie: 1 ≤ k ≤ input array's size for non-empty array.
  */
 public class _480 {
-
-    /**You cannot simply use minus sign '-' to denote the descending order, because e.g. 3 and -3 might both exist in this array,
-     * so we'll have to use the original numbers themselves to store in the heaps.*/
-    private PriorityQueue<Integer> minHeap = new PriorityQueue<>();
-    private PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
-
-    public double[] medianSlidingWindow(int[] nums, int k) {
-        int n = nums.length - k + 1;
-        if (n <= 0) {
-            return new double[0];
-        }
-        double[] result = new double[n];
-
-        for (int i = 0; i <= nums.length; i++) {
-            if (i >= k) {
-                result[i - k] = getMedian();
-                remove(nums[i - k]);
+    public static class Solution1 {
+
+        /**
+         * You cannot simply use minus sign '-' to denote the descending order, because e.g. 3 and -3 might both exist in this array,
+         * so we'll have to use the original numbers themselves to store in the heaps.
+         */
+        private PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        private PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
+
+        public double[] medianSlidingWindow(int[] nums, int k) {
+            int n = nums.length - k + 1;
+            if (n <= 0) {
+                return new double[0];
             }
-            if (i < nums.length) {
-                add(nums[i]);
+            double[] result = new double[n];
+
+            for (int i = 0; i <= nums.length; i++) {
+                if (i >= k) {
+                    result[i - k] = getMedian();
+                    remove(nums[i - k]);
+                }
+                if (i < nums.length) {
+                    add(nums[i]);
+                }
             }
-        }
 
-        return result;
-    }
-
-    private double getMedian() {
-        if (maxHeap.isEmpty() && minHeap.isEmpty()) {
-            return 0;
+            return result;
         }
 
-        if (maxHeap.size() == minHeap.size()) {
-            return ((double)maxHeap.peek() + (double)minHeap.peek()) / 2.0;
-        } else {
-            return (double)minHeap.peek();
-        }
-    }
+        private double getMedian() {
+            if (maxHeap.isEmpty() && minHeap.isEmpty()) {
+                return 0;
+            }
 
-    private void remove(int num) {
-        if (num < getMedian()) {
-            maxHeap.remove(num);
-        } else {
-            minHeap.remove(num);
-        }
-        if (maxHeap.size() > minHeap.size()) {
-            minHeap.add(maxHeap.poll());
-        }
-        if (minHeap.size() - maxHeap.size() > 1) {
-            maxHeap.add(minHeap.poll());
+            if (maxHeap.size() == minHeap.size()) {
+                return ((double) maxHeap.peek() + (double) minHeap.peek()) / 2.0;
+            } else {
+                return (double) minHeap.peek();
+            }
         }
-    }
 
-    private void add(int num) {
-        if (num < getMedian()) {
-            maxHeap.add(num);
-        } else {
-            minHeap.add(num);
-        }
-        if (maxHeap.size() > minHeap.size()) {
-            minHeap.add(maxHeap.poll());
+        private void remove(int num) {
+            if (num < getMedian()) {
+                maxHeap.remove(num);
+            } else {
+                minHeap.remove(num);
+            }
+            if (maxHeap.size() > minHeap.size()) {
+                minHeap.add(maxHeap.poll());
+            }
+            if (minHeap.size() - maxHeap.size() > 1) {
+                maxHeap.add(minHeap.poll());
+            }
         }
-        if (minHeap.size() - maxHeap.size() > 1) {
-            maxHeap.add(minHeap.poll());
+
+        private void add(int num) {
+            if (num < getMedian()) {
+                maxHeap.add(num);
+            } else {
+                minHeap.add(num);
+            }
+            if (maxHeap.size() > minHeap.size()) {
+                minHeap.add(maxHeap.poll());
+            }
+            if (minHeap.size() - maxHeap.size() > 1) {
+                maxHeap.add(minHeap.poll());
+            }
         }
     }
 
diff --git a/src/test/java/com/fishercoder/_480Test.java b/src/test/java/com/fishercoder/_480Test.java
@@ -10,21 +10,21 @@
  * Created by fishercoder on 5/27/17.
  */
 public class _480Test {
-    private static _480 test;
+    private static _480.Solution1 solution1;
     private static int[] nums;
     private static double[] expected;
     private static int k;
 
     @BeforeClass
     public static void setup() {
-        test = new _480();
+        solution1 = new _480.Solution1();
     }
 
     @Test
     public void test1() {
         nums = new int[]{1, 3, -1, -3, 5, 3, 6, 7};
         expected = new double[]{1, -1, -1, 3, 5, 6};
         k = 3;
-        assertArrayEquals(expected, test.medianSlidingWindow(nums, k), 0);
+        assertArrayEquals(expected, solution1.medianSlidingWindow(nums, k), 0);
     }
 }
