Heapsort

10.2 Heap

10.2.9 Heapsort

Apakah Anda masih ingat denganselection sort? Berikut adalah ringkasan langkah-langkahnya: 1. Pilih elemen terkecil, lalu tempatkan di paling awal data.

2. Ulangi hingga seluruh data terurut menaik.

Pada selection sort, langkah pencarian elemen terkecil dilakukan dengan linear search.

Langkah ini bisa kita optimisasikan menggunakan struktur dataheap, yang bisa mencari elemen terkecil dengan kompleksitas logaritmik. Algoritma pengurutan menggunakanheap ini dinamakan

heapsort. Implementasinya ditunjukkan pada Algoritma61.

Algoritma 61Prosedurheapsort untuk mengurutkanarray Adengan ukuranN secara menaik.

1: procedureHEAPSORT(A,N)

2: MAKEHEAP(A, N) ⊲Heap yang dibuat adalahmin-heap

3: fori_←0, N₋1do

4: A[i]_←TOP() ⊲Simpan elemen terkecil ke-i pada posisi ke-i

5: POP() ⊲Hapus elemen terkecil ke-i dariheap

6: end for

7: end procedure

Mari kita analisis kompleksitas dari algoritmaheapsort. Sebagaimana dijelaskan pada bagian sebelumnya, operasiMAKEHEAPmemiliki kompleksitas waktuO(N). Kemudian, kita melakukanN kali operasiPOP, yang masing-masing memiliki kompleksitas waktuO(logN). Maka, kompleksitas waktu dari algoritmaheapsort adalahO(N+NlogN)=O(NlogN).

Heapsort memiliki kompleksitas waktu yang sama denganquicksort maupunmerge sort,

yakniO(NlogN). Namun,heapsort memiliki keuntungan yang tidak dimiliki keduanya, yaitu bisa melakukanpartial sort (pengurutan parsial).

Pengurutan parsial adalah aktivitas mengurutkanKelemen terkecil (atau terbesar) saja dari suatuarray. Selection sort juga bisa melakukan pengurutan parsial, namun membutuhkan waktu O(NK). Denganheapsort, untuk melakukan pengurutan parsial kita cukup melakukan operasi

POPsebanyakKkali saja. Kompleksitas waktunya menjadiO(N+KlogN), yang lebih baik dari O(NK).

Setelah Anda memahami cara merepresentasikan dan menyelesaikan persoalan graf seder- hana, kini waktunya untuk mempelajari algoritma graf yang lebih rumit. Algoritma yang akan dipelajari pada bab ini adalah penyelesaian untuk permasalahan yang klasik pada graf, yaitu pencarianshortest path danMinimum Spanning Tree (MST).

Untuk memulai pembahasan tentang algoritma graf, asumsikan: • V menyatakan banyaknyanode.

• E menyatakan banyaknyaedge.

• w[a][b]menyatakan bobotedge yang menghubungkannode adengannode b. • Node pada graf dinomori dari1sampai denganV.

• ad j(x)menyatakan himpunannode yang merupakan tetangga darinode x.

11.1

Shortest Path

Salah satu persoalan umum yang dihadapi pada permasalahan graf adalah pencarianshortest path (jalur terpendek). Defi_{nisi masalah yang diberikan adalah: diberikan graf, cari serangkaian}

edge yang perlu dilalui mulai dari suatunode menuju suatunode lainnya, sedemikian sehingga jumlah bobot dariedge yang dilalui sekecil mungkin. Pada kasus graf tidak berbobot, kita dapat mengasumsikan bobot setiapedge adalah 1.

Defi_{nisi bobot dan jalur terpendek bergantung pada masalah yang dihadapi. Misalnya bobot}

edge pada suatu graf yang merepresentasikan kota dan jalan menyatakan waktu tempuh, berarti

shortest path menyatakan total waktu tempuh paling sedikit yang diperlukan untuk berpindah

dari suatu kota ke kota lainnya.

