Fix

Author: Hardvan

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

@@ -111,7 +111,7 @@ public String toString() {
     }
 
     /**
-     * @param otherHeapElement
+     * @param o : an object to compare with the current element
      * @return true if the keys on both elements are identical and the
      * additional info objects are identical.
      */
@@ -134,4 +134,8 @@ public int hashCode() {
         result = 31 * result + (additionalInfo != null ? additionalInfo.hashCode() : 0);
         return result;
     }
+
+    public String getValue() {
+        return additionalInfo.toString();
+    }
 }

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

@@ -45,18 +45,54 @@ public MaxHeap(List<HeapElement> listElements) {
         }
 
         maxHeap = new ArrayList<>();
+
+        // Safe initialization: directly add elements first
         for (HeapElement heapElement : listElements) {
             if (heapElement != null) {
-                insertElement(heapElement);
+                maxHeap.add(heapElement);
             } else {
                 System.out.println("Null element. Not added to heap");
             }
         }
+
+        // Then heapify the array bottom-up
+        for (int i = maxHeap.size() / 2; i >= 0; i--) {
+            heapifyDown(i + 1); // +1 because heapifyDown expects 1-based index
+        }
+
         if (maxHeap.isEmpty()) {
             System.out.println("No element has been added, empty heap.");
         }
     }
 
+    /**
+     * Maintains heap properties by moving an element down the heap.
+     * Similar to toggleDown but used specifically during initialization.
+     *
+     * @param elementIndex 1-based index of the element to heapify
+     */
+    private void heapifyDown(int elementIndex) {
+        int largest = elementIndex - 1;
+        int leftChild = 2 * elementIndex - 1;
+        int rightChild = 2 * elementIndex;
+
+        if (leftChild < maxHeap.size() && maxHeap.get(leftChild).getKey() > maxHeap.get(largest).getKey()) {
+            largest = leftChild;
+        }
+
+        if (rightChild < maxHeap.size() && maxHeap.get(rightChild).getKey() > maxHeap.get(largest).getKey()) {
+            largest = rightChild;
+        }
+
+        if (largest != elementIndex - 1) {
+            HeapElement swap = maxHeap.get(elementIndex - 1);
+            maxHeap.set(elementIndex - 1, maxHeap.get(largest));
+            maxHeap.set(largest, swap);
+
+            heapifyDown(largest + 1);
+        }
+    }
+
     /**
      * Retrieves the element at the specified index without removing it.
      * Note: The index is 1-based for consistency with heap operations.
@@ -147,7 +183,7 @@ private HeapElement extractMax() throws EmptyHeapException {
         if (maxHeap.isEmpty()) {
             throw new EmptyHeapException("Cannot extract from empty heap");
         }
-        HeapElement result = maxHeap.get(0);
+        HeapElement result = maxHeap.getFirst();
         deleteElement(1);
         return result;
     }
@@ -177,8 +213,8 @@ public void deleteElement(int elementIndex) throws EmptyHeapException {
         }
 
         // Replace with last element and remove last position
-        maxHeap.set(elementIndex - 1, maxHeap.get(maxHeap.size() - 1));
-        maxHeap.remove(maxHeap.size() - 1);
+        maxHeap.set(elementIndex - 1, maxHeap.getLast());
+        maxHeap.removeLast();
 
         // No need to toggle if we just removed the last element
         if (!maxHeap.isEmpty() && elementIndex <= maxHeap.size()) {

src/test/java/com/thealgorithms/datastructures/heaps/MaxHeapTest.java

@@ -1,12 +1,16 @@
 package com.thealgorithms.datastructures.heaps;
 
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.BeforeEach;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.util.Arrays;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 /**
  * Unit tests for MaxHeap implementation
@@ -18,13 +22,7 @@ class MaxHeapTest {
     @BeforeEach
     void setUp() {
         // Create a fresh heap for each test
-        List<HeapElement> elements = Arrays.asList(
-                new HeapElement(5.0, "Five"),
-                new HeapElement(2.0, "Two"),
-                new HeapElement(8.0, "Eight"),
-                new HeapElement(1.0, "One"),
-                new HeapElement(9.0, "Nine")
-        );
+        List<HeapElement> elements = Arrays.asList(new HeapElement(5.0, "Five"), new HeapElement(2.0, "Two"), new HeapElement(8.0, "Eight"), new HeapElement(1.0, "One"), new HeapElement(9.0, "Nine"));
         heap = new MaxHeap(elements);
     }
 
@@ -41,11 +39,7 @@ void testConstructorWithEmptyList() {
 
     @Test
     void testConstructorWithNullElements() {
-        List<HeapElement> elements = Arrays.asList(
-                new HeapElement(1.0, "One"),
-                null,
-                new HeapElement(2.0, "Two")
-        );
+        List<HeapElement> elements = Arrays.asList(new HeapElement(1.0, "One"), null, new HeapElement(2.0, "Two"));
         MaxHeap heap = new MaxHeap(elements);
         assertEquals(2, heap.size());
     }
@@ -76,7 +70,7 @@ void testGetElementAtInvalidIndex() {
     }
 
     @Test
-    void testDeleteElement() {
+    void testDeleteElement() throws EmptyHeapException {
         heap.deleteElement(1);
         assertEquals(8.0, heap.getElement(1).getKey());
         assertEquals(4, heap.size());
@@ -140,7 +134,7 @@ void testSizeAndEmpty() {
             try {
                 heap.getElement();
             } catch (EmptyHeapException e) {
-                fail("Should not throw EmptyHeapException while heap is not empty");
+                Assertions.fail("Should not throw EmptyHeapException while heap is not empty");
             }
         }