LAPORAN STRUKTUR DATA/PRAKTIKUM

STRUKTUR DATA

Disusun untuk memenuhi Tugas UAS

Mata Kuliah Struktur Data/Praktikum Struktur Data
Dosen Pengampu
Ach. Arif Alfin, S.Si., M.MT

Disusun oleh:
Muhammad Farhan Musthafa 20562020021
Koing Suryo Nugroho 20562020020
Muhammad Rizqy Alim 20562020028

PROGRAM STUDI TEKNIK KOMPUTER

FAKULTAS TEKNIK
UNIVERSITAS ISLAM KADIRI – KEDIRI
2021
 DAFTAR ISI

DAFTAR ISI ................................................................................................. I

BAB I SINGLE LINKED LIST ................................................................... 1
A. Pengertian Single Linked List ........................................................... 1
B. Penjelasan Method ............................................................................ 1
BAB II BINARY TREE ............................................................................... 2
A. Pengertian Binary Tree ..................................................................... 2
B. Penjelasan Method ............................................................................ 2
BAB III BINARY SEARCH TREE ............................................................. 4
A. Pengertian Binary Search Tree.......................................................... 4
B. Penjelasan Method ............................................................................ 4
BAB IV GRAPH ........................................................................................... 5
A. Pengertian Graph ............................................................................... 5
B. Penjelasan Method ............................................................................ 5
BAB V TRAVERSAL GRAPH ................................................................... 6
A. Pengertian Traversal Graph............................................................... 6
B. Penjelasan Method ............................................................................ 6
LAMPIRAN .................................................................................................. 7
 Soal 1................................................................................................. 7
 Soal 2................................................................................................. 10
 Soal 3................................................................................................. 15
 Soal 4................................................................................................. 22
 Soal 5................................................................................................. 27

I
 BAB I
SINGLE LINKED LIST

A. Pengertian Single Linked List

Single Linked List adalah sekumpulan dari node yang saling

terhubung dengan node lain melalui sebuah pointer.rangkaian single linked
list tersebut diawali dengan sebuah head untuk menyimpan alamat awal dan
di akhiri dengan node yang mengarah pointer ke null.

B. Penjelasan Method

a. Add :
Untuk menambahkan data yang ingin dimasukan.
b. Set :
Tipe data abstract dimana digunakan untuk menyimpan value tertentu.
Value ini tidak tersimpan dalam order tetapi tidak seharusnya menjadi
pengulangan value didalam set.
c. Get :
Berfungsi menghasilkan suatu nilai dari perhitungan.
d. IndexOf :
Mengembalikan posisi pemunculan pertama dari nilai yang ditentukan
dalam sebuah string.
e. LastIndexOf :
Mengembalikan posisi pemunculan terakhir dari nilai yang ditentukan
dalam sebuah string.
f. Remove(index) :
Mengapus data pada array dapat dilakukan berdasarkan index ataupun
langsung tertuju pada data apa yang akan kita hapus.
g. Remove(Object) :
Mengapus data pada array dapat dilakukan berdasarkan object ataupun
langsung tertuju pada data apa yang akan kita hapus.
h. ToString :
Mengubah nomor menjadi string.

1
 BAB II
BINARY TREE

A. Pengertian Binary Tree

Sebuah tree dengan syarat bahwa tiap node hanya boleh memiliki
maksimal 2 subtree yang disebut sebagai subpohon kiri (left subtree) dan
subpohon kanan (right subtree) dan kedua subtree tersebut harus terpisah,
atau dengan kata lain tiap node dalam binary tree hanya boleh memiliki
paling banyak 2 child.

B. Penjelasan Method

a. Membangun Tree :
Membangun bentuk struktur bukan linier yang menggambarkan bentuk
hirarki antara elemen-elemen.Tree biasanya terdiri dari akar dan node-
node yang berada dibawah akar.
b. Traversal tree InOrder, PostOrder, PreOrder :
mengacu pada proses mengunjungi setiap simpul pohon setidaknya
sekali. Tidak seperti struktur data linier dasar seperti array. Jika
akarnya dikunjungi sebelum sub pohonnya, ini merupakan preorder,
jika akarnya dikunjungi sesudah sub pohonnya ini merupakan
postorder sedangkan akarnya dikunjungi diantara sub pohonnya
dinamakan inorder.
c. Traversal Tree inorder,postorder, dan preorder non rekirsif :
Dalam rekursif penyelesaiannya dilakukan dengan memanggil fungsi
atau prosedur diatasnya, jika untuk mencari non-rekursif
penyelesaiannya memanfaatkan stack. Perbandingan ini didasarkan
kompleksitas beserta kelebihan dan kekurangan pada masing-masing
algoritma.
d. Ketinggian Tree :
Adalah level tertinggi dari tree ditambah 1.

