refactor 324

fishercoder1534 · fishercoder1534 · commit a78bdac32507 · 2019-01-01T08:47:25.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_324.java b/src/main/java/com/fishercoder/solutions/_324.java
@@ -20,47 +20,47 @@ Can you do it in O(n) time and/or in-place with O(1) extra space?
  */
 public class _324 {
 
-    /**Credit: https://discuss.leetcode.com/topic/41464/step-by-step-explanation-of-index-mapping-in-java
-     * TODO: completely understand it.*/
-    public void wiggleSort(int[] nums) {
-        int median = findKthLargest(nums, (nums.length + 1) / 2);
-        int n = nums.length;
+    public static class Solution1 {
+        /** Credit: https://discuss.leetcode.com/topic/41464/step-by-step-explanation-of-index-mapping-in-java */
+        public void wiggleSort(int[] nums) {
+            int median = findKthLargest(nums, (nums.length + 1) / 2);
+            int n = nums.length;
 
-        int left = 0;
-        int i = 0;
-        int right = n - 1;
+            int left = 0;
+            int i = 0;
+            int right = n - 1;
 
-        while (i <= right) {
+            while (i <= right) {
 
-            if (nums[newIndex(i, n)] > median) {
-                swap(nums, newIndex(left++, n), newIndex(i++, n));
-            } else if (nums[newIndex(i, n)] < median) {
-                swap(nums, newIndex(right--, n), newIndex(i, n));
-            } else {
-                i++;
+                if (nums[newIndex(i, n)] > median) {
+                    swap(nums, newIndex(left++, n), newIndex(i++, n));
+                } else if (nums[newIndex(i, n)] < median) {
+                    swap(nums, newIndex(right--, n), newIndex(i, n));
+                } else {
+                    i++;
+                }
             }
         }
-    }
 
-    private int findKthLargest(int[] nums, int k) {
-        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
-        for (int i : nums) {
-            maxHeap.offer(i);
-        }
-        while (k-- > 1) {
-            maxHeap.poll();
+        private int findKthLargest(int[] nums, int k) {
+            PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
+            for (int i : nums) {
+                maxHeap.offer(i);
+            }
+            while (k-- > 1) {
+                maxHeap.poll();
+            }
+            return maxHeap.poll();
         }
-        return maxHeap.poll();
-    }
 
-    private void swap(int[] nums, int i, int j) {
-        int tmp = nums[i];
-        nums[i] = nums[j];
-        nums[j] = tmp;
-    }
+        private void swap(int[] nums, int i, int j) {
+            int tmp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = tmp;
+        }
 
-    private int newIndex(int index, int n) {
-        return (1 + 2 * index) % (n | 1);
+        private int newIndex(int index, int n) {
+            return (1 + 2 * index) % (n | 1);
+        }
     }
-
 }
