Heap Sort

HeapSort adalah algoritma pengurutan data berdasarkan perbandingan, dan

termasuk golongan selection sort. Walaupun lebih lambat daripada quick sort pada
kebanyakan mesin , tetapi heap sort mempunyai keunggulan yaitu kompleksitas
algoritma pada kasus terburuk adalah n log n.
Algoritma pengurutan heap sort ini mengurutkan isi suatu larik masukan
dengan memandang larik masukan sebagai suatu Complete Binary Tree (CBT).
Setelah itu Complete Binary Tree (CBT) ini dapat dikonversi menjadi suatu heap
tree. Setelah itu Complete Binary Tree (CBT) diubah menjadi suatu priority queue.
Algoritma pengurutan heap dimulai dari membangun sebuah heap dari
kumpulan data yang ingin diurutkan, dan kemudian menghapus data yang
mempunyai nilai tertinggi dan menempatkan dalam akhir dari larik yang telah
terurut. Setelah memindahkan data dengan nilai terbesar, proses berikutnya adalah
membangun ulang heap dan memindahkan nilai terbesar pada heap tersebut dan
menempatkannya dalam tempat terakhir pada larik terurut yang belum diisi data
lain. Proses ini berulang sampai tidak ada lagi data yang tersisa dalam heap dan
larik yang terurut penuh. Dalam implementasinya kita membutuhkan dua larik
satu untuk menyimpan heap dan satu lagi untuk menyimpan data yang sudah
terurut.
Tetapi untuk optimasi memori, kita dapat menggunakan hanya satu larik saja, yaitu
dengan cara menukar isi akar dengan elemen terakhir dalam heap tree. Jika memori
tidak menjadi masalah maka dapat tetap menggunakan dua larik yaitu larik
masukan dan larik hasil.
Perbandingan nilai suatu node dengan nilai node child-nya mempunyai ketentuan
berdasarkan jenis heap, diantaranya :

Max Heap mempunyai ketentuan bahwa nilai suatu node lebih besar atau
sama
dengan ( >= ) dari nilai childnya.
Min Heap mempunyai ketentuan bahwa nilai suatu node lebih kecil atau
sama dengan ( <= ) dari nilai childnya.

1. Algoritma Heapify
Algoritma Heapify adalah membangun sebuah heap dari bawah ke atas, secara
berturut-turut berubah ke bawah untuk membangun heap. Permasalahan pertama
yang harus kita pertimbangkan dalam melakukan operasi heapify adalah dari
bagian mana kita harus memulai. Bila kita mencoba operasi heapify dari akar maka
akan terjadi operasi runut-naik seperti algoritma bubble sort yang akan
menyebabkan kompleksitas waktu yang ada akan berlipat ganda. Sebuah versi lain
adalah membangun heap secara atas-bawah dan berganti-ganti ke atas untuk
secara konseptual lebih sederhana untuk ditangani. Versi ini mulai dengan sebuah
heap kosong dan secara berturut-turut memasukkan data. Versi lainnya lagi adalah
dengan membentuk pohon heap-pohon heap mulai dari subtree-subtree yang paling
bawah. Jika subtree-subtree suatu simpul sudah membentuk heap maka pohon dari
simpul tersebut mudah dijadikan pohon heap dengan mengalirkannya ke bawah.
Setelah diuji, maka ide yang paling efisien adalah versi yang terakhir, yang
kompleksitas algoritmanya pada kasus terburuk adalah O(n), sedangkan versi
membentuk heap tree-heap tree dari atas ke bawah kompleksitas nya O(n log n).
Jadi, algoritma utama heapify adalah melakukan iterasi mulai dari internal simpul
paling kanan bawah(pada representasi larik, adalah elemen yang berada di indeks
paling besar) hingga akar, kemudian kearah kiri dan naik ke level di atasnya, dan
seterusnya hingga mencapai akar (sebagai larik [0..N-1]). Oleh karena itu, iterasi
dilakukan mulai dari j= N/2 dan berkurang satu-satu hingga mencapai j=0. Pada
simpul internal tersebut, pemeriksaan hanya dilakukan pada simpul anaknya
langsung (tidak pada level-level lain di bawahnya). Pada saat iterasi berada di level
yang lebih tinggi, subtreesubtree selalu sudah membentuk heap. Jadi, kasus yang
paling buruk adalah restrukturisasi hanya akan mengalirkan simpul tersebut kearah
bawah. Dengan demikian, heapify versi ini melakukan sebanyak N/2 kali iterasi, dan
pada kasus yang paling buruk akan melakukan iterasi sebanyak log(N) kali.
2. Algoritma Remove

Algoritma remove ini menukar akar (yang berisi nilai maksimum) dari heap
dengan elemen terakhir. Secara logika, simpul yang berada paling kanabawah
dipindahkan ke akar untuk menggantikan simpul akar yang akan diambil.
3. Algoritma Reheapify
Algoritma reheapify ini melakukan pembuatan ulang heap dari atas ke bawah
seperti halnya iterasi terakhir dari algoritma metoda heapify. Perbedaan antara
metode heapify dengan metode reheapify ada pada iterasi yang dilakukan oleh
kedua algoritma tersebut. Algoritma metode reheapify ini hanya melakukan iterasi
terakhir dari algoritma heapify. Hal ini disebabkan baik subtree kiri maupun subtree
kanannya sudah merupakan heap, sehingga tidak perlu dilakukan iterasi lengkap
seperti algoritma heapify. Dan setelah reheapify maka simpul yang akan diiterasikan
berikutnya akan berkurang satu.

Algoritma Untuk Heap Sort