2
e. Copy Tree :
Mencopy binary tree menggunakan postorder scan menduplikat tree
dari bawah ke atas.
f. Jumlah Node :
Jumlah Node terbagi menjadi dua yaitu Depth of node dan Height of
node. Depth of node adalah jumlah edge dan root ke node, sedangkan
Height of node adalah jumlah edge terpanjang dari node ke leaf.

3
 BAB III
BINARY SEARCH TREE

A. Pengertian Binary Search Tree

Pengertian Binary Search Tree adalah struktur data berbasis sandi

pohon biner yang memiliki sifat-sifat berikut, Subpohon yang tersisa hanya
berisi node dengan tombol yang lebih kecil dari pada saklarnya. Subpohon
yang tepat hanya berisi node dengan kunci yang lebih besar dari pada
saklarnya. Subpohon kiri dan kanan masing-masing harus juga menjadi pohon
pencari biner.

B. Penjelasan Method

a. Membangun Binary Search Tree :

Semua data dibagian kiri sub-tree dari node terlalu lebih kecil dari
data dalam node itu sendiri, semua data dibagian kanan sub-tree dari
node selalu lebih besar atau sama dengan data dalam note.
b. Mencari sebuah node, mencari node terbesar dan terkecil
(rekrusif dan non rekrusif) :
Pencarian secara rekrusif dimulai dari node root, jika data yang dicari
lebih kecil daripada data node root, maka pencarian dilakukan di sub
node sebelah kiri, sedangkan jika data yang dicari lebih besar
daripada data node root, maka pencarian dilakukan di sub node
sebelah kanan, jika data yang dicari sama dengan data suatu node
berarti kebalikan node tersebut dan berarti data ditemukan.
c. Menghapus node tertentu (rekursif dan non rekursif) beserta
aturan menghapus node :
Delete terhadap node tanpa anak/child (leaf/daun) : node dapat
langsung dihapus. Delete terhadap node dengan satu anak/child :
maka node anak akan menggantikan posisinya. Delete terhadap node
dengan dua anak/child : maka node akan juga digantikan oleh anak
paling kanan dari sub tree kiri.

4
 BAB IV
GRAPH

A. Pengertian Graph

Graph adalah kumpulan node (simpul) di dalam bidang data dimensi

yang dihubungkan dengan sekempulan garis (sisi) Graph dapat digunakan
untuk mempresentasikan objek-objek diskrit dan hubungan antara objek-
objek tersebut. Representasi visual dari graph adalah dengan menyatakan
objek sebagai node, bulatan atau titik (vertex), sedangkan hubungan antara
objek dinyatakan dengan garis (edge).

B. Penjelasan Method

a. Membuat Graph :
Membuat kumpulan node (simpul) di dalam bidang data dimensi
yang dihubungkan dengan sekumpulan garis.
b. Strongly atau Weakly :
Strongly membentuk partisi menjadi subgraph yang terhubung
dengan sendirinya. Bisa juga untuk menguji koneksivitas dari
grafik, atau untuk menemukan komponen yang terhubung.
c. Connected, Disconnected atau Completes :
Connected merupakan subgraph yang dimana setiap dua simpul
terhubung satu sama lain oleh jalur. Disconnected merupakan
graph yang tidak dapat terhubung satu sama lain pada jalurnya.
Completes adalah ketika semua node terhubung ke semua node.

5
 BAB V
TRAVERSAL GRAPH
A. Pengertian Traversal Graph

Graph Traversal merupakan proses mengunjungi setiap

vertex/node. Graph Traversal digunakan untuk mencari jalur dalam suatu
graph dari titik asal ke titik tujuan, mencari jalur terpendek antara dua
node/vertex, menemukan semua jalur yang bisa dilalui dari titik asal ke titik
tujuan.

B. Penjelasan Method

