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 -

Binary Heap has to be com­plete binary tree at all lev­els except the last level. This is called shape prop­erty.

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.

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());

}

}

min heap