Berikut merupakan algoritma dari heap sort :
1. Representasikan Heap dengan n elemen dalam sebuah array A[n]

2. Elemen root tempatkan pada A[1]

3. Elemen A[2i] adalah node kiri dibawah A[i]
4. Elemen A[2i+1] adalah node kanan dibawah A[i]
5. Contoh: array A=[16 14 10 8 7 9 3 2 4 1] mewakili binary-heap sbb:
6. Ambil nilai root (terbesar) A[1..n-1] dan pertukarkan dengan elemen terakhir dalam array, A[n]
7. Bentuk Heap dari (n-1) elemen, dari A[1] hingga A[n-1]
8. Ulangi langkah 6 dimana indeks terakhir berkurang setiap langkah.

Contoh Heap Sort

Terdapat data 16, 14, 10, 8, 7, 9, 2, 4, 1. Data-data tersebut dimasukkan dalam tree secara langsung dari
atas ke bawah dan dari kiri ke kanan.

Selanjutnya dilakukan heap sort seperti pada gambar berikut :

Program Heap Sort & Penjelasannya

<#include <>
void restoreHup(int*,int);

// pemanggilan fungsi void restoreHup

void restoreHdown(int*,int,int); //pemanggilan fungsi void restoreHdown

void main()
{
int a[20],n,i,j,k;
adalah integer

// pembuka void main

//

printf(" Masukkan jumlah element : "); //

memasukkan jumlah element
scanf("%d",&n);
melalui keyboard
printf(" Masukkan element : ");
memasukkan element

mendeklarasikan
untuk

bahwa

menampilkan

a[20]

kelayar

,n,i,j,k

perintah

// untuk mengidentifikasikan nilai yang dimasukkan

//untuk menampilkan kelayar perintah untuk

for(i=1;i<=n;i++)
//funsi for dimana jika ketentuan untuk i terpenuhi
maka progran di bawahnya akan dijalankan
{

// pembuka fungsi for

scanf("%d",&a[i]);

// untuk mengidentifikasi array a

restoreHup(a,i);

// a , i dalam fungsi restoreHup

// penutup fungsi for

j=n;

// nilai j sama dengan n

for(i=1;i<=j;i++)

//funsi for dimana jika ketentuan untuk i terpenuhi

maka progran di bawahnya akan dijalankan

// pembuka fungsi for

int temp;

// temp sebagai integer

temp=a[1];

// temp sama dengan nilai array a yang pertama

a[1]=a[n];
n

// nilai array a yg ke 1 sama dengan array a yang ke

a[n]=temp;

// nilai array a yang ke n sama dengan nilay temp

n--;

// nilai n selalu berkurang 1

restoreHdown(a,1,n);

// a , 1, n dalam fungsi restoreHdown

// penutup fungsi for

n=j;

// n sama dengan nilai j

printf(" Here is it... ");

layar

// untuk menampilkan perintah ke dalam

for(i=1;i<=n;i++)

//funsi for dimana jika ketentuan untuk i terpenuhi

maka progran di bawahnya akan dijalankan

printf("%4d",a[i]);

// untuk menampilkan nilai array ke i ke layar

// penutup void main

void restoreHup(int *a,int i)

// fungsi void restore Hup

// pembuka fungsi foid restoreHup

int v=a[i];

// v sama dengan nilai array a yang ke i

while((i>1)&&(a[i/2]
{

// pembuka fungsi while

a[i]=a[i/2];
yang ke i/2

// nilai array a yang ke i sama dengan nilai array a

i=i/2;

// nilai i sama dengan nilai i/2

//penutup fungsi while

a[i]=v;
}

// nilai array a yang ke i sama dengan nilai v

// penutup fungsi while

void restoreHdown(int *a,int i,int n)

// fungsi void restoreHdown

// pembuka fungsi void restoreHdown

int v=a[i];
integer

// v sama dengan nilai array a yang ke i sebagai

int j=i*2;

// nilai j sama dengan i kali 2 ialah integer

while(j<=n)
terpenuhi

// fungsi while akan dijalankan bila ketentuannya

// pembuka fungsi while

if((j<n)&&(a[j]></n)&&(a[j]>
j++;

// nilai j akan selalu tambah 1

if(a[j]
break;
a[j/2]=a[j];
yang ke j

// nilai array a yang ke j/2 sama dengan nilai array a

j=j*2;

// nilai j sama dengan nilai j*2

// penutup fungsi while

a[j/2]=v;

// nilai array a yang ke j/2 sama dengan v

// penutup fungsi void restorehdown

Kesimpulan

Algoritma pengurutan heap sort dapat digunakan untuk menyelesaikan

masalah-masalah pengurutan dalam membangun suatu program aplikasi

dengan mangkus.
Keunggulan algoritma pengurutan heap sort terletak pada kompleksitas
waktu asimptotiknya yang sangat baik.
Meskipun lebih lambat dari algoritma pengurutan data yang lain, algoritma
heap sort memiliki kelebihan ketika menangani data dalam skala yang
besar/massive. Karena algoritma ini memiliki kelebihan tidak menggunakan
banyak tabel, tetapi hanya satu tabel yang dipakai untuk menyimpan hasil
dari pengurutan tersebut.

Referensi / Daftar Pustaka

http://www.informatika.org/~rinaldi/Matdis/2008-2009/Makalah2008/Makalah0809046.pdf
http://www.informatika.org/~rinaldi/Stmik/Makalah/MakalahStmik08.pdf
http://www.ilmu-komputer.net/algorithms/heap-sort-source-code/
http://artofartikel.blogspot.com/2012/06/heap-sort.html