feat: add LibrarySort implementation

Author: Rosander0

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

@@ -0,0 +1,126 @@
+package com.thealgorithms.sorts;
+// author: Vraj Prajapati @Rosander0
+
+import java.util.Arrays;
+
+/**
+ * Library Sort (also known as Gapped Insertion Sort) is a sorting algorithm
+ * that works like insertion sort but leaves gaps between elements to make
+ * future insertions faster.
+ * Time Complexity: O(n log n) average case
+ * Space Complexity: O(n)
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Library_sort">
+ *     Wikipedia: Library Sort</a>
+ */
+public final class LibrarySort {
+
+    private LibrarySort() {
+        // Utility class
+    }
+
+    /**
+     * Sorts an array using the Library Sort algorithm.
+     *
+     * @param array the array to sort (must not be null)
+     * @return the sorted array
+     */
+    public static int[] sort(final int[] array) {
+        if (array == null) {
+            throw new IllegalArgumentException("Input array must not be null!");
+        }
+        if (array.length <= 1) {
+            return array;
+        }
+
+        int n = array.length;
+        int gapSize = 1;
+        int[] library = new int[2 * n];
+        boolean[] occupied = new boolean[2 * n];
+        Arrays.fill(library, Integer.MAX_VALUE);
+
+        // Insert first element
+        library[0] = array[0];
+        occupied[0] = true;
+        int occupiedCount = 1;
+
+        for (int i = 1; i < n; i++) {
+            // Find insertion position using binary search
+            int pos = binarySearch(library, occupied, array[i]);
+
+            // Shift elements to make room
+            if (occupied[pos]) {
+                // Find next free space
+                int free = pos;
+                while (free < 2 * n && occupied[free]) {
+                    free++;
+                }
+                if (free >= 2 * n) {
+                    // Rebalance if no space found
+                    rebalance(library, occupied, n);
+                    pos = binarySearch(library, occupied, array[i]);
+                    free = pos;
+                    while (free < 2 * n && occupied[free]) {
+                        free++;
+                    }
+                }
+                // Shift right to create gap
+                for (int j = free; j > pos; j--) {
+                    library[j] = library[j - 1];
+                    occupied[j] = occupied[j - 1];
+                }
+            }
+            library[pos] = array[i];
+            occupied[pos] = true;
+            occupiedCount++;
+            gapSize++;
+        }
+
+        // Collect sorted elements
+        int idx = 0;
+        for (int i = 0; i < 2 * n; i++) {
+            if (occupied[i]) {
+                array[idx++] = library[i];
+            }
+        }
+        return array;
+    }
+
+    /**
+     * Binary search to find insertion position in the library array.
+     */
+    private static int binarySearch(final int[] library, final boolean[] occupied, final int target) {
+        int lo = 0;
+        int hi = library.length - 1;
+        while (lo < hi) {
+            int mid = lo + (hi - lo) / 2;
+            if (library[mid] <= target) {
+                lo = mid + 1;
+            } else {
+                hi = mid;
+            }
+        }
+        return lo;
+    }
+
+    /**
+     * Rebalances the library array by redistributing elements with gaps.
+     */
+    private static void rebalance(final int[] library, final boolean[] occupied, final int n) {
+        int[] temp = new int[n];
+        int idx = 0;
+        for (int i = 0; i < 2 * n; i++) {
+            if (occupied[i]) {
+                temp[idx++] = library[i];
+                occupied[i] = false;
+                library[i] = Integer.MAX_VALUE;
+            }
+        }
+        // Redistribute with gaps
+        for (int i = 0; i < idx; i++) {
+            int pos = 2 * i;
+            library[pos] = temp[i];
+            occupied[pos] = true;
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+package com.thealgorithms.sorts;
+// author: Vraj Prajapati @Rosander0
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+public class LibrarySortTest {
+
+    @Test
+    public void testBasicSort() {
+        assertArrayEquals(new int[]{1, 2, 3, 4, 5},
+            LibrarySort.sort(new int[]{5, 3, 1, 4, 2}));
+    }
+
+    @Test
+    public void testAlreadySorted() {
+        assertArrayEquals(new int[]{1, 2, 3, 4, 5},
+            LibrarySort.sort(new int[]{1, 2, 3, 4, 5}));
+    }
+
+    @Test
+    public void testReverseSorted() {
+        assertArrayEquals(new int[]{1, 2, 3, 4, 5},
+            LibrarySort.sort(new int[]{5, 4, 3, 2, 1}));
+    }
+
+    @Test
+    public void testDuplicates() {
+        assertArrayEquals(new int[]{1, 2, 2, 3, 3},
+            LibrarySort.sort(new int[]{3, 2, 1, 3, 2}));
+    }
+
+    @Test
+    public void testSingleElement() {
+        assertArrayEquals(new int[]{1},
+            LibrarySort.sort(new int[]{1}));
+    }
+
+    @Test
+    public void testEmptyArray() {
+        assertArrayEquals(new int[]{},
+            LibrarySort.sort(new int[]{}));
+    }
+
+    @Test
+    public void testNullArray() {
+        assertThrows(IllegalArgumentException.class, () -> LibrarySort.sort(null));
+    }
+}