done required changes

Author: Darshan-Baligeri

src/main/java/com/thealgorithms/shufflealogrithm/ConstrainedShuffle.java

@@ -10,7 +10,8 @@ private ConstrainedShuffle() {
     }
 
     /**
-     * Shuffles elements in the array while ensuring that the first and last elements remain fixed.
+     * Shuffles elements in the array while ensuring that the first and last
+     * elements remain fixed.
      *
      * @param array the input array to shuffle
      */

src/main/java/com/thealgorithms/shufflealogrithm/UnderstandingShuffleAlgo.java

@@ -10,7 +10,8 @@ private UnderstandingShuffleAlgo() {
 
     /**
      * Shuffles the elements in the array randomly.
-     * Uses a method that gives each item an equal chance to appear in any position.
+     * Uses a method that gives each item an equal chance to appear in any
+     * position.
      *
      * @param array the array to be shuffled
      */

src/main/java/com/thealgorithms/shufflealogrithm/UniquePairShuffle.java

@@ -11,17 +11,21 @@ private UniquePairShuffle() {
     }
 
     /**
-     * Pairs each element in the array with another element randomly, ensuring no pair repeats.
-     * If the array length is odd, pairing cannot be completed, so an empty list is returned.
+     * Pairs each element in the array with another element randomly, ensuring no
+     * pair repeats. If the array length is odd, pairing cannot be completed, so
+     * an empty list is returned.
      *
      * @param array the input array to pair elements from
-     * @return a list of unique pairs where each pair is represented as an integer array of length 2
+     * @return a list of unique pairs where each pair is represented as an integer
+     *     array of length 2
      */
     public static List<int[]> pairShuffle(int[] array) {
         List<int[]> pairs = new ArrayList<>();
 
         // Handle edge case: If the array length is odd, pairing is not possible
-        if (array.length % 2 != 0) return pairs;
+        if (array.length % 2 != 0) {
+            return pairs;
+        }
 
         List<Integer> shuffledList = new ArrayList<>();
         for (int num : array) {
@@ -33,7 +37,7 @@ public static List<int[]> pairShuffle(int[] array) {
 
         // Form pairs from the shuffled elements
         for (int i = 0; i < shuffledList.size(); i += 2) {
-            pairs.add(new int[]{shuffledList.get(i), shuffledList.get(i + 1)});
+            pairs.add(new int[] {shuffledList.get(i), shuffledList.get(i + 1)});
         }
 
         return pairs;

src/main/java/com/thealgorithms/shufflealogrithm/WeightedShuffle.java

@@ -10,7 +10,8 @@ private WeightedShuffle() {
     }
 
     /**
-     * Shuffles elements based on their weights. Higher weight elements are more likely to appear earlier.
+     * Shuffles elements based on their weights. Higher weight elements are more
+     * likely to appear earlier.
      *
      * @param array   the input array to shuffle
      * @param weights the weights for each corresponding element in the array
@@ -26,7 +27,7 @@ public static void weightedShuffle(int[] array, int[] weights) {
             indices[i] = i;
         }
 
-        Arrays.sort(indices, Comparator.comparingInt(i -> -weights[i]));
+        Arrays.sort(indices, Comparator.comparingInt(i -> - weights[i]));
 
         int[] result = new int[array.length];
         for (int i = 0; i < array.length; i++) {

src/test/java/com/thealgorithms/datastructures/trees/BinaryTreeTest.java

@@ -1,13 +1,12 @@
 package com.thealgorithms.datastructures.trees;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
 
 import org.junit.jupiter.api.Test;
 
 public class BinaryTreeTest {
 
-    // checks that adding populating the tree and searching for data
-    // retrieves the expected data
+    // Test for adding elements and finding data within the tree
     @Test
     void test1() {
         BinaryTree t = new BinaryTree();
@@ -17,12 +16,14 @@ void test1() {
         t.put(9);
         t.put(12);
 
-        assertEquals(t.find(5).data, 5);
-        assertEquals(t.find(7).data, 7);
+        assertNotNull(t.find(5), "Node with value 5 should exist in the tree.");
+        assertEquals(5, t.find(5).data);
+
+        assertNotNull(t.find(7), "Node with value 7 should exist in the tree.");
+        assertEquals(7, t.find(7).data);
     }
 
-    // checks that removing data from the tree
-    // properly removes and makes the new root the expected new root
+    // Test for removing data and checking the new root
     @Test
     void test2() {
         BinaryTree t = new BinaryTree();
@@ -31,15 +32,17 @@ void test2() {
         t.put(7);
         t.put(9);
         t.put(12);
+
+        // Perform removals and check the new root
         t.remove(3);
         t.remove(5);
         t.remove(7);
 
-        assertEquals(t.getRoot().data, 9);
+        assertNotNull(t.getRoot(), "Root should not be null after removals.");
+        assertEquals(9, t.getRoot().data);
     }
 
-    // checks that removing an unexistend node returns false
-    //  as specified by the documentation of the function
+    // Test for attempting to remove a nonexistent node
     @Test
     void test3() {
         BinaryTree t = new BinaryTree();
@@ -49,13 +52,12 @@ void test3() {
         t.put(9);
         t.put(12);
 
-        assertEquals(t.remove(9), true);
-        assertEquals(t.remove(398745987), false);
+        assertTrue(t.remove(9), "Node with value 9 should be removed.");
+        assertFalse(t.remove(398745987),
+                "Removing a nonexistent node should return false.");
     }
 
-    // check if the bfs, inOrder, preOrder and postOrder functions
-    // worg as expected, also increases the coverage measures in
-    // JaCoCo
+    // Test traversal methods (bfs, inOrder, preOrder, postOrder)
     @Test
     void test4() {
         BinaryTree t = new BinaryTree();
@@ -65,12 +67,18 @@ void test4() {
         t.put(9);
         t.put(12);
 
-        t.bfs(t.find(12));
+        // Ensure root is not null before traversal
+        assertNotNull(t.getRoot(), "Root should not be null for traversal.");
+
+        // Invoke traversal methods to increase test coverage
+        t.bfs(t.getRoot());
         t.inOrder(t.getRoot());
         t.preOrder(t.getRoot());
         t.postOrder(t.getRoot());
 
-        assertEquals(t.remove(9), true);
-        assertEquals(t.remove(398745987), false);
+        // Additional assertions
+        assertTrue(t.remove(9), "Node with value 9 should be removed.");
+        assertFalse(t.remove(398745987),
+                "Removing a nonexistent node should return false.");
     }
 }

src/test/java/com/thealgorithms/shufflealgorithm/ConstrainedShuffleTest.java

@@ -0,0 +1,111 @@
+package com.thealgorithms.shufflealgorithm;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.thealgorithms.shufflealogrithm.ConstrainedShuffle;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class ConstrainedShuffleTest {
+
+    private int[] originalArray;
+
+    @BeforeEach
+    void setUp() {
+        originalArray = new int[] {1, 2, 3, 4, 5};
+    }
+
+    // Test that shuffling preserves the length and original elements
+    @Test
+    void testPreserveArrayLengthAndElements() {
+        int[] arrayCopy = Arrays.copyOf(originalArray, originalArray.length);
+        ConstrainedShuffle.constrainedShuffle(arrayCopy);
+
+        assertEquals(originalArray.length, arrayCopy.length,
+                "Array length should remain the same");
+
+        Set<Integer> originalElements = new HashSet<>();
+        for (int num : originalArray) {
+            originalElements.add(num);
+        }
+
+        for (int num : arrayCopy) {
+            assertEquals(true, originalElements.contains(num),
+                    "Array elements should be preserved");
+        }
+    }
+
+    // Test that the first and last elements remain unchanged after shuffle
+    @Test
+    void testFirstAndLastElementsFixed() {
+        int[] arrayCopy = Arrays.copyOf(originalArray, originalArray.length);
+        ConstrainedShuffle.constrainedShuffle(arrayCopy);
+
+        assertEquals(originalArray[0], arrayCopy[0],
+                "First element should remain fixed");
+        assertEquals(originalArray[originalArray.length - 1],
+                arrayCopy[arrayCopy.length - 1],
+                "Last element should remain fixed");
+    }
+
+    // Test that the function handles arrays with fewer than 3 elements without
+    // changes
+    @Test
+    void testArrayTooSmall() {
+        int[] smallArray = {1, 2};
+        int[] expectedArray = {1, 2};
+
+        ConstrainedShuffle.constrainedShuffle(smallArray);
+
+        assertArrayEquals(
+                expectedArray, smallArray,
+                "Array with fewer than 3 elements should remain unchanged");
+    }
+
+    // Test with null input (should handle gracefully without error)
+    @Test
+    void testNullArray() {
+        int[] nullArray = null;
+        ConstrainedShuffle.constrainedShuffle(nullArray);
+
+        assertEquals(null, nullArray, "Null input should remain null");
+    }
+
+    // Test that elements between the first and last positions change order in
+    // larger arrays
+    @Test
+    void testInternalElementsShuffled() {
+        int[] arrayCopy = Arrays.copyOf(originalArray, originalArray.length);
+        boolean hasShuffled = false;
+
+        for (int i = 0; i < 10; i++) { // Repeat shuffle to ensure randomness
+            ConstrainedShuffle.constrainedShuffle(arrayCopy);
+
+            if (!Arrays.equals(arrayCopy, originalArray)) {
+                hasShuffled = true;
+                break;
+            }
+        }
+
+        assertEquals(
+                true, hasShuffled,
+                "Internal elements should shuffle between first and last positions");
+    }
+
+    // Test with an array that has all identical elements
+    @Test
+    void testArrayWithIdenticalElements() {
+        int[] identicalArray = {1, 1, 1, 1, 1};
+        int[] expectedArray = {1, 1, 1, 1, 1};
+
+        ConstrainedShuffle.constrainedShuffle(identicalArray);
+
+        assertArrayEquals(
+                expectedArray, identicalArray,
+                "Array with all identical elements should remain unchanged");
+    }
+}

src/test/java/com/thealgorithms/shufflealgorithm/GroupShuffleTest.java

@@ -0,0 +1,91 @@
+package com.thealgorithms.shufflealgorithm;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.thealgorithms.shufflealogrithm.GroupShuffle;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+public class GroupShuffleTest {
+
+    // Test case to check basic functionality
+    @Test
+    void testGroupShuffleBasic() {
+        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        List<List<Integer>> shuffledGroups = GroupShuffle.groupShuffle(array, 3);
+
+        assertEquals(3, shuffledGroups.size()); // Expect 3 groups
+        assertTrue(shuffledGroups.stream().allMatch(
+                group -> group.size() <= 3)); // All groups should have size <= 3
+        System.out.println("Shuffled Groups (Basic Test): " + shuffledGroups);
+    }
+
+    // Test case to check when group size is larger than array length
+    @Test
+    void testGroupShuffleLargeGroupSize() {
+        int[] array = {1, 2, 3};
+        List<List<Integer>> shuffledGroups = GroupShuffle.groupShuffle(array, 5);
+
+        assertEquals(1, shuffledGroups.size()); // Expect 1 group with all elements
+        assertEquals(
+                Arrays.asList(1, 2, 3),
+                shuffledGroups.get(0)); // The group should contain all elements
+        System.out.println("Shuffled Groups (Large Group Size Test): " +
+                shuffledGroups);
+    }
+
+    // Test case to check when the array is null
+    @Test
+    void testGroupShuffleNullArray() {
+        List<List<Integer>> shuffledGroups = GroupShuffle.groupShuffle(null, 3);
+
+        assertTrue(shuffledGroups.isEmpty()); // Expect empty list
+        System.out.println("Shuffled Groups (Null Array Test): " + shuffledGroups);
+    }
+
+    // Test case to check when group size is less than or equal to zero
+    @Test
+    void testGroupShuffleZeroOrNegativeGroupSize() {
+        int[] array = {1, 2, 3};
+        List<List<Integer>> shuffledGroups = GroupShuffle.groupShuffle(array, 0);
+
+        assertTrue(
+                shuffledGroups.isEmpty()); // Expect empty list for group size zero
+        shuffledGroups = GroupShuffle.groupShuffle(array, -1);
+        assertTrue(
+                shuffledGroups.isEmpty()); // Expect empty list for negative group size
+        System.out.println("Shuffled Groups (Zero or Negative Group Size Test): " +
+                shuffledGroups);
+    }
+
+    // Test case to check when the array has fewer than 3 elements
+    @Test
+    void testGroupShuffleSmallArray() {
+        int[] array = {1, 2};
+        List<List<Integer>> shuffledGroups = GroupShuffle.groupShuffle(array, 2);
+
+        assertEquals(1, shuffledGroups.size()); // Expect 1 group with all elements
+        assertEquals(
+                Arrays.asList(1, 2),
+                shuffledGroups.get(0)); // The group should contain all elements
+        System.out.println("Shuffled Groups (Small Array Test): " + shuffledGroups);
+    }
+
+    // Test case to check the behavior when the group size is 1
+    @Test
+    void testGroupShuffleGroupSizeOne() {
+        int[] array = {1, 2, 3, 4, 5};
+        List<List<Integer>> shuffledGroups = GroupShuffle.groupShuffle(array, 1);
+
+        assertEquals(5, shuffledGroups.size()); // Expect 5 groups
+        for (int i = 0; i < 5; i++) {
+            assertEquals(
+                    Arrays.asList(i + 1),
+                    shuffledGroups.get(i)); // Each group should contain one element
+        }
+        System.out.println("Shuffled Groups (Group Size One Test): " +
+                shuffledGroups);
+    }
+}