Terdapat beberapa algoritma yang menyelesaikan masalah shortest path. Apabila kita diberikan graf yang tidak berbobot, pencarianshortest path dapat menggunakan penelusuran graf secara BFS. Untuk graf berbobot, diperlukan algoritma yang lebih kompleks. Pada bab ini, kita akan mempelajari algoritma Dijkstra, Bellman—_{Ford, dan Floyd}—_{Warshall. Nama ketiga}

algoritma tersebut berasal dari nama pencipta-penciptanya.

11.1.1

Dijkstra

Konsep

Algoritma Dijkstra menggunakan konsepgreedy untuk menemukanshortest path dari suatu node, misalnyas, ke semuanode lainnya. Untuk setiap tahapan, diperlukan pencatatan informasi berikut untuk seluruhnode:

• visited[x]: bernilaitrueapabila suatunode xtelah dikunjungi.

Sebagai tambahan, kita juga dapat mencatatnode mana yang dikunjungi sebelum mencapai suatu node xpadashortest path. Kita nyatakan node tersebut sebagai pred[x]. Informasi ini diperlukan apabila Anda membutuhkanedge-edge mana yang perlu digunakan padashortest path.

◮◮Sekilas Info◭◭

Apabila soal yang dihadapi tidak membutuhkan informasiedge-edge yang perlu diguna- kan pada shortest path, Anda dapat menghemat waktu dan pengetikan kode dengan mengabaikan pred[x].

Pada awalnya, seluruhnode xmemiliki nilaidist[x] =∞_{, dan}visited[x] = f alse. Khusus untuk node s, kita mengetahui bahwa jarak terpendek untuk mencapaisdarissendiri adalah0. Oleh sebab itu,dist[s] =0. Seluruh nilai pred[x]bisa kita isi−1, sebab tidak diketahuinode mana yang dikunjungi sebelumx.

Setelah inisialisasi selesai dilakukan, jalankan langkah-langkah berikut:

1. Pilih sebuah node yang belum dikunjungi dan memilikidist terkecil. Sebut sajanode ini sebagaiu.

2. Apabila tidak ada laginode yang belum dikunjungi, ataudist[u]bernilai∞_{, artinya tidak ada} laginode yang dapat dikunjungi. Algoritma Dijkstra berakhir.

3. Karenaudikunjungi, maka setvisited[u] =true. Kini dipastikanshortest path darismenuju uadalah dist[u]. Diketahui pulaedge _hpred[u],u_i merupakanedge yang perlu digunakan

padashortest path keu.

4. Untuk setiapnode vyang merupakan tetangga dariu, lakukan sebuah proses yang disebut "relax ". Proses relax untuk node u dan v adalah proses untuk memperbaharui jarak terpendek mencapaiv, apabila ternyata mencapaivmelaluiumembutuhkan jarak yang lebih kecil. Dengan kata lain, dilakukan:

dist[v] =min(dist[v],dist[u] +w[u][v])

Setiap kali dist[v] mengalami perubahan, ubah nilai pred[v] menjadi u. Sebab sejauh ini diketahui bahwa untuk mencapaivpadashortest path,node sebelumnya adalahu. 5. Kembali ke langkah 1.

Mari kita simulasikan Dijkstra pada graf berbobot dan tidak berarah yang ditunjukkan pada Gambar11.1. Misalnyanode permulaan adalah1, sehingga kita hendak mencarishortest path dari1ke semuanode lainnya. Gambar11.2sampai Gambar11.7menunjukkan simulasi Dijkstra pada graf tersebut.

2

1

4

3

5

2 6 3 ₂ 1 5

2 1 4 3 5 2 6 3 ₂ 1 5 1 _{2 3 4 5} dist 0 ∞ ∞ ∞ ∞

visited f alse f alse f alse f alse f alse

pred ₋1 ₋1 ₋1 ₋1 ₋1

Gambar 11.2: Tahap 1: Lakukan inisialisasi untuk seluruh datanode. Perhatikan perbedaan nilai inisialisasi untuknode permulaan, yaitunode 1.

