Removed Helper Class, formatted to make items final.

Author: JAPNITSINGH

src/main/java/com/thealgorithms/datastructures/heaps/LeonardoHeap.java

@@ -1,10 +1,12 @@
 package com.thealgorithms.datastructures.heaps;
 
-import com.thealgorithms.bitmanipulation.SingleBitOperations;
-import com.thealgorithms.maths.LeonardoNumber;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
+import com.thealgorithms.bitmanipulation.SingleBitOperations;
+import com.thealgorithms.maths.LeonardoNumber;
+
 /**
  * Wikipedia: https://en.wikipedia.org/wiki/Smoothsort
  */
@@ -17,7 +19,7 @@ public LeonardoHeap() {
     }
 
     private void decreaseLevelTracker() {
-        int lastTreeLevel = getRightMostTree();
+        final int lastTreeLevel = getRightMostTree();
         levelTracker = SingleBitOperations.clearBit(levelTracker, lastTreeLevel);
         if (lastTreeLevel != 0 && lastTreeLevel != 1) {
             levelTracker = SingleBitOperations.setBit(levelTracker, lastTreeLevel - 1);
@@ -26,7 +28,7 @@ private void decreaseLevelTracker() {
     }
 
     private void increaseLevelTracker() {
-        ArrayList<Integer> consecutiveTreeIndices = LeonardoHeapHelper.findConsecutiveTreeIndices(levelTracker);
+        final ArrayList<Integer> consecutiveTreeIndices = findConsecutiveTreeIndices(levelTracker);
         if (consecutiveTreeIndices.get(0) != -1) {
             // if 0th or 1st index is -1 that implies there are no concequtive trees
             levelTracker = SingleBitOperations.clearBit(levelTracker, consecutiveTreeIndices.get(0));
@@ -49,16 +51,10 @@ private void maxHeapifyTree(int rootNodeIndex, int currentLevel) {
             return; // Trees with one node are in already max-heapified.
         }
 
-        int currentRootNodeIndex = rootNodeIndex;
-        int rightChildIndex = rootNodeIndex - 1;
-        int leftChildIndex = rootNodeIndex - LeonardoNumber.leonardoNumber(currentLevel - 2) - 1;
-        int childIndexForSwap = -1;
-
-        if (heap.get(rightChildIndex).compareTo(heap.get(leftChildIndex)) >= 0) {
-            childIndexForSwap = rightChildIndex;
-        } else {
-            childIndexForSwap = leftChildIndex;
-        }
+        final int currentRootNodeIndex = rootNodeIndex;
+        final int rightChildIndex = rootNodeIndex - 1;
+        final int leftChildIndex = rootNodeIndex - LeonardoNumber.leonardoNumber(currentLevel - 2) - 1;
+        final int childIndexForSwap = (heap.get(rightChildIndex).compareTo(heap.get(leftChildIndex)) >= 0) ? rightChildIndex : leftChildIndex;
 
         if (heap.get(childIndexForSwap).compareTo(heap.get(currentRootNodeIndex)) > 0) {
             swap(currentRootNodeIndex, childIndexForSwap);
@@ -76,7 +72,7 @@ private void shiftRootAndRestoreHeap() {
             return;
         }
 
-        Integer[] currentTreeLevels = LeonardoHeapHelper.findAllTreeIndices(levelTracker);
+        final Integer[] currentTreeLevels = findAllTreeIndices(levelTracker);
         int previousTreeSizeCumulative = 0;
         ArrayList<Integer> rootNodeIndices = new ArrayList<Integer>();
 
@@ -90,34 +86,35 @@ private void shiftRootAndRestoreHeap() {
 
         int rootNodeIndexForHeapify = rootNodeIndices.getLast();
         int treeLevelforHeapify = currentTreeLevels[currentTreeLevels.length - 1];
-        boolean swaped = false;
 
         for (int i = 1; i < rootNodeIndices.size(); i++) {
 
             int currentRootNodeIndex = rootNodeIndices.get(i);
             int prevRootNodeIndex = rootNodeIndices.get(i - 1);
             int j = i;
+            boolean swapped = false;
+
             while (heap.get(prevRootNodeIndex).compareTo(heap.get(currentRootNodeIndex)) > 0) {
-                int currentLevel = currentTreeLevels[j];
+                final int currentLevel = currentTreeLevels[j];
                 if (currentLevel > 1) {
                     // compare child and swap
 
-                    int indexOfRightChild = rootNodeIndices.get(j) - 1; // right child is of level n-2
-                    int indexOfLeftChild = rootNodeIndices.get(j) - 1 - LeonardoNumber.leonardoNumber(currentLevel - 2);
-                    if (heap.get(prevRootNodeIndex).compareTo(heap.get(indexOfRightChild)) > 0 && heap.get(prevRootNodeIndex).compareTo(heap.get(indexOfLeftChild)) > 0) {
+                    final int rightChildIndex = rootNodeIndices.get(j) - 1; // right child is of level n-2
+                    final int leftChildIndex = rootNodeIndices.get(j) - 1 - LeonardoNumber.leonardoNumber(currentLevel - 2);
+                    if (heap.get(prevRootNodeIndex).compareTo(heap.get(rightChildIndex)) > 0 && heap.get(prevRootNodeIndex).compareTo(heap.get(leftChildIndex)) > 0) {
                         swap(prevRootNodeIndex, currentRootNodeIndex);
                         rootNodeIndexForHeapify = prevRootNodeIndex;
                         treeLevelforHeapify = currentTreeLevels[j - 1];
-                        swaped = true;
+                        swapped = true;
                     } else {
                         maxHeapifyTree(currentRootNodeIndex, currentLevel);
-                        swaped = false;
+                        swapped = false;
                     }
                 } else {
                     swap(prevRootNodeIndex, currentRootNodeIndex);
                     rootNodeIndexForHeapify = prevRootNodeIndex;
                     treeLevelforHeapify = currentTreeLevels[j - 1];
-                    swaped = true;
+                    swapped = true;
                 }
                 j = j - 1;
                 if (j > 0) {
@@ -129,9 +126,8 @@ private void shiftRootAndRestoreHeap() {
                 }
             }
 
-            if (swaped) {
+            if (swapped) {
                 maxHeapifyTree(rootNodeIndexForHeapify, treeLevelforHeapify);
-                swaped = false;
             }
         }
 
@@ -152,9 +148,7 @@ private int getRightMostTree() {
     }
 
     private void swap(int i, int j) {
-        T temp = heap.get(i);
-        heap.set(i, heap.get(j));
-        heap.set(j, temp);
+        Collections.swap(heap, i, j);
     }
 
     public void addElement(T element) {
@@ -165,9 +159,43 @@ public void addElement(T element) {
 
     public T removeElement() {
         decreaseLevelTracker();
-        T element = heap.removeLast();
+        final T element = heap.removeLast();
         shiftRootAndRestoreHeap();
 
         return element;
     }
+
+    private static ArrayList<Integer> findConsecutiveTreeIndices(int num) {
+        int prevOneIndex = -1;
+        int currentLevel = 0;
+
+        ArrayList<Integer> answer = new ArrayList<Integer>();
+        answer.add(-1);
+        answer.add(-1);
+
+        for (int i = 0; num > 0; i++) {
+            currentLevel = num & 1;
+            if (currentLevel == 1) {
+                if (prevOneIndex != -1) {
+                    answer.set(0, prevOneIndex);
+                    answer.set(1, i);
+                }
+                prevOneIndex = i;
+            } else {
+                prevOneIndex = -1;
+            }
+            num >>>= 1;
+        }
+        return answer;
+    }
+
+    private static Integer[] findAllTreeIndices(int num) {
+        List<Integer> setBitIndexes = new ArrayList<>();
+        for (int i = Integer.SIZE - 1; i >= 0; i--) {
+            if ((num & (1 << i)) != 0) {
+                setBitIndexes.add(i);
+            }
+        }
+        return setBitIndexes.toArray(new Integer[0]);
+    }
 }