TB 1 DESAIN DAN ANALISIS ALGORITMA

KELAS: L

Oleh :
Kelompok 3
Maryamah

135150201111008

Vivilia Putri A

135150201111230

Weni Agustina

135150201111019

Riza Rizqiana

135150207111019

Sema Yuni F

135150201111189

Dosen Pengampu: Ratih Kartika Dewi, S.T, M.Kom.

PROGRAM TEKNOLOGI INFORMASI DAN ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA
2014

1. Review Paper
Judul :
STUDI MINIMUM SPANNING TREE DENGAN ALGORITMA PRIM DAN
KRUSKAL
Nama Pengarang :
Hadyan Ghaziani Fadli
Nama Jurnal :
Studi Minimum Spanning Tree Dengan Algoritma Prim Dan Kruskal
Masalah :
Untuk kendaraan motor seperti mobil, menghubungkan beberapa kota besar
mungkin akan dihubungkan secara langsung dengan jalan tol. Namun pada umumnya,
seperti pada jalan kereta api, untuk penghematan pembuatan jalan, rel kereta api dibuat
tidak langsung, seperti jalan tol menghubungkan 2 kota yang cukup jauh secara langsung.
Namun, melalui kota-kota yang beradi diantaranya, jadi jalan ini sekaligus
menghubungkan kota-kota yang ada diantara kota asal dan kota tujuan kita.
Untuk menentukan jalur mana yang akan dipakai agar efisien maka diperlukan
cara untuk mendapatkan jalur terpendek. Karenanya pencarian sebuah jalan dengan jarak
minimal sangatlah dibutuhkan khususnya dalam dunia transportasi di dunia. Pada Tahun
1926, seorang Czech scientist, Otakar Boruvka menemukan sebuah algoritma yang
dikenal dengan Boruvkss Algoritma. Seiring berjalannya waktu, ada 2 algoritma lain
yang lebih umum untuk dipakai yaitu Algoritma Prim da Algoritma Kruskal.
Walaupun ada lebih dari 1 algoritma yang berbeda, namun jalan yang didapat
akan sama panjangnya. Metode yang dipakai oleh ketiga Algoritma ini adalah metode
Minimum Spanning Tree.

2. Algoritma
o Algoritma Prim
Algoritma Prim adalah suatu algoritma di dalam teori graf yang bertujuan
menemukan Minimum Spanning tree untuk menghubungkan graf berbobot.
Ini berarti algoritma ini menemukan subset dari sebuah tepi yang membentuk sebuah
Tree diminimalkan. Jika graf tidak terhubung, maka ini hanya akan menemukan
sebuah Minimum Spanning Tree menjadi satu jalur untuk komponen yang terhubung.
Algoritma ini ditemukan pada tahun 1930 oleh seorang ahli matematika Vojtech
Jamik, dan kemudian dipublikasikan oleh seorang computer scientist Robert C. Prim
pada tahun 1957 dan ditemukan kembali oleh Dijkstra pada tahun 1959. Oleh karena
itu, terkadang Algoritma ini juga disebut DJP algoritma atau algoritma Jamik.
Alur dan Cara Kerja Algoritma Prim
Alur :

A
7
5

B
7

9
15

C
5

6
9

A
7
5

18
7

9
15

C
G

6
9

A
7
5

9
15

D
6

18

Ini adalah sebuah graf berbobot yang asli,

ini bukan sebuah Tree karena definisi
sebuah Tree tidak memiliki sirkuit, dan
diagram ini memiliki sirkuit. Nama yang
lebih benar untuk diagram ini adalah sebuah
graf atau network. Nomer didekat busur
adalah bobotnya. Tidak satupun dari titik
sudut yang diberi highlight dan vertex D
dipilih sebagai starting point.

Kedua, pilih vertex terdekat dengan D : A

memiliki jarak 5 dengan D, B memiliki
jarak 9, E memiliki jarak 15, dan F
memiliki jarak 6. Dari semuanya 5 adalah
jarak terpendek, jadi kita highlight vertex A
dan busur DA.

