Paper

Binary Heap dengan Implementasi Array

Nama : Dwiko Satriyo. U. Y. S
NIM

: M0515008

Binary heap yaitu sebuah binary tree (pohon biner) yang menyimpan
pasangan prioritas (elemen) pada node. Strukturnya memiliki ciri semua level
kecuali terakhir terisi penuh. Diutamakan penuh di bagian kiri. Prioritas yang
terdapat pada sebuah node harus lebih besar atau sama daripada parent-nya.
Sebuah binary heap dapat diimplementasikan dalam sebuah array,
sehingga berbentuk urutan angka dengan pola tertentu. Digunakan algoritma
tertentu untuk operasi sebuah node, yaitu :

Mencari Parent dari Sebuah Node(i)

Dapat menggunakan rumus i/2, di mana i merupakan posisi node saat
ini.
Implementasi pada program dapat berupa :
Return i/2;
Mencari Left dari Sebuah Node(i)
Dapat menggunakan rumus 2*i, di mana i merupakan posisi node saat
ini.
Implementasi pada program dapat berupa :
Return 2i;
Mencari Right dari Sebuah Node(i)
Dapat menggunakan rumus 2*i+1, di mana i merupakan posisi node
saat ini.
Implementasi pada program dapat berupa :
Return 2i+1;
Insertion
Mengisi sebuah binary heap dimulai dari kiri. Bila node yang diinputkan
lebih kecil dari parent-nya, maka dilakukan heapify. Bila node sudah lebih
besar dari parent-nya, maka operasi dihentikan/bernilai selesai.
public void insert(int x)
{
if (isFull( ) )
throw new NoSuchElementException("Overflow
Exception");
/** Percolate up **/
heap[heapSize++] = x;
heapifyUp(heapSize - 1);
}
Delete Min

Operasi untuk menghapus root yang dilanjutkan dengan operasi heapify

down untuk meposisikan node sesuai dengan aturan binary heap.
public int deleteMin()
{
int keyItem = heap[0];
delete(0);
return keyItem;
}
public int delete(int ind)
{
if (isEmpty() )
throw new NoSuchElementException("Underflow
Exception");
int keyItem = heap[ind];
heap[ind] = heap[heapSize - 1];
heapSize--;
heapifyDown(ind);
return keyItem;
}
Heapify
Heapify adalah operasi untuk mengkoreksi angka/nilai pada binary heap
sesuai dengan aturannya dengan menukar node yang lebih kecil dengan
yang lebih besar hingga binary tree sesuai dengan aturan binar heap.
Terdapat 2 macam operasi pada heapify, yaitu heapify down dan heapify
up.
Heapify down menukar node dengan urutan dari bawah ke atas. Heapify
down diperlukan setelah dilakukan deletemin (mengambil/menghapus
root). Yaitu dengan menukar/memindahkan node child yang paling kecil
ke root.
private void heapifyDown(int ind)
{
int child;
int tmp = heap[ ind ];
while (kthChild(ind, 1) < heapSize)
{
child = minChild(ind);
if (heap[child] < tmp)
heap[ind] = heap[child];
else
break;
ind = child;
}
heap[ind] = tmp;
}

Heapify up yaitu memposisikan node dengan cara menukar node yang

baru di insert/masukkan dengan parent yang lebih kecil darinya hingga
memenuhi aturan binary heap.
private void heapifyUp(int childInd)
{
int tmp = heap[childInd];
while (childInd > 0 && tmp < heap[parent(childInd)])
{
heap[childInd] = heap[ parent(childInd) ];
childInd = parent(childInd);
}
heap[childInd] = tmp;
}