dataStructure@ Implementation of minimal heap

A binary heap is a heap data struc­ture cre­ated using a binary tree.

binary tree has two rules -

1. Binary Heap has to be com­plete binary tree at all lev­els except the last level. This is called shape prop­erty.
2. All nodes are either greater than equal to (Max-Heap) or less than equal to (Min-Heap) to each of its child nodes. This is called heap prop­erty.

Imple­men­ta­tion:

• Use array to store the data.
• Start stor­ing from index 1, not 0.
• For any given node at posi­tion i:
• Its Left Child is at [2*i] if available.
• Its Right Child is at [2*i+1] if available.
• Its Par­ent Node is at [i/2]if avail­able.

   

 Heap Majorly has 3 operations -

1. Insert Oper­a­tion
2. Delete Oper­a­tion
3. Extract-Min (OR Extract-Max)

Insert Oper­a­tion:

• Add the ele­ment at the bot­tom leaf of the Heap.
• Per­form the Bubble-Up operation.
• All Insert Oper­a­tions must per­form the bubble-up oper­a­tion(it is also called as up-heap, percolate-up, sift-up, trickle-up, heapify-up, or cascade-up)

Bubble-up Oper­a­tion:

• If inserted ele­ment is smaller than its par­ent node in case of Min-Heap OR greater than its par­ent node in case of Max-Heap, swap the ele­ment with its parent.
• Keep repeat­ing the above step, if node reaches its cor­rect posi­tion, STOP.

Insert() — Bubble-Up Min-Heap

Extract-Min OR Extract-Max Operation:

• Take out the ele­ment from the root.( it will be min­i­mum in case of Min-Heap and max­i­mum in case of Max-Heap).
• Take out the last ele­ment from the last level from the heap and replace the root with the element.
• Per­form Sink-Down
• All delete oper­a­tion must per­form Sink-Down Oper­a­tion ( also known as bubble-down, percolate-down, sift-down, trickle down, heapify-down, cascade-down).

Sink-Down Oper­a­tion:

• If replaced ele­ment is greater than any of its child node in case of Min-Heap OR smaller than any if its child node in case of Max-Heap, swap the ele­ment with its small­est child(Min-Heap) or with its great­est child(Max-Heap).
• Keep repeat­ing the above step, if node reaches its cor­rect posi­tion, STOP.

Delete OR Extract Min from Heap

Delete Oper­a­tion:

• Find the index for the ele­ment to be deleted.
• Take out the last ele­ment from the last level from the heap and replace the index with this element .
• Per­form Sink-Down

Time and Space Complexity:

Space	O(n)
Search	O(n)
Insert	O(log n)
Delete	O(log n)

package data_structure_testing;

import java.util.ArrayList;
import java.util.HashSet;

public class MinHeap {

    public ArrayList<Integer> minheap = null;
    
    public MinHeap() {    
        this.minheap = new ArrayList<Integer> ();
        this.minheap.add(Integer.MIN_VALUE);
        /**
         * -------------------------------------------------------------------------
         * Integer.MIN_VALUE |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
         * -------------------------------------------------------------------------
         */
    }
    
    public void swap(int i, int j) {
        if(i == j)  return;
        int tmp = minheap.get(i);
        minheap.set(i, minheap.get(j));
        minheap.set(j, tmp);
    }
    
    public int getSize() {
        return minheap.size();
    }
    
    public int parent(int i) {
        return i/2;
    }
    
    public int leftChild(int i) {
        return i*2;
    }
    
    public int rightChild(int i) {
        return i*2 + 1;
    }
    
    public void offer(int x) {
        
        minheap.add(x);
        int position = minheap.size() - 1;
        bubbleUp(position);
    }
    
    public void bubbleUp(int position) {
        
        int pa = parent(position);
        if(pa != 0 && minheap.get(position) < minheap.get(pa)) {
            swap(position, pa);
            bubbleUp(pa);
        }
    }
    
    public int peek() {
        if(getSize() == 1) {
            System.out.println("the min heap is empty!");
            return minheap.get(0);
        } else{
            return minheap.get(1);
        }
    }
    
    public void pushDown(int i) {
        
        int min_position = i, min_value = minheap.get(i);
        int lc = leftChild(i), rc = lc + 1;
        
        if(lc >= getSize()) {
            return;
        }
        
        if(lc < getSize()) {
            if(minheap.get(lc) < min_value) {
                min_position = lc;
                min_value = minheap.get(lc);
            }
            if(rc < getSize() && minheap.get(rc) < min_value) {
                min_position = rc;
            }
        }
        
        swap(min_position, i);
        if(min_position != i) {
            pushDown(min_position);
        }
    }
    
    public int poll() {
        if(getSize() == 1) {
            System.out.println("since the min heap is empty, so we cannot poll any element from it!");
            return minheap.get(0);
        }
        
        int top = minheap.get(1);
        swap(1, getSize()-1);
        minheap.remove(getSize()-1);
        
        if(getSize() > 1) {
            pushDown(1);
        }
        
        return top;
    }
    
    public static void main(String[] args) {
        
        MinHeap minheap = new MinHeap();
        
        minheap.offer(5);
        minheap.offer(4);
        minheap.offer(2);
        minheap.offer(4);
        minheap.offer(3);
        
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());

    }

}