Vertex berikutnya adalah vertex yang

G ke D atau A. B memiliki jarak 9
terdekat
7 dari 5D dan 7 dari A, E memiliki jarak 15
dan F memiliki jarak 6. Jadi F yang
E
memiliki jarak terpendek. Sehingga kita
highlight vertex F dan sisi DF.
9

F
1

A
7
5

9
15

Algoritma yang disebutkan diatas, vertex B,

yang5memiliki jarak 7 dari A, di highlight.
7 Disini
, sisi DB di highlight warna merah,
karena kedua vertex yaitu B dan D telah di
E
hilghlight, jadi ini tidak bisa digunakan

6
9

F
A

1
7

Dalam kasus ini, kita dapat memilih antara

7 C, E5dan G. C memiliki jarak 8 dai B, E

memiliki jarak v dari B dan G memiliki

E
jarak 11 dari F. E yang terdekat.jadi kita
highlight E dan sisi EB. Dia sisi lainnya
telah di highlight merah, artinya kedua
9 gabungan itu telah dipakai
vertices

15

D
6

F
A

1
7

C
G

C
G
Disin, vertices yang masih tersedia adalah

C dan
5 G. C memiliki jarak5 dari E dan G
7 memiliki
jarak 9 dari E. C yang dipilih. Jadi

kita highlight sisi EC, dan BC juga kita

E
highlight merah

15

D
6

F
A

1
7

C
G

Vertex G adalah vertex terakhir. Ini berjarak

5
7 11 dari
F, dan 9 dari E. E yang terdekat ,

jadi kita highlight sisi EG. Sekarang semua

E
vertices telah di highlight, sebuah Minimum
Spanning Tree di tamppilkan dengan warna
hijau, dalam kasus ini bobotnya adalah 39.

15

D
6

F
1

Cara Kerja :

Membuat sebuah tree yang mengandung vertex tunggal, pilih yang berbobot

minimum.
Membuat sebuah set (yang belum tercakup) yang mengandung semua vertices
yang

lain di dalam graf.

Membuat sebuah set (fringe vertices) yang di inisialisasi kosong.
Loop (jumlah vertices -1) :
Memindahkan tiap vertices yang belum tercakup dan secara langsung
terhubung kepada node terakhir, menambahkan ke fringe set.
Untuk setiap titik di set sisi, menentukan jika sebuah sisi menghubungkan
vertices dengan node terakhir ysng ditambahkan jika iya, maka jika sisi
tersebut memiliki bobot lebih kecil dari sisi sebelumnya yang
menghubungkan vertex ke Tree yang telah terbuat. Memasukkan sisi baru
ini melalui node terakhir yang ditambahkan sebagai rute terbaik di Tree
yang telah dibuat.
Memilih sisi dengan bobot minimum yang menghubungkan vertex dalam
fringe set ke vertex pada Tree yang sudah terbuat.
Menambahkan sisi tersebut ke Tree dan memindahkan fringe vertex dalam
fringe set ke sebuah vertex dalam Tree yang sudah terbuat.
Meng-update node terakhir yang ditambahkan untuk menjadi fringe vertex
yang baru ditambahkan.
Hanya | V | -1, dimana | V | adalah jumlah dari vertices dalam graf, pengulangan
diperlukan. Sebuah Tree menghubungkan | V | -1 sisi dan tiap pengulangan dari
algoritma yang dideskripsikan diatas tertarik dalam tepat 1 sisi.
Implementasi yang simple menggunakan representasi adjacency matrix graph dan
mencari sebuah barisan bobot untuk mencari sisi dengan bobot minimum.