2 1 4 3 5 2 6 3 ₂ 1 5 1 _{2 3 4 5} dist 0 _{2 6 3} ∞

visited true _{f alse f alse f alse f alse}

pred ₋1 _{1 1 1 −}

Gambar 11.3: Tahap 2: Node yang belum dikunjungi dan memiliki nilaidist terkecil adalah1. Tandainya denganvisited[1] =true, danrelax seluruh tetangganya.

2 1 4 3 5 2 6 3 ₂ 1 5 1 2 _{3 4 5} dist 0 2 _{6 3 7}

visited true true _{f alse f alse f alse}

pred ₋1 1 _{1 1 2}

Gambar 11.4: Tahap 3: Node yang belum dikunjungi dan memiliki nilaidist terkecil adalah2. Tandainya denganvisited[2] =true, danrelax seluruh tetangganya. Hanyanode 5

yang mengalami perubahandist. Kini diketahui pula bahwaedge h1,2_imerupakan bagian darishortest path ke2.

2 1 4 3 5 2 6 3 ₂ 1 5 1 2 3 4 ₅ dist 0 2 5 3 ₇

visited true true f alse true _{f alse}

pred ₋1 1 4 1 ₂

Gambar 11.5: Tahap 4: Node yang belum dikunjungi dan memiliki nilaidist terkecil adalah4. Ubah nilaivisiteddanrelax seluruh tetangganya. Node 3mengalami perubahan dist.

2 1 4 3 5 2 6 3 ₂ 1 5 1 2 3 _{4 5} dist 0 2 5 _{3 6}

visited true true true _{true f alse}

pred ₋1 1 4 _{1 3}

Gambar 11.6: Tahap 5: Node yang belum dikunjungi dan memiliki nilaidist terkecil adalah3. Ubah nilaivisited danrelax seluruh tetangganya. Hanyanode 5yang mengalami perubahandist. 2 1 4 3 5 2 6 3 ₂ 1 5 1 2 3 4 5 dist 0 2 5 3 6

visited true true true true true

pred ₋1 1 4 1 3

Gambar 11.7: Tahap 6: Satu-satunya node yang belum dikunjungi adalah5. Ubah nilaivisited danrelax seluruh tetangganya. Algoritma selesai.

Gambar11.7menunjukkanshortest path mulai darinode 1ke seluruhnode lainnya. Anda dapat melihat kebenaran hasil algoritma Dijkstra dengan membandingkannya dengan pencarian

shortest path secara manual.

Sifat algoritma Dijkstra yang pada setiap tahapnya selalu memilihnode berjarak tempuh terkecil merupakan suatu bentukgreedy. Diasumsikan bahwa pengutamaan perjalanan yang jarak tempuhnya terkecil saat itu akan menghasilkanshortest path yang benar. Hal ini akan selalu benar untuk graf yang tidak memiliki bobot negatif. Untuk kasus graf yang memiliki bobot negatif, asumsi ini tidak lagi memberikanshortest path yang optimal. Sebab mungkin saja terdapat suatu jalur yang jarak tempuhnya sangat besar, tetapi pada akhirnya akan melewatiedge dengan bobot negatif yang besar pula. Perhatikan Gambar11.8untuk lebih jelasnya.

2

1

4

3

8 1 -7 6

Gambar 11.8: Contoh graf yang mengakibatkan algoritma Dijkstra gagal. Shortest path dari1

ke4 yang dihasilkan algoritma Dijkstra adalah melalui1,3, lalu4 dengan jarak total7. Padahal, melalui1,2, lalu4memiliki jarak total1.

Implementasi

Algoritma62menunjukkan implementasi untuk algoritma Dijkstra. Representasi graf yang cocok untuk digunakan adalahadjacency list, sehingga pencacahan seluruh tetangga dari suatu node efi_sien.

Algoritma 62Implementasi algoritma Dijkstra.

1: functionDIJKSTRA(s)

2: dist_←new integer[V+1]

3: visited_←new boolean[V+1]

4: pred_←new integer[V+1]

