Merge branch 'master' into fix/rabinkarp-overflow

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"
 ...

.github/workflows/project_structure.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
-      - uses: actions/setup-python@v7.0.0
+      - uses: actions/setup-python@v7.1.0
         with:
           python-version: '3.13'
 

pom.xml

@@ -61,7 +61,7 @@
         <plugins>
             <plugin>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>3.6.0</version>
+                <version>3.6.1</version>
                 <configuration>
                     <forkNode implementation="org.apache.maven.plugin.surefire.extensions.SurefireForkNodeFactory"/>
                 </configuration>
@@ -82,7 +82,7 @@
             <plugin>
                 <groupId>org.jacoco</groupId>
                 <artifactId>jacoco-maven-plugin</artifactId>
-                <version>0.8.15</version>
+                <version>0.8.16</version>
                 <executions>
                     <execution>
                         <goals>

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/searches/BoyerMoore.java

@@ -1,27 +1,25 @@
 package com.thealgorithms.searches;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * Boyer-Moore string search algorithm.
  * Efficient algorithm for substring search.
  * https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string-search_algorithm
  */
 public class BoyerMoore {
 
-    private final int radix; // Radix (number of possible characters)
-    private final int[] right; // Bad character rule table
+    private final Map<Character, Integer> right; // Bad character rule table: last index of each pattern character
     private final String pattern;
 
     public BoyerMoore(String pat) {
         this.pattern = pat;
-        this.radix = 256;
-        this.right = new int[radix];
-
-        for (int c = 0; c < radix; c++) {
-            right[c] = -1;
-        }
+        // A map instead of a 256-entry array, so characters outside extended ASCII work too
+        this.right = new HashMap<>();
 
         for (int j = 0; j < pat.length(); j++) {
-            right[pat.charAt(j)] = j;
+            right.put(pat.charAt(j), j);
         }
     }
 
@@ -40,7 +38,7 @@ public int search(String text) {
                 char txtChar = text.charAt(i + j);
                 char patChar = pattern.charAt(j);
                 if (patChar != txtChar) {
-                    skip = Math.max(1, j - right[txtChar]);
+                    skip = Math.max(1, j - right.getOrDefault(txtChar, -1));
                     break;
                 }
             }

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;
         }