o Algoritma Kruskal
Algoritma Kruskal pertama kali dipopulerkan oleh Joseph Kruskal pada tahun
1959. Algoritma Kruskal adalah sebuah algoritma dalam teori grf yang mencari sebuah
Minimum Sanning Tree untuk sebuah graf yang berbobot dan yang terhubung. Ini
berarti mencari subset dari sisi yang membentuk sebuah Tree yag menampung setiap
vertex, dimana total bobot dari semua sisi dalam Tree adalah minimum. Jika graf tidak
terhubung, kemudian ini mencari sebuah Minimum Spanning Forest (sebuah
Minimumu Spanning Tree untuk tiap komponen yang terhubung). Algoritma Kruskal
adalah suatu contoh dari Algoritma Greedy.
Perbedaan prinsip antara algoritma prim dan Kruskal adalah jika pada algoritma
prim sisi yang dimasukkan ke dalam Tree harus bersisian dengan sebuah simpul di

Tree, maka pada algoritma kruskal sisi yang dipilih tidak perlu bersisian dengan
sebuah simpul di Tree, asalkan penambahan sisi tersebut tidak membentuk cycle.
Kedua algoritma ini berbeda dalam metodologinya, tetapi keduanya mempunyai
tujuan menemukan minimum spanning

Algoritma Kruskal menggunakan edge, dan

Algoritma Prim menggunakan vertex yang terhubung

Alur dan Cara Kerja Algoritma Kruskal :

Alur :

7
5

9
15

Ini adalah graf asli. Angka-Angka dekat sisi

5
bobot mereka. Tidak satupun dari
7 menandai
sisi di Highlight

6
9

A
7
5

9
15

18

ADG
dan
5 CE adalah sisi yang paling pendek,
7
dengan panjangnya 5, dan AD ditetapkan
sebagai
E awal, jadi kita beri highlight

6
9

F
A

1
7

D
A

C
G
CE sekarang adalah sisi terpendek yang

tidak membentuk loop, dengan panjang 5,

7 maka5 kita highlight.

9
15
6
7

E
8

FB
7
1

9
15

E
G

6
9

F
1

Sisi selanjutnya , DF dengan panjang 6, di

highlight menggunakan metode yang sama

A
7
5

Sisi terpendek berikutnya adalah AB dan

7 BE, 5keduanya memiliki panjang 7, AB

dipilih, dai di highlight, Sisi BD di

E
Highlight
merah, karena ini akan
membentuk loop ABD

15

D
6

A
7
5

18

G berlanjut dengan meng- highlight ke

Proses
berikutnya, BE dengan
panjang 7. akan lebih banyak sisi yang di
E
highlight
dengan merah dalam stage ini :
BC, DE dan FE

7 sisi 5terpendek

9
15

D
6

F
1

A
7
5

GC

Terakhir,
proses berakhir dengan sisi EG
5
7 dengan
panjang 9, dan Minimum Spanning

Tree telah ditemukan

15

6
9

F
Cara Kerja :

Membuat sebuah Forest F (set

G dari Tree) yang tiap vertex dalam graf adalah Tree

pemisah.
Membuat sebuah set S yang mengandung semua sisi di dalam graf.
While S tidak kosong :
Membuang sebuah sisi dengan bobot minimum dari S
Jika sebuah sisi menghubungkan dua Tree yang berbeda, kemudian
menambahkan ini ke dalam Forest, mengkombinasikan dua Tree ke dalam 1 Tree

 Dilain pihak membuang sisi tersebut Dalam terminasi dari algoritma ini, Forest
hanya memiliki satu komponen dan membentuk sebuah Minimum Spanning
Tree dari graf.
3. Implementasi
Source code utama yang berisi algoritma
o Algoritma Prim
Graph.java
public void Prim( )
{
int i, j, k, x, y;
boolean[] RuteDilewati = new boolean[Nodes];
predNode = new int[Nodes];
// dimulai pada node awal = 0 pada sebuah vertex
RuteDilewati[0] = true;
for ( k = 1; k < Nodes; k++ )
{
RuteDilewati[k] = false;
}
predNode[0] = 0;
printSeluruhRute( RuteDilewati );
for (k = 1; k < Nodes; k++)
{
x = y = 0;
for ( i = 0; i < Nodes; i++ )
for ( j = 0; j < Nodes; j++ )
{
if ( RuteDilewati[i] && !RuteDilewati[j] &&
Jarak[i][j] < Jarak[x][y] )
{
x = i;
y = j;
}
}
System.out.println("Jarak Min : (" +
+ x + "," +
+ y + ")" +
"Jarak = " + Jarak[x][y]);
predNode[y] = x;
RuteDilewati[y] = true;
printSeluruhRute( RuteDilewati );
System.out.println();
}

int[]

printRuteMin( predNode );
}

