fix: Final correction for SmoothSort

Author: NarenCK11

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

@@ -19,14 +19,16 @@
 public final class SmoothSort {
     // clang-format off
 
-    /**
-     * Private constructor to prevent instantiation of this utility class.
-     */
+    /** Private constructor to prevent instantiation of this utility class. */
     private SmoothSort() {}
 
     // Leonardo numbers: L(0)=1, L(1)=1, L(k)=L(k-1)+L(k-2)+1
     private static final int[] LP = {
-        1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049, 242785, 392835, 635621, 1028457, 1664079, 2692537, 4356617, 7049155, 11405773, 18454929, 29860703, 48315633, 78176337, 126491971, 204668309, 331160281, 535828591, 866988873,
+        1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193,
+        5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049, 242785, 392835,
+        635621, 1028457, 1664079, 2692537, 4356617, 7049155, 11405773, 18454929,
+        29860703, 48315633, 78176337, 126491971, 204668309, 331160281, 535828591,
+        866988873,
     };
 
     /**
@@ -41,84 +43,102 @@ public static <T extends Comparable<T>> void sort(T[] arr) {
         }
         int n = arr.length;
 
-        int q = 0; // The order of the rightmost heap
-        long p = 1; // A bitmask representing the sizes of the heaps
-        int head = 0; // The head of the list to be sorted
+        int q = 0; // Order of the rightmost heap
+        long p = 1; // Bitmask representing heap sizes
+        int head = 0; // Current index in array
 
         while (head < n) {
             if ((p & 3) == 3) {
-                // Combine the last two heaps
                 p >>>= 2;
                 q += 2;
             } else {
-                p >>>= 1;
-                q = 1;
+                if ((p & 1) == 0) {
+                    p = (p << 1) | 1;
+                    q = 1;
+                } else {
+                    p <<= 1;
+                    q = 0;
+                }
             }
-            p |= 1L << q;
 
+            // Prevent out-of-bounds heap building
             while (head + LP[q] > n) {
-                p &= ~(1L << q);
+                p >>>= 1;
                 q--;
             }
+
+            trinkle(arr, head, p, q);
             head++;
-            trinkle(arr, head - 1, p, q);
         }
 
-        for (head = n - 1; head > 0; head--) {
+        // Sort the heaps
+        while (q != 0 || p != 1) {
             if (q <= 1) {
-                p >>>= q;
-                q = Long.numberOfTrailingZeros(p) + 1;
+                // Step back through the heaps
+                while ((p & 1) == 0) {
+                    p >>>= 1;
+                    q++;
+                }
+                p >>>= 1;
             } else {
                 p &= ~(1L << q);
                 q--;
-                int prevHeapOrder = Long.numberOfTrailingZeros(p) + 1;
-                sift(arr, head - LP[q], q);
-                p |= (1L << (prevHeapOrder - 1));
-                trinkle(arr, head - 1, p, prevHeapOrder);
+                int right = head - 1;
+                int left = head - 1 - LP[q];
+                sift(arr, left + LP[q], q);
+                sift(arr, right, q);
             }
+            head--;
         }
     }
 
     private static <T extends Comparable<T>> void trinkle(T[] arr, int head, long p, int q) {
-        while (q > 0) {
-            p &= ~(1L << q);
-            int prevHeapOrder = Long.numberOfTrailingZeros(p) + 1;
-
-            if (prevHeapOrder > 0) {
-                int parent = head - LP[q];
-                if (arr[parent].compareTo(arr[head]) >= 0) {
-                    break;
-                }
-                swap(arr, head, parent);
-                head = parent;
+        while (q > 1) {
+            int parent = head - LP[q];
+            if (parent < 0) {
+                return; // prevent negative index
             }
-            q = prevHeapOrder;
+
+            if (arr[head].compareTo(arr[parent]) <= 0) {
+                break;
+            }
+
+            swap(arr, head, parent);
+            head = parent;
+            q -= 2;
         }
         sift(arr, head, q);
     }
 
     private static <T extends Comparable<T>> void sift(T[] arr, int head, int order) {
         while (order >= 2) {
             int rightChild = head - 1;
-            int leftChild = head - LP[order] + LP[order - 1];
+            int leftChild = head - 1 - LP[order - 2];
 
-            if (arr[head].compareTo(arr[leftChild]) >= 0 && arr[head].compareTo(arr[rightChild]) >= 0) {
+            if (leftChild < 0 || rightChild < 0) {
+                return; // safety check
+            }
+
+            int largerChild =
+                    arr[leftChild].compareTo(arr[rightChild]) >= 0 ? leftChild : rightChild;
+
+            if (arr[head].compareTo(arr[largerChild]) >= 0) {
                 break;
             }
 
-            if (arr[leftChild].compareTo(arr[rightChild]) > 0) {
-                swap(arr, head, leftChild);
-                head = leftChild;
+            swap(arr, head, largerChild);
+            head = largerChild;
+
+            if (largerChild == leftChild) {
                 order -= 1;
             } else {
-                swap(arr, head, rightChild);
-                head = rightChild;
                 order -= 2;
             }
         }
     }
 
     private static <T> void swap(T[] arr, int i, int j) {
+        if (i == j) return;
         T temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;