Merge branch 'master' into fix/boyermoore-non-ascii

Author: DenizAltunkapan

.github/workflows/codeql.yml

@@ -30,15 +30,15 @@ jobs:
           distribution: 'temurin'
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.39.0
+        uses: github/codeql-action/init@v4.39.1
         with:
           languages: 'java-kotlin'
 
       - name: Build
         run: mvn --batch-mode --update-snapshots verify
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.39.0
+        uses: github/codeql-action/analyze@v4.39.1
         with:
           category: "/language:java-kotlin"
 
@@ -55,12 +55,12 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.39.0
+        uses: github/codeql-action/init@v4.39.1
         with:
           languages: 'actions'
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.39.0
+        uses: github/codeql-action/analyze@v4.39.1
         with:
           category: "/language:actions"
 ...

src/main/java/com/thealgorithms/datastructures/lists/SkipList.java

@@ -121,6 +121,9 @@ public void remove(E e) {
                 current = next;
             }
         }
+        if (layer < 0) {
+            return; // not found, nothing to unlink
+        }
         for (int i = 0; i <= layer; i++) {
             current.previous(i).setNext(i, current.next(i));
             if (current.next(i) != null) {

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

@@ -13,6 +13,9 @@ public class DutchNationalFlagSort implements SortAlgorithm {
 
     @Override
     public <T extends Comparable<T>> T[] sort(T[] array) {
+        if (array.length == 0) {
+            return array;
+        }
         return dutchNationalFlagSort(array, array[(int) Math.ceil((array.length) / 2.0) - 1]);
     }
 

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

@@ -76,7 +76,8 @@ private <T extends Comparable<? super T>> void flashSort(T[] arr) {
             return; // All elements are the same
         }
 
-        final int m = (int) (classificationRatio * arr.length);
+        // At least one class, otherwise small arrays index into an empty classification table
+        final int m = Math.max(1, (int) (classificationRatio * arr.length));
 
         final int[] classificationArray = new int[m];
 

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

@@ -17,7 +17,12 @@ public <T extends Comparable<T>> T[] sort(T[] array) {
             final int amountSmallerElements = this.getSmallerElementCount(array, index);
 
             if (amountSmallerElements > 0) {
-                SortUtils.swap(array, index, index + amountSmallerElements);
+                int target = index + amountSmallerElements;
+                // Skip slots that already hold an equal element, otherwise two equal values swap forever
+                while (array[target].compareTo(array[index]) == 0) {
+                    target++;
+                }
+                SortUtils.swap(array, index, target);
             } else {
                 index++;
             }

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

@@ -3,6 +3,8 @@
 import static com.thealgorithms.sorts.SortUtils.print;
 
 import com.thealgorithms.datastructures.trees.BSTRecursiveGeneric;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -30,38 +32,39 @@ public <T extends Comparable<T>> List<T> sort(List<T> unsortedList) {
     }
 
     private <T extends Comparable<T>> T[] doTreeSortArray(T[] unsortedArray) {
-        // create a generic BST tree
-        BSTRecursiveGeneric<T> tree = new BSTRecursiveGeneric<T>();
-
-        // add all elements to the tree
-        for (T element : unsortedArray) {
-            tree.add(element);
-        }
-
-        // get the sorted list by inorder traversal of the tree
-        List<T> sortedList = tree.inorderSort();
-
-        // add the elements back to the initial array
-        int i = 0;
-        for (T element : sortedList) {
-            unsortedArray[i++] = element;
-        }
-
-        // return the array
-        return unsortedArray;
+        // sort through the list path and copy the result back into the initial array
+        List<T> sortedList = doTreeSortList(Arrays.asList(unsortedArray));
+        return sortedList.toArray(unsortedArray);
     }
 
     private <T extends Comparable<T>> List<T> doTreeSortList(Iterable<T> unsortedList) {
-        // create a generic BST tree
-        BSTRecursiveGeneric<T> tree = new BSTRecursiveGeneric<T>();
+        // the BST ignores duplicate keys, so pair every element with its position to keep equal values apart
+        BSTRecursiveGeneric<Keyed<T>> tree = new BSTRecursiveGeneric<>();
 
         // add all elements to the tree
+        int position = 0;
         for (T element : unsortedList) {
-            tree.add(element);
+            tree.add(new Keyed<>(element, position++));
         }
 
         // get the sorted list by inorder traversal of the tree and return it
-        return tree.inorderSort();
+        List<T> sortedList = new ArrayList<>();
+        for (Keyed<T> keyed : tree.inorderSort()) {
+            sortedList.add(keyed.value());
+        }
+        return sortedList;
+    }
+
+    /**
+     * An element plus its original position. Equal elements are ordered by position,
+     * which also makes the sort stable.
+     */
+    private record Keyed<T extends Comparable<T>>(T value, int position) implements Comparable<Keyed<T>> {
+        @Override
+        public int compareTo(Keyed<T> other) {
+            int byValue = value.compareTo(other.value);
+            return byValue != 0 ? byValue : Integer.compare(position, other.position);
+        }
     }
 
     public static void main(String[] args) {

src/main/java/com/thealgorithms/strings/HorspoolSearch.java

@@ -95,7 +95,7 @@ public static Integer getLastComparisons() {
      * @return index of first occurrence of the pattern in the text
      */
     private static int firstOccurrence(String pattern, String text, boolean caseSensitive) {
-        shiftValues = calcShiftValues(pattern); // build the bad symbol table
+        shiftValues = calcShiftValues(pattern, caseSensitive); // build the bad symbol table
         comparisons = 0; // reset comparisons
 
         if (pattern.length() == 0) { // return failure, if pattern empty
@@ -113,7 +113,7 @@ private static int firstOccurrence(String pattern, String text, boolean caseSens
                 char patternChar = pattern.charAt(i);
                 char textChar = text.charAt((textIndex + i) - (pattern.length() - 1));
                 if (!charEquals(patternChar, textChar, caseSensitive)) { // bad character, shift pattern
-                    textIndex += getShiftValue(text.charAt(textIndex));
+                    textIndex += getShiftValue(text.charAt(textIndex), caseSensitive);
                     break;
                 }
                 i--;
@@ -153,14 +153,15 @@ private static boolean charEquals(char c1, char c2, boolean caseSensitive) {
      * in the table, then it is not a rightmost occurrence, so it continues.
      *
      * @param pattern basis for the bad symbol table
+     * @param caseSensitive whether to build the table with case-sensitive keys
      * @return the bad symbol table
      */
-    private static HashMap<Character, Integer> calcShiftValues(String pattern) {
+    private static HashMap<Character, Integer> calcShiftValues(String pattern, boolean caseSensitive) {
         patternLength = pattern.length();
         HashMap<Character, Integer> table = new HashMap<>();
 
         for (int i = pattern.length() - 2; i >= 0; i--) { // length - 2 is the index of the second to last character
-            char c = pattern.charAt(i);
+            char c = caseSensitive ? pattern.charAt(i) : Character.toLowerCase(pattern.charAt(i));
             int finalI = i;
             table.computeIfAbsent(c, k -> pattern.length() - 1 - finalI);
         }
@@ -173,11 +174,14 @@ private static HashMap<Character, Integer> calcShiftValues(String pattern) {
      * appropriate shift value for a given character
      *
      * @param c character
+     * @param caseSensitive whether the table was built with case-sensitive keys
      * @return shift value that corresponds to the character argument
      */
-    private static Integer getShiftValue(char c) {
-        if (shiftValues.get(c) != null) {
-            return shiftValues.get(c);
+    private static Integer getShiftValue(char c, boolean caseSensitive) {
+        // the table holds lower-case keys for case-insensitive searches
+        char key = caseSensitive ? c : Character.toLowerCase(c);
+        if (shiftValues.get(key) != null) {
+            return shiftValues.get(key);
         } else {
             return patternLength;
         }

src/test/java/com/thealgorithms/datastructures/lists/SkipListTest.java

@@ -106,6 +106,20 @@ void testClearViaRemovals() {
         assertEquals(0, skipList.size());
     }
 
+    @Test
+    @DisplayName("Removing a missing element leaves the list unchanged")
+    void testRemoveMissing() {
+        skipList.remove("missing");
+        assertEquals(0, skipList.size());
+
+        skipList.add("a");
+        skipList.add("c");
+        skipList.remove("b");
+        assertEquals(2, skipList.size());
+        assertEquals("a", skipList.get(0));
+        assertEquals("c", skipList.get(1));
+    }
+
     private SkipList<String> createSkipList() {
         SkipList<String> s = new SkipList<>();
         String[] values = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"};

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

@@ -109,4 +109,10 @@ void testOddStringsMidGivenDnfs() {
         dutchNationalFlagSort.sort(strings, "e");
         assertArrayEquals(strings, stringsResult);
     }
+
+    @Test
+    void testEmptyArray() {
+        Integer[] integers = {};
+        assertArrayEquals(new Integer[] {}, new DutchNationalFlagSort().sort(integers));
+    }
 }

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

@@ -1,5 +1,6 @@
 package com.thealgorithms.sorts;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -59,6 +60,12 @@ public List<DynamicTest> dynamicTestsForSorting() {
         return dynamicTests;
     }
 
+    @Test
+    public void testArraysTooSmallForMoreThanOneClass() {
+        assertArrayEquals(new Integer[] {1, 2}, new FlashSort().sort(new Integer[] {2, 1}));
+        assertArrayEquals(new Integer[] {1, 2, 3, 4, 5}, new FlashSort(0.1).sort(new Integer[] {5, 3, 1, 4, 2}));
+    }
+
     private List<DynamicTest> createDynamicTestsForRatio(double ratio) {
         List<DynamicTest> dynamicTests = new ArrayList<>();
         for (TestMethod testMethod : getTestMethodsFromSuperClass()) {