TUGAS KECERDASAN TIRUAN

Algoritma Depth First Search

Disusun Oleh:
Kelompok 2 - Kecerdasan Tiruan (D)

1. I Made Riken Indra Putera (1605551106)

2. I Nyoman Krisna Pranata (1605551114)
3. I Kadek Owen Nirvana Kaskora (1605551115)

PROGRAM STUDI TEKNOLOGI INFORMASI

FAKULTAS TEKNIK
UNIVERSITAS UDAYANA
2018
 DEPTH FIRST SEARCH

A. Pengertian
Depth First Search adalah sebuah algoritma untuk melintasi atau mencari struktur data
pohon atau grafik. Seseorang mulai berakar (memilih beberapa nodus acak sebagai akar dalam
kasus grafik) dan mengekplorasi sejauh mungkin di sepanjang cabang sebelum melakukan
backtracking.

B. Cara kerja DFS

Pencarian rute terpendek dilakukan dengan cara membuat simpul-simpul yang menjadi
titik awal, titik-titik yang akan dilalui dan juga titik akhir sebagai akhir dari tujuan atau sebagai
simpul yang dicari.
Dalam algoritma DFS, simpul yang telah dikunjungi disimpan dalam suatu tumpukan
(stack). Antrian ini digunakan untuk mengacu simpul-simpul yang akan dikunjungi sesuai urutan
tumpukan (masuk terakhir, keluar pertama) dan mempermudah proses runut-balik jika simpul
sudah tidak mempunyai anak (simpul pada kedalaman maksimal). Untuk memperjelas cara kerja
algoritma DFS beserta tumpukan yang digunakannya, berikut langkah-langkah algoritma DFS:

1. Masukkan simpul ujung (akar) ke dalam tumpukan

2. Ambil simpul dari tumpukan teratas, lalu cek apakah simpul merupakan solusi
3. Jika simpul merupakan solusi, pencarian selesai dan hasil dikembalikan.
4. Jika simpul bukan solusi, masukkan seluruh simpul yang bertetangga dengan simpul
tersebut (simpul anak) ke dalam tumpukan
5. Jika tumpukan kosong dan setiap simpul sudah dicek, pencarian selesai dan
mengembalikan hasil solusi tidak ditemukan
6. Ulangi pencarian dari langkah kedua

C. Kelebihan & Kekurangan DFS

Depth First Search Memiliki kelebihan dan kekurangan tersendiri, tergantung pada
masalah graf yang ingin dipecahkan pada algoritma tersebut. Tapi secara umum, Depth First
Search memiliki kelebihan dan kekurangan sebagai berikut.
 1. Kelebihan DFS
a) Pemakaian memori hanya sedikit, berbeda jauh dengan BFS yang harus
menyimpan semua node yang pernah dibangkitkan.
b) Jika solusi dicari pada level yang paling dalam, maka DFS akan menemukannya
secara cepat.
2. Kelemahan DFS
a) Jika pohon yang dibangkitakan memiliki level yang dalam (tak terhingga), maka
tidak ada jaminan untuk menemukan solusi.
b) Jika terdapat lebih dari satu solusi yang sama tetapi berada pada level yang
berbeda, maka DFS tidak ada jaminan untuk menemukan solusi yang paling baik.

D. Studi Kasus
Depth First Search (DFS) adalah algoritma umum traversal atau pencarian pada pohon,
struktur pohon, atau graf. DFS adalah pencarian yang berjalan dengan meluaskan anak akar
pertama dari pohon pencarian yang dipilih dan berjalan dalam dan lebih dalam lagi sampai simpul
tujuan ditemukan, atau sampai menemukan simpul yang tidak punya anak. Kemudian, pencarian
backtracking, akan kembali ke simpul yang belum selesai ditelusuri. Dalam implementasi
nonrekursif , semua simpul yang diluaskan ditambahkan ke LIFO stack untuk penelusuran.
Beberapa hal mengenai traversal DFS :
1. Traversal DFS dari suatu graf G akan :
 Mengunjungi semua simpul dan sisi dari G
 Menentukan apakah G terhubung
 Memperhitungkan komponen terhubung dari G
 Memperhitungkan pohon merentang dari G
