fix: logic simplication

Author: Rosander0

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

@@ -1,8 +1,6 @@
 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
@@ -19,6 +17,8 @@ private LibrarySort() {
         // Utility class
     }
 
+    private static final int GAP = 1;
+
     /**
      * Sorts an array using the Library Sort algorithm.
      *
@@ -34,93 +34,57 @@ public static int[] sort(final int[] 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);
+        // Allocate spaced array with gaps between each element
+        int spacedSize = n * (GAP + 1);
+        Integer[] spaced = new Integer[spacedSize];
 
         // Insert first element
-        library[0] = array[0];
-        occupied[0] = true;
-        int occupiedCount = 1;
+        spaced[0] = array[0];
+
+        int inserted = 1;
 
         for (int i = 1; i < n; i++) {
-            // Find insertion position using binary search
-            int pos = binarySearch(library, occupied, array[i]);
+            // Binary search for correct position among inserted elements
+            int pos = binarySearch(spaced, inserted, 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];
-                }
+            // Shift elements right by GAP+1 to make room
+            for (int j = inserted; j > pos; j--) {
+                spaced[j] = spaced[j - 1];
             }
-            library[pos] = array[i];
-            occupied[pos] = true;
-            occupiedCount++;
-            gapSize++;
+            spaced[pos] = array[i];
+            inserted++;
         }
 
-        // Collect sorted elements
+        // Collect sorted elements back
         int idx = 0;
-        for (int i = 0; i < 2 * n; i++) {
-            if (occupied[i]) {
-                array[idx++] = library[i];
+        for (int i = 0; i < spacedSize; i++) {
+            if (spaced[i] != null) {
+                array[idx++] = spaced[i];
             }
         }
         return array;
     }
 
     /**
-     * Binary search to find insertion position in the library array.
+     * Binary search to find insertion position among inserted elements.
+     *
+     * @param spaced the spaced array
+     * @param inserted number of elements inserted so far
+     * @param target the value to find position for
+     * @return the correct insertion index
      */
-    private static int binarySearch(final int[] library, final boolean[] occupied, final int target) {
+    private static int binarySearch(final Integer[] spaced,
+            final int inserted, final int target) {
         int lo = 0;
-        int hi = library.length - 1;
+        int hi = inserted;
         while (lo < hi) {
             int mid = lo + (hi - lo) / 2;
-            if (library[mid] <= target) {
+            if (spaced[mid] != null && spaced[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;
-        }
-    }
 }