refactor 41

Author: fishercoder1534

README.md

@@ -631,7 +631,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |44|[Wildcard Matching](https://leetcode.com/problems/wildcard-matching/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_44.java)|O(m*n)|O(m*n)||Hard| Backtracking, DP, Greedy, String
 |43|[Multiply Strings](https://leetcode.com/problems/multiply-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_43.java)|O(n)|O(1)||Medium| Array, String
 |42|[Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_42.java)|O(n)|O(1)||Hard|
-|41|[First Missing Positive](https://leetcode.com/problems/first-missing-positive/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_41.java)|O(n)|O(1)||Hard|
+|41|[First Missing Positive](https://leetcode.com/problems/first-missing-positive/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_41.java)|O(n)|O(1)||Hard| Array
 |40|[Combination Sum II](https://leetcode.com/problems/combination-sum-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_40.java)|O(k*n^k)|O(k)||Medium|Backtracking
 |39|[Combination Sum](https://leetcode.com/problems/combination-sum/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_39.java)|O(k*n^k)|O(k)||Medium|Backtracking
 |38|[Count and Say](https://leetcode.com/problems/count-and-say/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_38.java)|O(n*2^n)|O(2^n)||Easy| Recursion, LinkedList

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

@@ -2,6 +2,7 @@
 
 /**
  *41. First Missing Positive
+ *
  *Given an unsorted integer array, find the first missing positive integer.
 
  For example,
@@ -13,35 +14,36 @@ Your algorithm should run in O(n) time and uses constant space.
 
 public class _41 {
 
-    public static class Solution1 {
-        public int firstMissingPositive(int[] nums) {
-            int i = 0;
-            while (i < nums.length) {
-                if (nums[i] > 0 && nums[i] != i + 1
-                        && nums[i] - 1 < nums.length
-                        && nums[i] != nums[nums[i] - 1]) {
-                    swap(nums, i, nums[i] - 1);
-                } else {
-                    i++;
-                }
-            }
-
-            for (int j = 0; j < nums.length; j++) {
-                if (nums[j] != j + 1) {
-                    return j + 1;
-                }
-            }
-
-            return nums.length + 1;
-            /** if all values are in the correct position, then we return the length + 1.
-             * This also takes care of corner case: [], we return 1 for it.*/
+  public static class Solution1 {
+    /**
+     * Time: O(n) Space: O(1)
+     *
+     * Idea: put every number in its right position, e.g. put 5 in nums[4].
+     */
+    public int firstMissingPositive(int[] nums) {
+      int i = 0;
+      while (i < nums.length) {
+        if (nums[i] > 0 && nums[i] != i + 1 && nums[i] - 1 < nums.length && nums[i] != nums[nums[i]
+            - 1]) {
+          swap(nums, i, nums[i] - 1);
+        } else {
+          i++;
         }
+      }
 
-        public void swap(int[] nums, int i, int j) {
-            int temp = nums[i];
-            nums[i] = nums[j];
-            nums[j] = temp;
+      for (int j = 0; j < nums.length; j++) {
+        if (nums[j] != j + 1) {
+          return j + 1;
         }
+      }
+
+      return nums.length + 1;
     }
 
+    void swap(int[] nums, int i, int j) {
+      int temp = nums[i];
+      nums[i] = nums[j];
+      nums[j] = temp;
+    }
+  }
 }

src/test/java/com/fishercoder/_41Test.java

@@ -0,0 +1,41 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._41;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _41Test {
+  private static _41.Solution1 solution1;
+  private static int[] nums;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _41.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    nums = new int[] {1, 2, 0};
+    assertEquals(3, solution1.firstMissingPositive(nums));
+  }
+
+  @Test
+  public void test2() {
+    nums = new int[] {};
+    assertEquals(1, solution1.firstMissingPositive(nums));
+  }
+
+  @Test
+  public void test3() {
+    nums = new int[] {3, 4, -1, 1};
+    assertEquals(2, solution1.firstMissingPositive(nums));
+  }
+
+  @Test
+  public void test4() {
+    nums = new int[] {2};
+    assertEquals(1, solution1.firstMissingPositive(nums));
+  }
+}