refactor 581

fishercoder1534 · fishercoder1534 · commit c3b120c13500 · 2019-07-14T07:43:14.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_581.java b/src/main/java/com/fishercoder/solutions/_581.java
@@ -21,47 +21,53 @@
  */
 public class _581 {
 
-    /**credit: https://discuss.leetcode.com/topic/89282/java-o-n-time-o-1-space
-     * Use start and end to keep track of the minimum subarray nums[start...end] which must be sorted for the entire array nums.
-     * If start < end < 0 at the end of the for loop, then the array is already fully sorted.
-     *
-     * Time: O(n)
-     * Space: O(1)*/
-    public int findUnsortedSubarray(int[] nums) {
-        int n = nums.length;
-        int start = -1;
-        int end = -2;
-        int min = nums[n - 1];
-        int max = nums[0];
-        for (int i = 1; i < n; i++) {
-            max = Math.max(max, nums[i]);
-            min = Math.min(min, nums[n - 1 - i]);
-            if (nums[i] < max) {
-                end = i;
-            }
-            if (nums[n - 1 - i] > min) {
-                start = n - 1 - i;
+    public static class Solution1 {
+        /**
+         * credit: https://discuss.leetcode.com/topic/89282/java-o-n-time-o-1-space
+         * Use start and end to keep track of the minimum subarray nums[start...end] which must be sorted for the entire array nums.
+         * If start < end < 0 at the end of the for loop, then the array is already fully sorted.
+         *
+         * Time: O(n)
+         * Space: O(1)
+         */
+        public int findUnsortedSubarray(int[] nums) {
+            int n = nums.length;
+            int start = -1;
+            int end = -2;
+            int min = nums[n - 1];
+            int max = nums[0];
+            for (int i = 1; i < n; i++) {
+                max = Math.max(max, nums[i]);
+                min = Math.min(min, nums[n - 1 - i]);
+                if (nums[i] < max) {
+                    end = i;
+                }
+                if (nums[n - 1 - i] > min) {
+                    start = n - 1 - i;
+                }
             }
+            return end - start + 1;
         }
-        return end - start + 1;
     }
 
-    /**
-     * Time: O(nlogn)
-     * Space: O(n)
-     */
-    public int findUnsortedSubarray_sorting(int[] nums) {
-        int[] clones = nums.clone();
-        Arrays.sort(clones);
-        int start = nums.length;
-        int end = 0;
-        for (int i = 0; i < nums.length; i++) {
-            if (clones[i] != nums[i]) {
-                start = Math.min(start, i);
-                end = Math.max(end, i);
+    public static class Solution2 {
+        /**
+         * Time: O(nlogn)
+         * Space: O(n)
+         */
+        public int findUnsortedSubarray(int[] nums) {
+            int[] clones = nums.clone();
+            Arrays.sort(clones);
+            int start = nums.length;
+            int end = 0;
+            for (int i = 0; i < nums.length; i++) {
+                if (clones[i] != nums[i]) {
+                    start = Math.min(start, i);
+                    end = Math.max(end, i);
+                }
             }
+            return (end - start > 0) ? end - start + 1 : 0;
         }
-        return (end - start > 0) ? end - start + 1 : 0;
     }
 
 }
diff --git a/src/test/java/com/fishercoder/_581Test.java b/src/test/java/com/fishercoder/_581Test.java
@@ -10,24 +10,27 @@
  * Created by fishercoder on 5/17/17.
  */
 public class _581Test {
-    private static _581 test;
+    private static _581.Solution1 solution1;
+    private static _581.Solution2 solution2;
     private static int[] nums;
 
     @BeforeClass
     public static void setup() {
-        test = new _581();
+        solution1 = new _581.Solution1();
+        solution2 = new _581.Solution2();
     }
 
     @Test
     public void test1() {
         nums = new int[]{1, 2, 3, 4};
-        assertEquals(0, test.findUnsortedSubarray(nums));
-        assertEquals(0, test.findUnsortedSubarray_sorting(nums));
+        assertEquals(0, solution1.findUnsortedSubarray(nums));
+        assertEquals(0, solution2.findUnsortedSubarray(nums));
     }
 
     @Test
     public void test2() {
         nums = new int[]{2, 6, 4, 8, 10, 9, 15};
-        assertEquals(5, test.findUnsortedSubarray(nums));
+        assertEquals(5, solution1.findUnsortedSubarray(nums));
+        assertEquals(5, solution2.findUnsortedSubarray(nums));
     }
 }
