STRUKTUR DATA
(Yuniasyah)
GRAPH
Disusun oleh :
Agung Juliansyah (1031123)
Akbar Aswad (1031089)
Nafisatul Hasanah (1031085)
Indra Putra (1031095)
Nurhadi Jumain Fantri (1031099)
Puji Syukur khadirat Allah Yang Maha Kuasa karena atas Rahmat dan
Hidayah-Nyalah kami dapat menyelesaikan Tugas Tengah Semester ini.
Makalah ini merupkan salah satu bagian dalam Tugas kami yang berjudul
GRAPH. Terima kasih juga kepada Bapak Yuniasyah selaku dosen
Pembimbing Mata Kulias Struktur Data di kelas kami 1SIMC.
Makalah ini berisi tentang Pembelajaran mengenai GRAPH di dalam
Struktur Data. Tentunya kami sangat berharap Makalah ini dapat berguna bagi
siapapun yang membacanya.
Masih banyak kekurangan dalam makalah ini . Selain itu dalam
penyusunan tugas atau materi ini, tidak sedikit hambatan yang penulis hadapi.
Namun penulis menyadari bahwa kelancaran dalam penyusunan materi ini tidak
lain berkat bantuan, dorongan dan bimbingan orang tua, sehingga kendalakendala yang penulis hadapi teratasi
Tim Penyusun
DAFTAR ISI
Definisi Graph............................................................................................6
Istilah dalam Graph....................................................................................9
Jenis jenis Graph....................................................................................11
Konektivitas Tiap Jenis Graph...................................................................12
Metode Pencarian Vertex...........................................................................14
a. Depth First Search (DFS)......................................................................14
b. Breadth First Search (BFS)....................................................................15
F. Shortest Path.............................................................................................17
a. Graph Berbobot (Weighted Graph)........................................................18
b. Algoritma Dijkstras.................................................................................19
c. Dinamic Programming............................................................................19
G. Minimum Spanning Tree............................................................................21
H. Algoritma Menentukan Minimum Spanning Tree (MST)...........................22
III. GRAPH PADA JAVA........................................................................................25
IV. KESIMPULAN..................................................................................................27
DAFTAR PUSTAKA..............................................................................................28
I. PENDAHULUAN
media
kolom-kolom data, baik itu kolom yang tampak oleh pengguna (user) ataupun
kolom yang hanya digunakan untuk keperluan pemrograman yang tiadak tampak
oleh pengguna.
Graph merupakan struktur data yang paling umum. Jika struktur linear
memungkinkan pendefinisian keterhubungan sikuensial antara entitas data,
struktur data tree memungkinkan pendefinisian keterhubungan hirarkis, maka
struktur graph memungkinkan pendefinisian keterhubungan tak terbatas antara
entitas data.
Banyak entitas-entitas data dalam masalah-masalah nyata secara
alamiah memiliki keterhubungan langsung (adjacency) secara tak terbatas
demikian. Contoh: informasi topologi dan jarak antar kota-kota di pulau Jawa.
Dalam masalah ini kota x bisa berhubungan langsung dengan hanya satu atau
lima kota lainnya. Untuk memeriksa keterhubungan dan jarak tidak langsung
antara
dua
kota
dapat
diperoleh
berdasarkan
data
keterhubungan-
edge,
hingga
menjadi
suatu
kesatuan
yang
disebut
graf. Sebagai contoh dari pemodelan graf adalah peta kota kota, dimana kota
disini sebagai vertex dan jalur yang menghubungkannya berlaku sebagai edge.
Agar lebih jelas perhatikan gambar dibawah ini :
Graf Tidak Berbobot : adalah suatu graf dimana edge dari graf tersebut tidak
memiliki bobot atau nilai. Untuk merepresentasikannya dalam pemrograman
komputer, graf dapat disusun dari LinkedList yang berada dalam LinkedList.
Verteks
menyatakan
entitas-entitas
data
dan
sisi
menyatakan
G = (V, E)
G = Graph
V = Simpul atau Vertex, atau Node, atau Titik
E = Busur atau Edge, atau arc
b. Graph Berarah
Dalam matrik diatas dapat kita lihat bahwa kotak yang berisi angka satu
menunjukan
bahwa
dalam
dua
vertex
tersebut
terdapat
edge
yang
menghubungkannya. Dan jika dalam kotak terdapat angka nol, maka hal tersebut
menandakan tidak ada edge yang mengubungkan secara langsung dua vertex
tersebut.
Untuk representasi dalam pemorgraman komputer, graf tersebut dapat
digambarkan seperti dibawah ini :
3. Adjacent
Pada graph tidah berarah, 2 buah simpul disebut adjacent bila ada
busur yang menghubungkan kedua simpul tersebut. Simpul v dan w
disebut adjacent.
E = { {A,B},{A,C}, {A,D}, {A,F}, {B,C}, {B,H}, {C,E}, {C,G}, {C,H}, {C,I}, {D,E},
{D,F}, {D,G}, {D,K}, {D,L}, {E,F}, {G,I}, {G,K}, {H,I}, {I,J}, {I,M}, {J,K}, {J,M}, {L,K},
{L,M}}.
Siklus: suatu path dengan panjang lebih dari satu yang dimulai dan
berakhir pada suatu verteks yang sama.
Siklus sederhana: dalan undigraph, siklus yang terbentuk pada tiga atau
lebih verteks-verteks yang berlainan yang mana tidak ada verteks yang
dikunjungi lebih dari satu kali kecuali verteks awal/akhir.
Pohon bebas (free tree): suatu undigraph yang hanya terdapat satu
komponen terkoneksi serta tidak memiliki siklus sederhana.
Adjacency ke / dari: Jika terdapat sisi (x,y) maka dalam digraph dikatakan
bahwa x "adjacent ke" y atau y "adjacent dari" x. Demikian pula jika terdapat
path dari x ke y maka belum tentu ada path dari y ke x Jadi dalam digraph
keterkoneksian didefinisikan lebih lanjut lagi sebagai berikut.
pencarian, yakni Depth First Search (DFS) dan Breadth First Search (BFS).
a. Depth First Search (DFS)
Pencarian dengan metode ini dilakukan dari node awal secara mendalam
hingga yang paling akhir (dead-end) atau sampai ditemukan. Dengan kata lain,
simpul cabang atau anak yang terlebih dahulu dikunjungi.
dengan
banyak cabang karena tidak perlu mengeksekusi semua simpul pada suatu
level tertentu pada daftar open. Selain itu, Depth First Search memerlukan
memori yang relatif kecil karena banyak node pada lintasan yang aktif saja
yang Selain kelebihan, Depth First Search juga memiliki kelemahan di antaranya
adalah memungkinkan tidak ditemukannya tujuan yang diharapkan dan hanya
akan mendapatkan satu solusi pada setiap pencarian.
b. Breadth First Search (BFS)
Prosedur Breadth First Search (BFS) merupakan pencarian yang
dilakukan dengan mengunjungi tiap-tiap node secara sistematis pada setiap
level hingga keadaan tujuan (goal state) ditemukan. Atau dengan kata lain,
penulusuran
yang
dilakukan
adalah
ruang
keadaan. Prosedur untuk Breadth First Search dapat dituliskan sebagai berikut:
2)
3)
4)
5)
6)
7)
8)
Open = [8, 9, 10, 11, 12, 13, 14]; closed = [7, 6, 5, 4, 3, 2, 1].
9)
Ada
beberapa
keuntungan
menggunakan
algoritma
Breadth First
Search ini, diantaranya adalah tidak akan menemui jalan buntu dan jika ada
satu solusi maka Breadth First Search akan menemukannya, dan jika ada lebih
dari satu solusi maka solusi minimum akan ditemukan.
Namun ada tiga persoalan utama berkenaan dengan Breadth First
Search ini yaitu :
1) Membutuhkan memori yang lebih besar, karena menyimpan semua node
dalam satu pohon.
2) Membutuhkan sejumlah besar pekerjaan, khususnya jika lintasan solusi
terpendek cukup panjang, karena jumlah node yang perlu diperiksa
bertambah secara eksponensial terhadap panjang lintasan.
3) Tidak relevannya operator akan menambah jumlah node yang harus diperiksa.
Oleh karena proses Breadth First Search mengamati node di setiap
level graf sebelum bergerak menuju ruang yang lebih dalam maka mulamula semua keadaan akan dicapai lewat lintasan yang terpendek dari
keadaan awal. Oleh sebab itu, proses ini menjamin ditemukannya lintasan
terpendek dari keadaan awal ke keadaan tujuan
karena
mula-mula
semua
(akhir).
Lebih
jauh
yang ditemui
pada
kali
kedua
didapati
pada
sepanjang sebuah lintasan yang sama atau lebih panjang. Kemudian, jika tidak
ada kesempatan ditemukannya
keadaan
yang
identik
pada
sepanjang
F. Shortest Path
Pencarian shortest path (lintasan terpendek) adalah masalah umum
dalam suatu weighted, connected graph. Misal : Pencarian jaringan jalan raya
yang menghubungkan kota-kota disuatu wilayah.
b. Algoritma Dijkstras
Algoritma Dijkstra's :
1. Menyelesaikan problem single-source shortest-path ketika semua edge
memiliki bobot tidak negatif.
2. Algoritma greedy mirip ke algoritma Prim's.
3. Algoritma di awali pada vertex sumber s, kemudian berkembang
membentuk sebuah tree T, pada akhirnya periode semua vertex dijangkau
dari S. Vertex di tambah ke T sesuai urutan
Misalnya :
Pertama S, kemudian vertex yang tepat ke S, kemudian yang tepat berikutnya
dan seterusnya.
c. Dynamic Programming
Terdiri dari sederetan tahapan keputusan. Pada setiap tahapan berlaku
prinsip optimality (apapun keadaan awal dan keputusan yang diambil, keputusan
berikutnya harus memberikan hasil yang optimal dengan melihat hasil keputusan
sebelumnya.
Misalnya :
Multistage Graph
Dimana
Dengan
Jika ada dua atau lebih shorthest path maka total biaya harus sama.
Bila jalur (edge) mempunyai biaya (cost) maka yang dicari adalah minimum
cost spanning tree.
1. Algoritma Kruskal
Algoritma ini lebih sederhana jika dilihat dari konsepnya namun lebih sulit
dalam implementasinya. Idenya adalah mendapatkan satu demi satu sisi mulai
dari yang berbobot terkecil untuk membentuk tree, suatu sisi walaupun berbobot
kecil tidak akan diambil jika membentuk siklik dengan sisi yang sudah termasuk
dalam tree. Yang menjadi masalah dalam implementasinya adalah keperluan
adanya pemeriksaan kondisi siklik tersebut.Salah satu pemecahaannya adalah
dengan subsetting yaitu pembentukan subset-subset yang disjoint dan secara
bertahap dilakukan penggabungan atas tiap dua subset yang berhubungan
dengan suatu sisi dengan bobot terpendek. Algoritma lengkapnya:
subset awal.
Tahap berikutnya, urutkan sisi-sisi dengan bobot yang terkecil hingga
terbesar.
Mulai dari sisi dengan bobot terkecil hingga terbesar lakukan dalam
iterasi: jika sisi tsb. menghubungkan dua vertex dalam satu subset
(berarti membentuk siklik) maka skip sisi tersebut dan periksa sisi
berikutnya jika tidak (berarti membentuk siklik) maka kedua subset dari
verteks-verteks yang bersangkutan digabungkan menjadi satu subset
yang lebih besar. Iterasi akan berlangsung hingga semua sisi terproses.
MST_KRUSKAL (G)
{ For setiap vertex v dalam V[G] Do
{ set S(v) {v} }
Inisialisasi priority queue Q yang berisi semua edge dari G,
gunakan bobot sebagai keys.
A { } // A berisi edge dari MST
While A lebih kecil dari pada n-1 edge Do
{ set S(v) berisi v dan S(u) berisi u }
IF S(v) != S(u) Then
{ Tambahkan edge (u, v) ke A
}
2. Algoritma Prim
Algoritma dimulai dari suatu verteks awal tertentu dan bisa ditentukan oleh
pemanggil atau dipilih sembarang oleh algoritma. Misalnya verteks awal tersebut
adalah v. Pada setiap iterasi terdapat kondisi di mana himpunan vertex V terbagi
dalam dua:
W yaitu himpunan verteks yang sudah dievaluasi sebagai node di dalam
pohon, serta (V-W) yaitu himpunan verteks yang belum dievaluasi.
Di awal algoritma W diinisialisasi berisi verteks awal v. Selanjutnya, di dalam
iterasinya:
Pada setiap adjacency dari tiap verteks dalam W dengan verteks dalam
(V-W) dicari sisi dengan panjang minimal. setelah diperoleh, sisi tersebut
ditandai sebagai sisi yang membentuk tree dan verteks adjacent sisi
tersebut dalam (VW) dipindahkan ke W (menjadi anggota W).
Jika sisi tersebut tidak ada maka proses selesai.
Dari contoh di atas misalnya dilakukan pencarian mulai dari verteks A
Maka algoritma ini menghasilkan tahapan-tahapan iterasi pencarian sbb.:
MST_PRIM (G, w, v)
{ Q V[G]
for setiap u dalam Q do key [u]
key [r] 0
[r] NIl
while queue tidak kosong do
{ u EXTRACT_MIN (Q)
for setiap vertex v dalam Adj[u] do
{ if v ada dalam Q dan w(u, v) < key [v] then
{ [v] w(u, v)
key [v] w(u, v)
}
}
}
Didalam Project ini terdapat 5 package Java. Dan yang akan kita bahas
disini adalah Package GRAPH_BASIC. Package GRAPH_BASIC, berisi 5 file
berextensi .java yang saling berhubungan satu sama lain. Untuk detail File bisa
di lihat di gambar di bawah ini.
Dapat Kita lihat dari gambar diatas, logika Graph di mulai dari penambahan
Vertex/Node, dengan memanggil fungsi AddVertex pada file Graph.java.
Setelah vertex tercipta, dilakukan penambahan Edge/Busur dan terakhir
memanggil fungsi untuk menghasilkan output.
Untuk Output yang di hasilkan bisa di lihat gambar di bawah ini.
IV. KESIMPULAN
Mengenal Graph :
DAFTAR PUSTAKA