a. Membuat Graph :
Membuat kumpulan node (simpul) di dalam bidang data dimensi
yang dihubungkan dengan sekumpulan garis.
b. Breadth Firstt Search :
Pencarian pertama yang luas menggunakan antrian untuk melintasi
grafik dengan cara yang sama. Node awal ditambahkan ke antrian
untuk memulai. Asalkan antriannya tidak kosong, nodes itu
disingkirkan dan para tetangganya tidak dikunjungi akan
ditambahkan ke dalam antrian, karena sebuah grafik bisa berisi
siklus, seperangkat hash dikunjungi. Hanya ingin memanbahkan
node yang tidak dikunjungi dalam antrian.
c. Dept First Search :
Kedalaman pencarian pertama adalah kebaikan dari FBS. Ini
menggunakan tumpukan sebagai pengganti untuk melintasi grafik.
Node awal ditekan ke tumpukan . selama tumpukan itu tidak kosong,
node-nya akan terbuka. Grafik ini mendalam karena node yang
muncul dari tumpukan adalah yang paling baru didorong, sama
seperti BFS.

6
 LAMPIRAN

Soal 1

 Single Linked List

a. Add .
b. Set.
c. Get.
d. IndexOf.
e. LastIndexOf.
f. Remove(index).
g. Remove(object).
h. ToString().

 Algoritma