2. DFS pada graf dengan n simpul dan m sisi membutuhkan waktu O(n + m )
3. DFS dapat lebih jauh diperluas untuk menyelesaikan masalah-masalah pada graf
 Menemukan dan melaporkan lintasan antara dua simpul yang diberikan
 Menemukan sirkuit pada graf
4. Depth First Search untuk menggambar graf Euler ke pohon biner.
Berikut adalah contoh suatu pohon pencarian

Pada graf yang kita miliki di atas hubungan antara lintasan tidak dua arah. Semua lintasan
hanya berjalan dari atas ke bawah. Dengan kata lain, A memiliki lintasan ke B dan C, tapi B dan
C tidak memiliki lintasan ke A. Jadi, secara umum bisa kita anggap seperti jalan satu arah (one
way street).
Setiap lingkaran yang berhuruf pada graf di atas adalah simpul. Setiap simpul dapat
dihubungkan dengan simpul yang lain dengan sisi atau suatu lintasan, dan simpul yang langsung
berhubungan dengan simpul disebut tetangga. B dan C adalah tetangga dari A. Kemudian, E dan
D adalah tetangga dari B, dan B bukan tetangga dari D atau E karena B tidak bisa dicapai
menggunakan D atau E. Misalkan kita ingin mencari lintasan antara simpul A dan F pada
graf yang telah kita punyai pada gambar diatas.
Depth First Search telah kita ketahui, bekerja dengan memilih suatu simpul, kemudian akan
memeriksa tetangga-tetangganya, meluaskan dengan simpul pertama yang ditemui pada tetangga-
tetangganya, kemudian memeriksa apakah simpul hasil perluasan adalah tujuannya atau bukan,
dan jika bukan, akan melanjutkan menelusuri simpul yang lebih banyak lagi.

Langkah Awal : Dimulai dari simpul akar, atau simpul tujuan yang kita pilih, yaitu A

Kita akan menggunakan dua list info untuk menyimpan langkah yang kita lakukan, yaitu
Open dan Close. Open akan menyimpan langkah yang perlu kita lakukan, dan Close akan
menyimpan langkah yang telah kita lakukan. Saat ini, kita hanya punya titik awal yang kita pilih,
yaitu simpul A. Kita belum melakukan apapun ke simpul tersebut, sehingga sekarang kita
tambahkan ke Open.
Open : A
Close : < kosong >

Langkah 1 : Sekarang, kita memeriksa tetangga- tetangga dari simpul A. Dengan kata lain,
mengambil simpul awal dari Open kita dan kemudian menelusuri tetanggatetangganya.

Tetangga-tetangga dari simpul A adalah simpul B dan C. Karena sekarang kita telah selesai
dengan simpul A, kita dapat menghapusnya dari Open dan menambahkannya ke Close. Kita belum
selesai dengan langkah ini tentunya. Tambahkan dua simpul B dan C tadi ke Open.
Sekarang, Open dan Close berisi data sebagai berikut :
Open : B, C
Close : A
Langkah 2 : Open kini berisi dua simpul. Untuk depth first search dan breadth first search, selalu
kita telusuri simpul pertama dari Open. Simpul pertama pada open sekarang adalah simpul B. B
bukan tujuan kita, sehingga kita telusuri tetangga-tetangganya.

Karena kini B telah diluaskan, kita dapat menghapusnya dari Open dan menambahkannya
ke Close. Kini, simpul baru kita adalah D dan E, dan kita tambahkan simpul ini ke awal dari Open
(menggantikan B yang telah dihapus).
Open : D, E, C
Close : A, B

Langkah 3 : Kita akan melihat bahwa sebuah pola mulai terbentuk. Karena D ada di awal dari
Open, maka kita meluaskannya. D bukan tujuan kita, dan tidak berisi satu pun tetangga.
Selanjutnya, kita dapat menghapus D dari Open dan menambahkanya ke Close.
Open : E, C
Close : A, B, D