5: FILLARRAY(dist,∞) 6: FILLARRAY(visited,f alse)

7: FILLARRAY(pred,₋1)

8: dist[s]_←0

9: whiletruedo ⊲Perulangan ini akan diakhiri denganbreak

10: u_{← −}1 11: minDist _←∞

12: fori_←1,V do ⊲Carinode yang belum dikunjungi dan memilikidist terkecil

13: if(notvisited[i])_∧(dist[i]<minDist)then

14: u_←i

15: minDist _←dist[i]

16: end if

17: end for

18: if(u=₋1)_∨ISINFINITE(dist[u])then

19: break ⊲Akhiri perulanganwhile

20: end if

21: visited[u]_←true

22: forv∈ad j(u)do ⊲Lakukanrelax untuk semua tetanggau

23: ifdist[v]>dist[u] +w[u][v]then

24: dist[v] =dist[u] +w[u][v]

25: pred[v] =u

26: end if

27: end for

28: end while

29: returndist ⊲Kembalikan tabelshortest path yang bermula daris

30: end function

Untuk mencetak edge-edge yang perlu dilalui untuk mencapai suatu node x dari node permulaan (yaitus), cukup lakukan penelusuran darixke belakang menggunakan informasi pred[x]

sampai mencapais. Algoritma pencariannya ditunjukkan pada Algoritma63. Waspadai bahwa belum tentu semua node x dapat dikunjungi dari s. Ketika hal ini terjadi, pred[x]masih tetap bernilai−1.

Algoritma 63Mencetakedge-edge yang dilalui untuk mencapainode x.

1: procedurePRINTPATH(x)

2: if(pred[x] =₋1)_∧(x₆=s)then

3: print"Tidak ada jalan"

4: else if pred[x]₆=₋1then

5: PRINTPATH(pred[x])

6: print pred[x],x

7: end if 8: end procedure

Untuk kasus terburuk, seluruhnode dapat dicapai darissehingga terdapatV iterasi. Pada setiap iterasi, dilakukan pencariannode untuk di-relax dan prosesrelax. Algoritma62menun- jukkan pencariannode untuk di-relax yang diimplementasikan denganlinear search, sehingga kompleksitas sekali pencariannya adalahO(V). Untuk prosesrelax sendiri, total kompleksitas- nya ketika seluruhnode di-relax adalahO(E). Kompleksitas total untuk implementasi ini adalah O(V2+E). Kompleksitas ini juga dapat dituliskan sebagaiO(V2) saja, sebab banyaknyaedge dibatasi olehV2.

Optimisasi denganheap

Pencariannode untuk di-relax sebenarnya merupakan pencarian nilai terkecil dari suatu kumpulan. Kita dapat menggunakan struktur dataheap untuk membuat pencarian ini lebih efi_sien,

yaituO(logV)per pencarian.

Heap yang kita perlukan adalah min-heap, yang menyimpan daftar node yang terurut berdasarkan jarak tempuh sejauh ini. Untuk mempermudah implementasi, kita dapat membuat heap yang dapat menyimpan elemen berupa pasangan data hjarak,node_i. Setiap kali jarak tempuh suatunode diperbaharui, masukkan datanya ke dalamheap. Hal ini memungkinkanheap menyimpan beberapanode yang sama dengan jarak yang berbeda. Tidak menjadi masalah, sebab ketika hasilpop heap adalahnode yang sudah dikunjungi, kita cukup mengabaikannya. Algoritma 64menunjukkan implementasi yang dioptimisasi denganheap.

Algoritma 64Implementasi algoritma Dijkstra dengan optimisasiheap.

1: functionDIJKSTRA(s)

2: dist_←new integer[V+1]

3: visited_←new boolean[V+1]

4: pred_←new integer[V+1]

5: FILLARRAY(dist,∞)

6: FILLARRAY(visited,f alse)

7: FILLARRAY(pred,₋1)

8: INITIALIZEHEAP() ⊲Buat sebuahmin-heap

9: PUSH(_h0,s_i) ⊲Masukkannode sdengan jarak tempuh0ke dalamheap

