update _47

fishercoder1534 · fishercoder1534 · commit fefcd45ac061 · 2024-02-04T18:51:47.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_47.java b/src/main/java/com/fishercoder/solutions/_47.java
@@ -17,7 +17,7 @@ public List<List<Integer>> permuteUnique(int[] nums) {
                 return result;
             }
             boolean[] used = new boolean[nums.length];
-            Arrays.sort(nums);//this sorting is critical for the correctness of this backtracking algorithm as we compare the two adjancent neighbors to filter out possible duplicate permutations
+            Arrays.sort(nums);//this sorting is critical for the correctness of this backtracking algorithm as we compare the two adjacent neighbors to filter out possible duplicate permutations
             backtracking(nums, used, new ArrayList(), result);
             return result;
         }
@@ -52,18 +52,17 @@ private void backtracking(int[] nums, boolean[] used, List<Integer> list, List<L
 
     public static class Solution2 {
         public List<List<Integer>> permuteUnique(int[] nums) {
-            Arrays.sort(nums);
             Set<List<Integer>> set = new HashSet<>();
             set.add(new ArrayList<>());
-            set = recursion(nums, set, 0);
+            set = recurse(nums, set, 0);
             List<List<Integer>> res = new ArrayList<>();
             for (List<Integer> list : set) {
                 res.add(list);
             }
             return res;
         }
 
-        private Set<List<Integer>> recursion(int[] nums, Set<List<Integer>> set, int pos) {
+        private Set<List<Integer>> recurse(int[] nums, Set<List<Integer>> set, int pos) {
             if (pos == nums.length) {
                 return set;
             }
@@ -75,8 +74,7 @@ private Set<List<Integer>> recursion(int[] nums, Set<List<Integer>> set, int pos
                     newSet.add(newList);
                 }
             }
-            set = newSet;
-            return recursion(nums, set, pos + 1);
+            return recurse(nums, newSet, pos + 1);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public List<List<Integer>> permuteUnique(int[] nums) {`
`17`	`17`	`return result;`
`18`	`18`	`}`
`19`	`19`	`boolean[] used = new boolean[nums.length];`
`20`		`- Arrays.sort(nums);//this sorting is critical for the correctness of this backtracking algorithm as we compare the two adjancent neighbors to filter out possible duplicate permutations`
	`20`	`+ Arrays.sort(nums);//this sorting is critical for the correctness of this backtracking algorithm as we compare the two adjacent neighbors to filter out possible duplicate permutations`
`21`	`21`	`backtracking(nums, used, new ArrayList(), result);`
`22`	`22`	`return result;`
`23`	`23`	`}`
`@@ -52,18 +52,17 @@ private void backtracking(int[] nums, boolean[] used, List<Integer> list, List<L`
`52`	`52`
`53`	`53`	`public static class Solution2 {`
`54`	`54`	`public List<List<Integer>> permuteUnique(int[] nums) {`
`55`		`- Arrays.sort(nums);`
`56`	`55`	`Set<List<Integer>> set = new HashSet<>();`
`57`	`56`	`set.add(new ArrayList<>());`
`58`		`- set = recursion(nums, set, 0);`
	`57`	`+ set = recurse(nums, set, 0);`
`59`	`58`	`List<List<Integer>> res = new ArrayList<>();`
`60`	`59`	`for (List<Integer> list : set) {`
`61`	`60`	`res.add(list);`
`62`	`61`	`}`
`63`	`62`	`return res;`
`64`	`63`	`}`
`65`	`64`
`66`		`- private Set<List<Integer>> recursion(int[] nums, Set<List<Integer>> set, int pos) {`
	`65`	`+ private Set<List<Integer>> recurse(int[] nums, Set<List<Integer>> set, int pos) {`
`67`	`66`	`if (pos == nums.length) {`
`68`	`67`	`return set;`
`69`	`68`	`}`
`@@ -75,8 +74,7 @@ private Set<List<Integer>> recursion(int[] nums, Set<List<Integer>> set, int pos`
`75`	`74`	`newSet.add(newList);`
`76`	`75`	`}`
`77`	`76`	`}`
`78`		`- set = newSet;`
`79`		`- return recursion(nums, set, pos + 1);`
	`77`	`+ return recurse(nums, newSet, pos + 1);`
`80`	`78`	`}`
`81`	`79`	`}`
`82`	`80`	`}`