Langkah 4 : Sekarang kita meluaskan simpul E dari Open. E bukan tujuan kita, sehingga kita
telusuri tetanggatetangganya dan menemukan bahwa ia memiliki tetangga F dan G. Karena F
adalah tujuan kita, kita masih belum berhenti di sini tentunya. Di samping F berada pada lintasan
kita, kita hanya akan berhenti begitu kita akan meluaskan simpul tujuan kita, dalam kasus ini yaitu
F:
 Kita akan menghapus simpul E dari Open dan menambahkan simpul F dan G ke dalamnya.
Kemudian, simpul E ditambahkan ke Close: Open: F, G, C Close: A, B, D, E

Langkah 5 : Sekarang kita meluaskan simpul F. Karena F adalah tujuan kita, maka kita berhenti :

Kita menghapus F dari Open dan menambahkannya ke Close. Karena kita telah sampai di
tujuan, maka tidak perlu lagi meluaskan F dan mencari tetangganya. Open dan Close akhir kita
akan berisi data sebagai berikut :
Open : G, C
Close : A, B, D, E, F
Lintasan akhir yang akan diambil oleh metode Depth First Search kita adalah nilai terakhir dari
Close, yaitu : A, B, D, E, F.
E. Contoh Program
Pada studi kasus diatas merupakan metode pencarian depth first search dalam suatu pohon
(tree) dimana tujuannya itu adalah dari A sampai huruf F, pada program kali ini kelompok kami
akan membuat metode Depth First Search seperti pada contoh diatas.

Kelas DepthFirstSearch
package depthfirstsearch;

import java.util.Stack;

public class DepthFirstSearch {

public void depthFirstSearch(Node root) {

if(root == null) {
return;
}

Stack<Node> nodeStack = new Stack<Node>();

nodeStack.push(root);

while(!nodeStack.isEmpty()) {
Node node = nodeStack.pop();
System.out.print(node.data + " ");
if(node.data != "F"){
if(node.right != null) {
nodeStack.push(node.right);
}
if(node.left != null) {
nodeStack.push(node.left);
}
}else{
break;
}
}
}

public static void main(String args[]) {

 Node root = new Node("A");
root.left = new Node("B");
root.right = new Node("C");
root.left.left = new Node("D");
root.left.right = new Node("E");
root.left.right.left = new Node("F");
root.left.right.right = new Node ("G");
root.left.right.right.left = new Node ("H");
root.left.right.right.right = new Node ("I");
root.left.right.right.left.left = new Node ("J");
root.left.right.right.left.right = new Node ("K");
root.left.right.right.left.left.left = new Node ("L");
root.left.right.right.left.left.right = new Node ("M");

DepthFirstSearch dfs = new DepthFirstSearch();

dfs.depthFirstSearch(root);
}
}

Pada kode program diatas menunjukan kelas DepthFirstClass, dimana pada kelas ini kita
akan menentukan lintasan – lintasan yang nantinya dilewati, pada public main terlihat terdapat
huruf – huruf yang dimasukan kedalam kelas Node, jika ini digambarkan dalam bentuk pohon
maka nantinya huruf – huruf itu akan seperti pada gambar pada contoh studi kasus diatas, jika kita
sudah menentukan lintasannya yang nantinya akan ditentukan oleh method depthFirstSearch pad
akelas DepthFirstSearch
Kelas Node
package depthfirstsearch;

public class Node {

String data;
Node left;
Node right;

public Node(String value) {

data = value;
left = right = null;
 }
}

Pada Kode Program diatas menunjukan kelas Node, dimana kelas ini nantinya dipanggil
oleh kelas DepthFirstSearch, pada kelas node disni berguna untuk menentukan data dari sebuah
lintasan yang dimasukkan pad akelas public main di DepthFirstSearch dan menentukan nilai left
dan right.
Output

Pada gambar diatas menunjukkan sebuah hasil dimana hasil tersebut menunjukkan A-B-
D-E-F hasil ini didapat dari 2 kelas yaitu DepthFirstSearch dan Node, pada program ini hasilnya
akan berhenti jika menemui huruf “F” karena pada studi kasus disini kita hanya perlu mencari
lintasan dari pohon A sampai F.