10: dist[s]_←0

11: while notISEMPTYHEAP()do

12: _hcurDist,u_{i ←}POP() ⊲Dapatkannode yang jarak tempuhnya terkecil

13: if notvisited[u]then ⊲Hanya proses apabilaubelum dikunjungi

14: visited[u]_←true

15: forv_∈ad j(u)do ⊲Lakukanrelax untuk semua tetanggau

16: ifdist[v]>dist[u] +w[u][v]then

17: dist[v] =dist[u] +w[u][v]

18: pred[v] =u

19: PUSH(hdist[v],v_i) ⊲Masukkan jarak dannode yang diperbaharui keheap

20: end if 21: end for 22: end if 23: end while 24: returndist 25: end function

Optimisasi ini membuat kompleksitas algoritma Dijkstra berjalan dalamO((V+E)logV).

11.1.2

Bellman—Ford

Konsep

Untuk mengatasi kekurangan algoritma Dijkstra pada graf dengan bobot negatif, kita dapat menggunakan algoritma Bellman—_{Ford. Algoritma ini menerima input berupa graf dan sebu-}

ah node awal, misalnya s, dan mengembalikanshortest path dari s ke seluruh node lainnya. Algoritma ini juga memberikan kemampuan tambahan berupa pendeteksiannegative cycle.

Negative cycle merupakancycle pada graf berbobot yang jumlah bobotnya negatif. Ketika

negative cycle dapat dicapai dari suatunode awal dan dapat menuju ke suatunode akhir, maka shortest path dari keduanode tersebut menjadi tidak terdefi_{nisi. Sebab, perjalanan darinode}

awal ke node akhir dapat berputar-putar di negative cycle sambil terus mengurangi bobot perjalanannya. Gambar11.9menunjukkan contoh graf dengannegative cycle.

2

1

4

3

5

2 6 1 2 -5 3

Gambar 11.9: Contoh graf yang memilikinegative cycle, yaitu[2,3,4]. Shortest path dari1ke5

tidak terdefi_{nisi karena adanyanegative cycle.}

Ide dari algoritma Bellman—_{Ford adalah terus menerus melakukan prosesrelax, sampai}

pada akhirnya tidak ada perubahan bobot perjalanan danshortest path yang benar ditemukan. Observasi yang dimanfaatkan algoritma ini adalah, shortest path dari suatu node ke node lainnya dipastikan tidak melibatkan lebih dariV₋1edge. Artinya apabila sebanyakV₋1 kali seluruhedge di-relax, maka seluruhshortest path akan ditemukan. Dengan demikian, algoritma ini dapat disimpulkan menjadi: sebanyakV₋1kali,relax seluruhedge.

Untuk mendeteksi keberadaannegative cycle, kita dapat melakukanrelax tambahan seba- nyak satu kali. Jika masih terdapat bobot perjalanan yang berubah, dipastikan perubahan itu disebabkan olehnegative cycle.

Implementasi

Representasi graf yang cocok digunakan adalahedge list atauadjacency list, untuk men- dapatkan informasi seluruhedge secara efi_{sien. Algoritma65menunjukkan implementasinya,}

sementara Algoritma66menunjukkan fungsi tambahan untuk mendeteksi keberadaannegative cycle.

Algoritma 65Implementasi algoritma Bellman—_Ford.

1: functionBELLMAN-FORD(s)

2: dist_←new integer[V+1]

3: FILLARRAY(dist,∞)

5: fori_←1,V₋1do

6: forhu,v_{i ∈}edgeListdo

7: ifdist[v]>dist[u] +w[u][v]then

8: dist[v] =dist[u] +w[u][v] 9: end if 10: end for 11: end for 12: returndist 13: end function

Algoritma 66Pendeteksiannegative cycle dengan memanfaatkan hasil pencarianshortest path menggunakan Bellman—_Ford.

1: functionHASNEGATIVECYCLE(s)

2: dist_←BELLMAN-FORD(s)

3: for_hu,v_{i ∈}edgeList do