public class SingleLinkedList {

public static void main(String[] args){
// Membuat LinkedList
LinkedList<String> benda = new LinkedList<>();
// Menambahkan Data
benda.add("Meja"); //No Index 0
benda.add("Kursi"); //No Index 1
benda.add("Kasur"); //No Index 2
benda.add("Lemari"); //No Index 3
benda.add("Gayung"); //No Index 4

benda.add( "Sapu");
System.out.println("Benda Baru: ");
System.out.println("" + benda);
System.out.println ("");

7
Algoritma :

Untuk pembuatan Single Linked List yang pertama kami lakukan

adalah progam class. Lalu membuat program inputan
LinkedList<String> benda = new LinkedList<>();. Lalu
buat list data benda. Untuk list benda memnggunkan inputan add.

System.out.println ("Jumlah Benda :");

System.out.println (benda + " Total :" +
benda.size());
System.out.println ("");
//Mengambil Data pada Urutan Teratas
System.out.println("Data Teratas :
"+benda.getFirst());
//Mengambil Data pada Urutan Terbawah
System.out.println("Data Terbawah :
"+benda.getLast());
//Mengambil Data pada Nomor Index 1
System.out.println("Data Index 1 :
"+benda.get(1));
//Mengambil Data pada Nomor Index 5
System.out.println("Data Index 5 :
"+benda.get(5));
System.out.println ("");

Algoritma :

Membuat program untuk menampilkan hasil dari inputan.

8
 benda.removeFirst();
System.out.println("Hapus Depan : ");
System.out.println("" +benda +" Total :"
+benda.size());
System.out.println ("");
benda.removeLast();
System.out.println("Hapus Belakang : ");
System.out.println("" +benda +" Total :"
+benda.size());
System.out.println ("");

benda.remove(3);
System.out.println("Hapus: " +benda);

}
}

Algoritma :

Yang terakhir membuat inputan untuk hapus index dan object.

9
 Soal 2

 Binarty Tree
a. Membangun Tree.
b. Traversal tree inorder, postorder, dan preorder.
c. Traversal tree inorder, postorder, dan preorder non rekrusif.
d. Ketinggian tree.
e. Copy Tree.
f. Jumlah Node.

 Algoritma

import static
uasfarhankoingalim.TreeApp.getHeight;

class TreeNode {
int data;
TreeNode left, right;

public TreeNode(int data){

this.data = data;
}
}
class TreeApp {
TreeNode root;

public boolean isEmpty(){

return(root == null);
}

Algoritma :

Pertama kami membuat class program dengan inputan untuk membangun

TreeNode.

10
 public void insert(TreeNode input){
if (isEmpty()){
root = input;
} else{
TreeNode current = root;
TreeNode parent = null;
boolean onLeft = true;
while(current != null){
parent = current;
if(current.data < input.data){
current = current.right;
onLeft = false;
}else if(current.data input.data){
current = current.left;
onLeft = true;
}else{
System.out.println("Data "+input.data+" Telah Ada");
break;
}
}
if(onLeft){
parent.left = input;
}else{
parent.right = input;
}
}
}

public void preOrder(){

preOrder(root);
}
public void inOrder(){
inOrder(root);

11
 }
public void postOrder(){
postOrder(root);
}
public void preOrder(TreeNode akar){
if(akar != null){
System.out.print(akar.data+ " ");
preOrder(akar.left);
preOrder(akar.right);
}
}
public void inOrder(TreeNode akar){
if(akar != null){
inOrder(akar.left);
System.out.print(akar.data+ " ");
inOrder(akar.right);
}
}
public void postOrder(TreeNode akar){
if(akar != null){
postOrder(akar.left);
postOrder(akar.right);
System.out.print(akar.data+ " ");
}
}

Algoritma :

Membuat inputan InOrder, PostOrder, PreOder. Menggunakan public

void. Peletakannya yang pertama PreOrder, yang kedua InOrder, yang
ketiga PostOrder.

12
 public TreeNode search(int key){
TreeNode node = null;
TreeNode current = root;
while(current != null){
if(current.data == key){
return node;
}else{
if(current.data < key){
current = current.right;
}else{
current = current.left;
}
}
}
return node;
}
public static int getHeight (TreeNode node) {
if (node == null)
return 3;
else{
int a=getHeight(node.left);
int b=getHeight(node.right);
if (a>b)
return a+1;
else
return b+1;
}
}
}
public class Binarytree {
public static void main(String[] args) {
TreeApp tree = new TreeApp();
TreeNode node;
node = new TreeNode(350);
tree.insert(node);
node = new TreeNode(150);
tree.insert(node);
node = new TreeNode(50);
tree.insert(node);
node = new TreeNode(300);
tree.insert(node);
node = new TreeNode(450);
tree.insert(node);

13
 node = new TreeNode(100);
tree.insert(node);
node = new TreeNode(200);
tree.insert(node);
node = new TreeNode(400);
tree.insert(node);
node = new TreeNode(250);
tree.insert(node);
node = new TreeNode(500);
tree.insert(node);
System.out.print("\nPreOrder Traversal :
");
tree.preOrder();
System.out.print("\nInOrder Traversal :
");
tree.inOrder();
System.out.print("\nPostOrder Traversal :
");
tree.postOrder();
System.out.println("");
System.out.println("Height : " +getHeight
(node));
}
}

Algoritma :

Untuk menentukan ketinggian di program binary tree, kami menggunakan

inputan getHeight. Menambahkan list data inputan untuk ditampilkan di
output.

14
Soal 3

 Binary Search Tree

a. Membangun Binary Search Tree.
b. Mencari sebuah node, mencari node terbesar dan terkecil (rekrusif dan
non rekrusif).
c. Menghapus node tertentu (rekrusif dan non rekrusif) beserta aturan
menghapus node.

 Algoritma

public class Binarysearchtree {

public static class Node{
int data;
Node left;
Node right;

public Node(int data){

// Tetapkan data ke simpul baru,
atur left Dan right children ke null
this.data = data;
this.left = null;
this.right = null;
}
}

//untuk akar pohon biner

public Node root;

public Binarysearchtree (){

root = null;

15
Algoritma :

Pertama kami membuat inputan yang berisi int data node kiri dan node
kanan. Lalu buat akar biner dengan perintah public Node root;.

//insert() akan menambahkan node baru ke pohon

pencarian biner
public void insert(int data) {
//Membuat node baru
Node newNode = new Node(data);

//Check whether tree is empty

if(root == null){
root = newNode;
return;
}
else {
// titik simpul saat ini ke akar pohon
Node current = root, parent = null;
while(true) {
// melacak simpul induk dari simpul saat ini.
parent = current;

//Jika data lebih kecil dari data saat ini, simpul

akan disisipkan di sebelah kiri pohon
if(data < current.data) {
current = current.left;
if(current == null) {
parent.left = newNode;
return;
}
}

16
 //Jika data lebih besar dari data saat ini,
simpul akan disisipkan di sebelah kanan pohon
else {
current = current.right;
if(current == null) {
parent.right = newNode;
return;
}
}
}
}
}

Algoritma :
Membuat perintah insert, digunakan untuk menambah node baru pada
binary tree. Atur titik simpul kearah akar pohon, lacak simpul parent.
Apabila data lebih kecil dari yang saat ini, maka simpul akan di sisipkan
kekiri. Apabila lebih dari data yang saat ini, simpul disisipkan ke kanan.

// minNode() akan mengetahui node minimum

public static Node minNode(Node root) {
if (root.left != null)
return minNode(root.left);
else
return root;
}
//deleteNode() akan menghapus node yang
diberikan dari pohon pencarian biner
public Node deleteNode(Node node, int value) {
if(node == null){
return null;
}
else {

17
 //nilai lebih kecil dari data simpul, cari
nilai di subpohon kiri
if(value < node.data)
node.left = deleteNode(node.left, value);

//nilai lebih besar dari data simpul, cari

nilai di subpohon kanan
else if(value > node.data)
node.right = deleteNode(node.right, value);

//Jika nilainya sama dengan data node, berati

telah menemukan node yang akan dihapus
else {
//Jika node yang akan dihapus tidak memiliki child
setel node ke null
if(node.left == null && node.right == null)
node = null;
//Jika node yang akan dihapus hanya memiliki
satu child kanan
else if(node.left == null) {
node = node.right;
}
//Jika node yang akan dihapus hanya memiliki
satu child tersisa
else if(node.right == null) {
node = node.left;
}
//Jika simpul yang akan dihapus memiliki dua
simpul children node
else {

18
 //kemudian cari simpul minimum dari subpohon
kanan
Node temp = minNode(node.right);
// tukar data antara node dan temp
node.data = temp.data;
//Hapus simpul duplikat dari subpohon kanan
node.right = deleteNode(node.right, temp.data);
}
}
return node;
}
}
//inorder() akan melakukan traversal
inorder pada pohon pencarian biner
public void inorderTraversal(Node node) {
//Periksa apakah pohon kosong
if(root == null){
System.out.println("Tree is empty");
return;
}
else {
if(node.left!= null)
inorderTraversal(node.left);
System.out.print(node.data + " ");
if(node.right!= null)
inorderTraversal(node.right);
}
}

19
 public static void main(String[] args) {
Binarysearchtree bt = new Binarysearchtree ();
//Tambahkan node ke pohon biner
bt.insert(60);
bt.insert(40);
bt.insert(80);
bt.insert(70);
bt.insert(20);
bt.insert(100);
System.out.println("Binary search
tree after insertion:");
//Menampilkan pohon biner
bt.inorderTraversal(bt.root);
Node deletedNode = null;
//Menghapus node 90 yang tidak memiliki child
deletedNode = bt.deleteNode(bt.root, 80);
System.out.println("\nBinary search tree after
deleting node 90:");
bt.inorderTraversal(bt.root);
//Menghapus node 30 yang memiliki satu child
deletedNode = bt.deleteNode(bt.root,20);
System.out.println("\nBinary search tree after
deleting node 30:");
bt.inorderTraversal(bt.root);
//Menghapus node 50 yang memiliki dua children
deletedNode = bt.deleteNode(bt.root, 60);
System.out.println("\nBinary search
tree after deleting node 50:");
bt.inorderTraversal(bt.root);

}
}

20
Algoritma :
Membuat perintah dengan perintah public static node deleteNode,
digunakan untuk mengetahui minimum node. Dan membuat inputan untuk
menghapus node.

21
Soal 4

 Graph
a. Membuat Graph.
b. Strongly atau Weakly.
c. Connected, Disconneted atau Completes.

 Algoritma

package uasfarhankoingalim;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

class Graph<T> {
private Map<T, List<T> > map = new HashMap<>();
public void addVertex(T s)
{
map.put(s, new LinkedList<T>());
}
public void addEdge(T source,
T destination,
boolean bidirectional)
{
if (!map.containsKey(source))
addVertex(source);
if (!map.containsKey(destination))
addVertex(destination);
map.get(source).add(destination);
if (bidirectional == true) {
map.get(destination).add(source);
}
}

22
Algoritma :
Pertama-tama kami membuat class simpul edge dan import.

public void getVertexCount()

{
System.out.println("The graph has "
+ map.keySet().size()
+ " vertex");
}
public void getEdgesCount(boolean bidirection)
{
int count = 0;
for (T v : map.keySet()) {
count += map.get(v).size();
}
if (bidirection == true) {
count = count / 2;
}
System.out.println("The graph has "
+ count
+ " edges.");
}
public void hasVertex(T s)
{
if (map.containsKey(s)) {
System.out.println("The graph contains "
+ s + " as a vertex.");
}
else {
System.out.println("The graph does not contain "
+ s + " as a vertex.");
}
}

23
 public void hasEdge(T s, T d)
{
if (map.get(s).contains(d)) {
System.out.println("The graph has an edge between "
+ s + " and " + d + ".");
}
else {
System.out.println("The graph has no edge between "
+ s + " and " + d + ".");
}
}
@Override
public String toString()
{
StringBuilder builder = new
StringBuilder();
for (T v : map.keySet()) {
builder.append(v.toString() + ": ");
for (T w : map.get(v)) {
builder.append(w.toString() + " ");
}
builder.append("\n");
}
return (builder.toString());
}

24
public static void main(String args[]){
Graph<Integer> g = new Graph<Integer>();
g.addEdge(0, 1, true);
g.addEdge(0, 4, true);
g.addEdge(1, 2, true);
g.addEdge(1, 3, true);
g.addEdge(1, 4, true);
g.addEdge(2, 3, true);
g.addEdge(3, 4, true);
System.out.println("Graph:\n"
+ g.toString());
g.getVertexCount();
g.getEdgesCount(true);
g.hasEdge(3, 4);
g.hasVertex(5);
}
int getvCount() {
throw new
UnsupportedOperationException("Not supported
yet.");
}

Iterable<Integer> neighbours(int i) {
throw new
UnsupportedOperationException("Not supported
yet.");
}
}

25
Algoritma :
Membuat program inputan dan menambahkan data yang ingin di masukan.
Membuat method untuk menghubungkan vertex dan edge.

26
Soal 5

 Traversal Graph
a. Membuat Graph.
b. Breadth First Search.
c. Deepth First Search.

 Algoritma

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
public class Traversalgraph {
private int vCount;
private List<Integer>[] adj;

public int getvCount() {

return vCount;
}

public Traversalgraph(int vCount) {

this.vCount = vCount;
adj = (List<Integer>[]) new List[vCount];
for (int i = 0; i < vCount; i++)
adj[i] = new ArrayList<Integer>();
}

Algoritma :
Pertama kita membuat class traversal breath first search dan isi intV dan
linked list yang berisi integer .

27
public void addEdge(int i, int j) {
adj[i].add(j);
}
public void removeEdge(int i, int j) {
Iterator<Integer> it = adj[i].iterator();
while (it.hasNext()) {
if (it.next() == j) {
it.remove();
return;
}
}
}
public boolean hasEdge(int i, int j) {
return adj[i].contains(j);
}
public List<Integer> neighbours(int vertex) {
return adj[vertex];
}
public void printGraph() {
for (int i = 0; i < vCount; i++) {
List<Integer> edges = neighbours(i);
System.out.print(i + ": ");
for (int j = 0; j < edges.size(); j++) {
System.out.print(edges.get(j) + " ");
}
System.out.println();
}
}

28
public static void bfs(Traversalgraph g, int v) {
boolean[] seen = new boolean[g.getvCount()];
LinkedList<Integer> q = new
LinkedList<Integer>(); // queue-like
q.add(v);
seen[v] = true;
while (!q.isEmpty()) {
int i = q.remove();
for (Integer j : g.neighbours(i)) {
if (!seen[j]) {
q.add(j);
seen[j] = true;
}
}
}

Algoritma :
Membuat graph dengan V adj/adjacency yaitu new linked list, tambahkan
adges ke graph.

System.out.print(v + " -> ");

for (int i = 0; i < seen.length; i++) {
if (seen[i])
System.out.print(i + ", ");
}
System.out.println();
}

public static void dfs(Traversalgraph g, int v) {

byte white = 0, grey = 1, black = 2;
byte[] c = new byte[g.getvCount()];
Stack<Integer> s = new Stack<Integer>();
s.push(v);

29
 while (!s.isEmpty()) {
int i = s.pop();
if (c[i] == white) {
c[i] = grey;
for (int j : g.neighbours(i))
s.push(j);
c[i] = black;
}
}
System.out.print(v + " -> ");
for (int i = 0; i < c.length; i++) {
if (c[i] == black)
System.out.print(i + ", ");
}
System.out.println();
}
public static void main(String[] args) {
Traversalgraph g = new Traversalgraph(5);

System.out.println("Graph:");
// add Edges
g.addEdge(0, 2);
g.addEdge(0, 4);
g.addEdge(1, 4);
g.addEdge(1, 4);
g.addEdge(2, 1);
g.addEdge(2, 3);
g.addEdge(3, 4);
g.addEdge(4, 2);

30
 // print Graph
g.printGraph();

// Traversal Algorithms
System.out.println("BFS:");
bfs(g, 0);
bfs(g, 1);

System.out.println("DFS:");
dfs(g, 0);
dfs(g, 1);
}
}

Algoritma :
Membuat program BFS dan DFS. Buat inputan public static void main
digunakan memanggil progam traversal graph dan panggil inputan BFS dan
DFS.

31