refactor 47

fishercoder1534 · fishercoder1534 · commit fc7014370c48 · 2019-06-09T12:51:01.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_47.java b/src/main/java/com/fishercoder/solutions/_47.java
@@ -1,12 +1,13 @@
 package com.fishercoder.solutions;
 
-import com.fishercoder.common.utils.CommonUtils;
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-/**Given a collection of numbers that might contain duplicates, return all possible unique permutations.
+/**
+ * 47. Permutations II
+ * 
+ * Given a collection of numbers that might contain duplicates, return all possible unique permutations.
 
  For example,
  [1,1,2] have the following unique permutations:
@@ -16,49 +17,46 @@
  [2,1,1]
  ]*/
 public class _47 {
-    /**credit: https://discuss.leetcode.com/topic/31445/really-easy-java-solution-much-easier-than-the-solutions-with-very-high-vote*/
-    public List<List<Integer>> permuteUnique(int[] nums) {
-        List<List<Integer>> result = new ArrayList();
-        if (nums == null || nums.length == 0) {
+    public static class Solution1 {
+        /**
+         * credit: https://discuss.leetcode.com/topic/31445/really-easy-java-solution-much-easier-than-the-solutions-with-very-high-vote
+         */
+        public List<List<Integer>> permuteUnique(int[] nums) {
+            List<List<Integer>> result = new ArrayList();
+            if (nums == null || nums.length == 0) {
+                return result;
+            }
+            boolean[] used = new boolean[nums.length];
+            List<Integer> list = new ArrayList();
+            Arrays.sort(nums);
+            dfs(nums, used, list, result);
             return result;
         }
-        boolean[] used = new boolean[nums.length];
-        List<Integer> list = new ArrayList();
-        Arrays.sort(nums);
-        dfs(nums, used, list, result);
-        return result;
-    }
 
 
-    private void dfs(int[] nums, boolean[] used, List<Integer> list, List<List<Integer>> result) {
-        if (list.size() == nums.length) {
-            result.add(new ArrayList(list));
-            return;
-        }
-        for (int i = 0; i < nums.length; i++) {
-            if (used[i]) {
-                continue;
+        private void dfs(int[] nums, boolean[] used, List<Integer> list, List<List<Integer>> result) {
+            if (list.size() == nums.length) {
+                result.add(new ArrayList(list));
+                return;
             }
-            if (i > 0 && nums[i - 1] == nums[i] && !used[i - 1]) {
-                continue;
+            for (int i = 0; i < nums.length; i++) {
+                if (used[i]) {
+                    continue;
+                }
+                if (i > 0 && nums[i - 1] == nums[i] && !used[i - 1]) {
+                    continue;
+                }
+                /**
+                 * For this line, both !used[i-1] and used[i-1] will AC. It is because the first one makes sure when
+                 * duplicates are selected, the order is ascending (index from small to large). However,
+                 * the second one means the descending order.
+                 */
+                used[i] = true;
+                list.add(nums[i]);
+                dfs(nums, used, list, result);
+                used[i] = false;
+                list.remove(list.size() - 1);
             }
-            /**
-             * For this line, both !used[i-1] and used[i-1] will AC. It is because the first one makes sure when
-             * duplicates are selected, the order is ascending (index from small to large). However,
-             * the second one means the descending order.
-             */
-            used[i] = true;
-            list.add(nums[i]);
-            dfs(nums, used, list, result);
-            used[i] = false;
-            list.remove(list.size() - 1);
         }
     }
-
-    public static void main(String... args) {
-        int[] nums = new int[]{1, 1, 2};
-        _47 test = new _47();
-        List<List<Integer>> result = test.permuteUnique(nums);
-        CommonUtils.printListList(result);
-    }
 }
diff --git a/src/test/java/com/fishercoder/_47Test.java b/src/test/java/com/fishercoder/_47Test.java
@@ -0,0 +1,25 @@
+package com.fishercoder;
+
+import com.fishercoder.common.utils.CommonUtils;
+import com.fishercoder.solutions._47;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+public class _47Test {
+    private static _47.Solution1 solution1;
+    private static List<List<Integer>> actual;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _47.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        actual = solution1.permuteUnique(new int[]{1, 1, 2});
+        CommonUtils.printListList(actual);
+    }
+
+}