o Algoritma Kruskal
Graph.cpp
void KruskalMST(struct Graph* graph){
int V = graph->V;
struct Edge result[V];
int e = 0;
int i = 0;
qsort(graph->edge, graph->E, sizeof(graph->edge[0]),
myComp);
struct subset *subsets = (struct subset*) malloc( V *
sizeof(struct subset));
for (int v = 0; v < V; ++v){
subsets[v].parent = v;
subsets[v].rank = 0;
}
while (e < V - 1) {
struct Edge next_edge = graph->edge[i++];
int x = find(subsets, next_edge.src);
int y = find(subsets, next_edge.dest);
if (x != y) {
result[e++] = next_edge;
Union(subsets, x, y);
}
}
printf("Following are the edges in the constructed MST\n");
for (i = 0; i < e; ++i)
printf("%d -- %d == %d\n", result[i].src,
result[i].dest, result[i].weight);
return;
}

Screenshoot: tampilan hasil program

o Algoritma Prim

o Algoritma Kruskal

4. Analisis kompleksitas
4.1 Penentuan n
o Algoritma Prim
n = 8.
o Algoritma Kruskal
Pada algoritma kruskal ini kita menginputkan n = v-i
4.2 Basic operation & alasan pemilihan
o Algoritma Prim
for ( i = 0; i < Nodes; i++ )
for ( j = 0; j < Nodes; j++ )

Alasan : Karena for i dan for j sering dieksekusi dalam program algoritma prim.
o Algoritma Kruskal
While (e < V-1)

Alasan : eksekusi dilakukan berulang-ulang sesuai dengan nilai edge dan vertex
yang diinputkan. Jika nilai yang diinputkan 5 maka eksekusi akan dilakukan 5
kali.
4.3 Proses memperoleh C(n)
Penentuan kelas OOG
o Algoritma Prim
nm nm

C ( n) = . 1
i=1

j=1

nm

1(nm1+1)
i=1

nm

1(nm)
i=1

( nm1+ 1 ) (nm)
( nm) ( nm )
n2nmnmm2
2

n 2 nmm

T ( n ) =n ( nm ) +1

o Algoritma Kruskal

Best case : Cn =

1
i=1

e= edge dan v = vertex

Dengan kondisi e = v-1 dapat ditulis e log v
Waktu untuk 2e untuk menemukan operasinya adalah = log v
Untuk operasi v-1= n
Sehingga total running time
T(n) = e log v + 2e log v + n
T(n) = (e+v) log n

Notasi asymptotic
o Algoritma Prim
O(n ( nm )+1)
o Algoritma Kruskal
Best case = O (1)
T (n) = O ((n+m)log n )

Catatan Dosen Pengampu

Kelas
Kelompok
1

: TIF-L
: 03

Pemilihan paper
acuan

Review

Kompleksitas

Implementasi

Lain2

Jur
Int
Al>1
Jud+Nam
Mslh Ut
Desc Al
N
Bo
C(n)
OOG
ASYM
Cde
Scrst
Rap
Tep

Jumlah

(Ratih Kartika Dewi, S.T, M.Kom.)

Ini adalah sebuah graf berbobot yang asli, ini bukan sebuah Tree
karena definisi sebuah Tree tidak memiliki sirkuit, dan diagram
ini memiliki sirkuit. Nama yang lebih benar untuk diagram ini
adalah sebuah graf atau network. Nomer didekat busur adalah
bobotnya. Tidak satupun dari titik sudut yang diberi highlight dan
vertex D dipilih sebagai starting point.