Added UniquePermutations algo with test cases

Author: VarnitRaina

src/main/java/com/thealgorithms/Recursion/UniquePermutations.java

@@ -1,13 +1,26 @@
 package com.thealgorithms.Recursion;
 
-public class UniquePermutations {
-    throw new UnsupportedOperationException("Utility class");
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
+public class UniquePermutations {
 
     public static List<String> getUniquePermutations(String str) {
-        List<String> result = new ArrayList<>();
-        boolean[] used = new boolean[str.length()];
+        // Handle null or empty input
+        if (str == null) return new ArrayList<>();
+        if (str.length() == 0) {
+            List<String> result = new ArrayList<>();
+            result.add("");
+            return result;
+        }
+        
+        // Sort characters to handle duplicates
         char[] chars = str.toCharArray();
+        Arrays.sort(chars);
+        
+        List<String> result = new ArrayList<>();
+        boolean[] used = new boolean[chars.length];
         StringBuilder currentPermutation = new StringBuilder();
         generatePermutations(chars, used, currentPermutation, result);
         return result;
@@ -20,6 +33,7 @@ private static void generatePermutations(char[] chars, boolean[] used, StringBui
         }
 
         for (int i = 0; i < chars.length; i++) {
+            // Skip used characters or duplicates
             if (used[i] || (i > 0 && chars[i] == chars[i - 1] && !used[i - 1])) {
                 continue;
             }
@@ -32,3 +46,7 @@ private static void generatePermutations(char[] chars, boolean[] used, StringBui
     }
 }
 
+
+//This is a more efficient but complex algorithm
+//If you want to refer to a simpler one and then come to this,
+//click on the URL=>"https://www.geeksforgeeks.org/java-program-to-print-distinct-permutations-of-a-string/""

src/test/java/com/thealgorithms/Recursion/UniquePermutationsTest.java

@@ -1,6 +1,8 @@
-package com.thealgorithms.recursion;
+package com.thealgorithms.Recursion;
 
 import org.junit.jupiter.api.Test;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -11,7 +13,8 @@ void testUniquePermutations() {
         String str = "abc";
         List<String> expected = List.of("abc", "acb", "bac", "bca", "cab", "cba");
         List<String> result = UniquePermutations.getUniquePermutations(str);
-        assertEquals(expected.size(), result.size());
+        Collections.sort(expected); // Ensure expected is sorted
+        Collections.sort(result); // Ensure result is sorted
         assertEquals(expected, result);
     }
 
@@ -20,7 +23,8 @@ void testUniquePermutationsWithDuplicates() {
         String str = "aab";
         List<String> expected = List.of("aab", "aba", "baa");
         List<String> result = UniquePermutations.getUniquePermutations(str);
-        assertEquals(expected.size(), result.size());
+        Collections.sort(expected); // Ensure expected is sorted
+        Collections.sort(result); // Ensure result is sorted
         assertEquals(expected, result);
     }
 
@@ -29,6 +33,7 @@ void testEmptyString() {
         String str = "";
         List<String> result = UniquePermutations.getUniquePermutations(str);
         assertEquals(1, result.size()); // only 1 permutation which is an empty string
+        assertEquals("", result.get(0)); // Verify the only permutation is the empty string
     }
 
     @Test
@@ -38,4 +43,30 @@ void testSingleCharacter() {
         assertEquals(1, result.size());
         assertEquals("a", result.get(0));
     }
+
+    @Test
+    void testAllIdenticalCharacters() {
+        String str = "aaa";
+        List<String> expected = List.of("aaa");
+        List<String> result = UniquePermutations.getUniquePermutations(str);
+        assertEquals(expected.size(), result.size());
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void testMixedCaseCharacters() {
+        String str = "aAb";
+        List<String> expected = List.of("AaB", "AbA", "aAB", "aBA", "baA", "bAa");
+        List<String> result = UniquePermutations.getUniquePermutations(str);
+        Collections.sort(expected); // Ensure expected is sorted
+        Collections.sort(result); // Ensure result is sorted
+        assertEquals(expected, result);
+    }
+
+    @Test
+    void testNullInput() {
+        String str = null;
+        List<String> result = UniquePermutations.getUniquePermutations(str);
+        assertEquals(0, result.size()); // Expect an empty list for null input
+    }
 }