refactor 41

Author: fishercoder1534

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

@@ -13,32 +13,33 @@ Your algorithm should run in O(n) time and uses constant space.
 
 public class _41 {
 
-    public int firstMissingPositive(int[] A) {
+    public int firstMissingPositive(int[] nums) {
         int i = 0;
-        while (i < A.length) {
-            if (A[i] > 0 && A[i] != i + 1
-                    && A[i] - 1 < A.length
-                    && A[i] != A[A[i] - 1]) {
-                swap(A, i, A[i] - 1);
+        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 < A.length; j++) {
-            if (A[j] != j + 1) {
+        for (int j = 0; j < nums.length; j++) {
+            if (nums[j] != j + 1) {
                 return j + 1;
             }
         }
 
-        return A.length + 1;// if all values are in the correct position, then
-        // we return the last one + 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 void swap(int[] A, int i, int j) {// i and j are indices in array A
-        int temp = A[i];
-        A[i] = A[j];
-        A[j] = temp;
+    public void swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
     }
 
 }