Merge branch 'master' into patch-2

Author: siriak

pom.xml

@@ -20,7 +20,7 @@
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
-                <version>5.11.2</version>
+                <version>5.11.3</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -31,7 +31,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
-            <version>5.11.2</version>
+            <version>5.11.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -43,15 +43,15 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>5.14.1</version>
+            <version>5.14.2</version>
             <scope>test</scope>
         </dependency>
 
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.11.2</version>
+            <version>5.11.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -132,7 +132,7 @@
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.8.6.4</version>
+                <version>4.8.6.5</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>

src/main/java/com/thealgorithms/sorts/AdaptiveMergeSort.java

@@ -0,0 +1,40 @@
+package com.thealgorithms.sorts;
+
+public class AdaptiveMergeSort implements SortAlgorithm {
+    @SuppressWarnings("unchecked")
+    public <T extends Comparable<T>> T[] sort(T[] array) {
+        if (array.length <= 1) {
+            return array;
+        }
+        T[] aux = array.clone();
+        sort(array, aux, 0, array.length - 1);
+        return array;
+    }
+
+    private <T extends Comparable<T>> void sort(T[] array, T[] aux, int low, int high) {
+        if (low >= high) {
+            return;
+        }
+        int mid = low + (high - low) / 2;
+        sort(array, aux, low, mid);
+        sort(array, aux, mid + 1, high);
+        merge(array, aux, low, mid, high);
+    }
+
+    private <T extends Comparable<T>> void merge(T[] array, T[] aux, int low, int mid, int high) {
+        System.arraycopy(array, low, aux, low, high - low + 1);
+        int i = low;
+        int j = mid + 1;
+        for (int k = low; k <= high; k++) {
+            if (i > mid) {
+                array[k] = aux[j++];
+            } else if (j > high) {
+                array[k] = aux[i++];
+            } else if (aux[j].compareTo(aux[i]) < 0) {
+                array[k] = aux[j++];
+            } else {
+                array[k] = aux[i++];
+            }
+        }
+    }
+}

src/main/java/com/thealgorithms/sorts/StalinSort.java

@@ -0,0 +1,21 @@
+package com.thealgorithms.sorts;
+
+public class StalinSort implements SortAlgorithm {
+    @SuppressWarnings("unchecked")
+    public <T extends Comparable<T>> T[] sort(T[] array) {
+        if (array.length == 0) {
+            return array;
+        }
+        int currentIndex = 0;
+        for (int i = 1; i < array.length; i++) {
+            if (array[i].compareTo(array[currentIndex]) >= 0) {
+                currentIndex++;
+                array[currentIndex] = array[i];
+            }
+        }
+        // Create a result array with sorted elements
+        T[] result = (T[]) java.lang.reflect.Array.newInstance(array.getClass().getComponentType(), currentIndex + 1);
+        System.arraycopy(array, 0, result, 0, currentIndex + 1);
+        return result;
+    }
+}

src/test/java/com/thealgorithms/sorts/AdaptiveMergeSortTest.java

@@ -0,0 +1,53 @@
+package com.thealgorithms.sorts;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class AdaptiveMergeSortTest {
+
+    @Test
+    public void testSortIntegers() {
+        AdaptiveMergeSort adaptiveMergeSort = new AdaptiveMergeSort();
+        Integer[] input = {4, 23, 6, 78, 1, 54, 231, 9, 12};
+        Integer[] expected = {1, 4, 6, 9, 12, 23, 54, 78, 231};
+        Integer[] result = adaptiveMergeSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortStrings() {
+        AdaptiveMergeSort adaptiveMergeSort = new AdaptiveMergeSort();
+        String[] input = {"c", "a", "e", "b", "d"};
+        String[] expected = {"a", "b", "c", "d", "e"};
+        String[] result = adaptiveMergeSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortWithDuplicates() {
+        AdaptiveMergeSort adaptiveMergeSort = new AdaptiveMergeSort();
+        Integer[] input = {1, 3, 2, 2, 5, 4};
+        Integer[] expected = {1, 2, 2, 3, 4, 5};
+        Integer[] result = adaptiveMergeSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortEmptyArray() {
+        AdaptiveMergeSort adaptiveMergeSort = new AdaptiveMergeSort();
+        Integer[] input = {};
+        Integer[] expected = {};
+        Integer[] result = adaptiveMergeSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortSingleElement() {
+        AdaptiveMergeSort adaptiveMergeSort = new AdaptiveMergeSort();
+        Integer[] input = {42};
+        Integer[] expected = {42};
+        Integer[] result = adaptiveMergeSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+}

src/test/java/com/thealgorithms/sorts/StalinSortTest.java

@@ -0,0 +1,53 @@
+package com.thealgorithms.sorts;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class StalinSortTest {
+
+    @Test
+    public void testSortIntegers() {
+        StalinSort stalinSort = new StalinSort();
+        Integer[] input = {4, 23, 6, 78, 1, 54, 231, 9, 12};
+        Integer[] expected = {4, 23, 78, 231};
+        Integer[] result = stalinSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortStrings() {
+        StalinSort stalinSort = new StalinSort();
+        String[] input = {"c", "a", "e", "b", "d"};
+        String[] expected = {"c", "e"};
+        String[] result = stalinSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortWithDuplicates() {
+        StalinSort stalinSort = new StalinSort();
+        Integer[] input = {1, 3, 2, 2, 5, 4};
+        Integer[] expected = {1, 3, 5};
+        Integer[] result = stalinSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortEmptyArray() {
+        StalinSort stalinSort = new StalinSort();
+        Integer[] input = {};
+        Integer[] expected = {};
+        Integer[] result = stalinSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testSortSingleElement() {
+        StalinSort stalinSort = new StalinSort();
+        Integer[] input = {42};
+        Integer[] expected = {42};
+        Integer[] result = stalinSort.sort(input);
+        assertArrayEquals(expected, result);
+    }
+}