fix: Final correction for smoothsort

Author: NarenCK11

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

@@ -17,58 +17,16 @@
  * @see <a href="https://en.wikipedia.org/wiki/Smoothsort">Wikipedia: Smoothsort</a>
  */
 public final class SmoothSort {
+    // clang-format off
 
     /**
      * Private constructor to prevent instantiation of this utility class.
      */
-    private SmoothSort() {
-    }
+    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,
     };
 
     /**
@@ -82,11 +40,11 @@ public static <T extends Comparable<T>> void sort(T[] arr) {
             return;
         }
         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
-        long p = 1; // A bitmask representing the sizes of the heaps.
-        int q = 1; // Size of the rightmost heap
 
-        // Phase 1: Build the forest of heaps
         while (head < n) {
             if ((p & 3) == 3) {
                 // Combine the last two heaps
@@ -96,7 +54,6 @@ public static <T extends Comparable<T>> void sort(T[] arr) {
                 p >>>= 1;
                 q = 1;
             }
-
             p |= 1L << q;
 
             while (head + LP[q] > n) {
@@ -107,7 +64,6 @@ public static <T extends Comparable<T>> void sort(T[] arr) {
             trinkle(arr, head - 1, p, q);
         }
 
-        // Phase 2: Deconstruct the forest to sort the array
         for (head = n - 1; head > 0; head--) {
             if (q <= 1) {
                 p >>>= q;
@@ -123,6 +79,24 @@ public static <T extends Comparable<T>> void sort(T[] arr) {
         }
     }
 
+    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;
+            }
+            q = prevHeapOrder;
+        }
+        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;
@@ -131,6 +105,7 @@ private static <T extends Comparable<T>> void sift(T[] arr, int head, int order)
             if (arr[head].compareTo(arr[leftChild]) >= 0 && arr[head].compareTo(arr[rightChild]) >= 0) {
                 break;
             }
+
             if (arr[leftChild].compareTo(arr[rightChild]) > 0) {
                 swap(arr, head, leftChild);
                 head = leftChild;
@@ -143,26 +118,11 @@ private static <T extends Comparable<T>> void sift(T[] arr, int head, int order)
         }
     }
 
-    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;
-            }
-            q = prevHeapOrder;
-        }
-        sift(arr, head, q);
-    }
-
     private static <T> void swap(T[] arr, int i, int j) {
         T temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;
     }
+
+    // clang-format on
 }