4: ifdist[v]>dist[u] +w[u][v]then

5: returntrue

6: end if

7: end for

8: return f alse

9: end function

TerdapatV₋1tahapan relaksasiedge, yang mana setiap relaksasi bekerja dalamO(E). Secara jelas, kita dapat memperhatikan bahwa kompleksitas algoritma Bellman—_{Ford adalah}

O(V E). Meskipun lebih lambat daripada Dijkstra, algoritma ini bersifat lebih umum.

11.1.3

Floyd—Warshall

Konsep

Kadang-kadang, kita membutuhkan informasishortest path dari setiapnode ke setiapnode lainnya pada suatu graf. Selain dengan menjalankan Dijkstra atau Bellman—_{Ford satu per satu}

untuk setiapnode, kita juga dapat menggunakan algoritma Floyd—_Warshall.

Konsep dari algoritma ini adalahdynamic programming. Defi_{nisikan sebuah fungsi f(i,j,k)}

yang menyatakan jarak terpendek untuk berpindah darinode ikenode j, dengan hanya menggu- nakannode-node perantara{1,2,3, ...,k}. Nilai dari f(i,j,k)merupakan salah satu yang terkecil dari:

• Jarak terpendek dariike j, apabila tidak menggunakanksebagai perantaranya. Nilai ini sama dengan f(i,j,k₋1).

• Jarak terpendek dariike j, apabilakdigunakan sebagai perantaranya. Jaraknya adalah jarak ikek, ditambahkke j, dengan masing-masing hanya boleh menggunakan{1,2,3, ...,k₋1_}

sebagai perantaranya. Nilai ini sama dengan f(i,k,k₋1) +f(k,j,k₋1).

Kasus ketika perpindahan ike j tidak boleh menggunakan perantara menjadibase case. Kasus ini terjadi ketikak=0, yang artinyanode perantara yang boleh digunakan berupa himpunan kosong. Pada kasus ini, f(i,j,0) =w[i][j].

Dengan demikian, dapat dirumuskan DP berikut:

f(i,j,k) =

w[i][j], k=0

min(f(i,j,k₋1),f(i,k,k₋1) +f(k,j,k₋1)), k>0

Shortest path darinode skenode tdinyatakan pada f(s,t,V).

Implementasi

Seperti DP umumnya, kita dapat menggunakantop-down ataubottom-up. Implementasi yang biasa digunakan adalah versi bottom-up menggunakan optimisasi flying table, karena pendek dan mudah ditulis. Optimisasi flying table dapat dilakukan sebab perhitungan DP f(_,_,k)hanya membutuhkan informasi f(_,_,k−1). Representasi graf yang mudah digunakan adalahadjacency matrix. Algoritma Algoritma67menunjukkan implementasinya.

Algoritma 67Implementasi algoritma Floyd—_{Warshall dengan DPbottom-up.}

1: functionFLOYD-WARSHALL()

2: dist_←new integer[V+1][V+1]

3: FILLARRAY(dist,∞)

4: fori_←1,V do

5: for j_←1,V do

6: dist[i][j]_←w[i][j] ⊲Base case

7: end for 8: end for

9: fork_←1,V do ⊲Pengisian tabel

10: fori_←1,V do

11: for j_←1,V do

12: dist[i][j]_←min(dist[i][j],dist[i][k] +dist[k][j])

13: end for

14: end for 15: end for

⊲Kinidist[i][j]berisishortest path dariike j

16: returndist ⊲Kembalikan tabel DP

17: end function

Terlihat jelas bahwa kompleksitas waktunya adalahO(V3). Meskipun lebih lambat daripada menggunakan algoritma Dijkstra atau Bellman—_{Ford satu per satu, Floyd}—_{Warshall memiliki}

kelebihan dalam kemudahan implementasinya. Cukup dengan tiga lapis for ... loop,shortest path antar setiapnode ditemukan. Algoritma ini cocok digunakan apabila hanya terdapat sedikit node, dan Anda hendak menghemat waktu pengetikan kode.