Trying to implement min-heap using logic of max-heap

Question

I am trying to implement min-heap which includes methods like insert,delete and heap sort.I am using implementation of max-heap and trying to convert it to min-heap.But,i am having some minor issues.It's a very straight-forward method ,but i am missing something,which i am not able to get.

This is the Helper Max-heap implementation i am using:

public void trickleDown(int index)
{
int largerChild;
Node top = heapArray[index]; // save root
while(index < currentSize/2) // while node has at
{ // least one child,
int leftChild = 2*index+1;
int rightChild = leftChild+1;
// find larger child
if( rightChild < currentSize && // (rightChild exists?)
heapArray[leftChild].getKey() <
heapArray[rightChild].getKey() )
largerChild = rightChild;
else
largerChild = leftChild;
// top >= largerChild?
if(top.getKey() >= heapArray[largerChild].getKey())
break;
// shift child up
heapArray[index] = heapArray[largerChild];
index = largerChild; // go down
} // end while
heapArray[index] = top; // index <- root
} // end trickleDown()

/////// My Implementation


 /** Removes the top element of the heap and returns it.
 * 
 * Complexity: O(log n)
 * @return Top (min/max) element of the heap.
 * @throws IllegalStateException if the heap is empty.
 */
 T remove() {

    if (size == 0) {
        throw new IllegalStateException();
    }

    Comparable root = data[0];
    data[0] = data[size-1];
    size--;
    trickleDown(0);
    return  (T) root;


  }



private void trickleDown(int i) {

 int largerChild;
 Comparable top = data[i]; // save root
 while(i > size/2 ) // not on bottom row{
 int leftChild = left(i);
 int rightChild = right(i);
 if(rightChild > size && data[left(i)].compareTo(data[right(i)]) < 0 )
 largerChild = leftChild;
 else
 largerChild = rightChild;

 if(data[i].compareTo(data[right(i)]) <= 0 )
 break;

 data[i] = data[largerChild];
 i = largerChild; 
 } 
 data[i] = top; 
}

///// Test File

 void checkHeapOrder(MinHeap h) {
    assertTrue(h != null);

    for(int i = 1; i < h.size() / 2; ++i) 
        assertTrue("Heap order property is broken at element at position " 
        + i,
                   h.data[i].compareTo(h.data[i*2]) < 0 && 
                   h.data[i].compareTo(h.data[i*2 + 1]) < 0);
   }


@Test
public void testRemove() {
    System.out.println("remove");
    MinHeap h = new MinHeap(10);

    boolean throws_exception = false;
    try {
        h.remove();
    } catch (IllegalStateException e) {
        throws_exception = true;
    } catch (Throwable e) {

    }
    assertTrue("remove throws an exception when empty", throws_exception);

    // Permutation of 0...9
    int[] input = { 0, 5, 9, 2, 3, 1, 6, 8, 7, 4 };

    for(int i : input)                    
        h.insert(i);  

    assertTrue(h.isFull());

    for(int i = 10; i > 0; --i) {
        assertEquals(h.size(), i);
        Integer x = (Integer)h.remove();
        assertEquals(x, new Integer(10-i)); // Items are removed in correct order
        checkHeapOrder(h);
    }

testRemove Failed: expected<0> but was <1>

I am pretty sure that the code is simple and i have tried to change everything from max to min,but just missing on with something,which i am having a hard time figuring out.

Do you have a working implementation of the min-heap? In that case it may be easier/more generic to use a comparator instead of calls to `compareTo`. Then you can keep the same algorithm and just switch the comparator. That will give you a correct algorithm without having to implement anything new. — Daniel Junglas, Nov 05 '19 at 07:15
No,that's why i am going this way.Can i implement min from max by just switching the comparator.? I did that,but the logic is little more than that.Hope you can help.Thanks. — Meet Yeole, Nov 05 '19 at 07:32

Trying to implement min-heap using logic of max-heap

0 Answers0