PRAKTIKUM 5

Graph & Tree

A. TUJUAN
Setelah melakukan praktikum bab ini, mahasiswa diharapakan mampu :
1. Memahami konsep-konsep algoritma Graph dan Tree
2. Mengimplementasikan algoritma Graph dan Tree untuk menyelesaikan sebuah
studi kasus.

B. DASAR TEORI
B1. GRAPH

Suatu graph didefinisikan oleh himpunan vertex (V) dan edge (E). Verteks
menyatakan entitas-entitas data dan edge menyatakan keterhubungan antara verteks.
Biasanya untuk suatu graph G digunakan notasi matematis.
G = (V, E)
Dimana : G = Graph
V = Simpul atau Vertex, atau Node, atau Titik
E = Busur atau Edge, atau arc

B.1.1 JENIS-JENIS GRAPH

1. Directed Graph (Digraph)

Jika sisi-sisi graph hanya berlaku satu arah. Misalnya : {x,y} yaitu arah x ke y, bukan
dari y ke x, x disebut origin dan y disebut terminus. Secara notasi sisi digraph
ditulis sebagai vektor (x, y).

Contoh Digraph G = {V, E} :

V = {A, B, C, D, E, }
E = {(A,B), (A,D), (B,A), (B,E), (B,C), (C,B), (C,D), (C,E), (D,E), }.
2. Graph Tak Berarah (Undirected Graph atau Undigraph)
Setiap sisi {x, y} berlaku pada kedua arah: baik x ke y maupun y ke x. Secara grafis
sisi pada undigraph tidak memiliki mata panah dan secara notasional
menggunakan kurung kurawal.
Contoh Undigraph G = {V, E}
V = {A, B, C, D, E, F, G, H, I,J, K, L, M}
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}}.

3. Graph Berbobot (Weighted Graph)

Jika setiap busur mempunyai nilai yang menyatakan hubungan antara 2 buah
simpul, maka busur tersebut dinyatakan memiliki bobot. Bobot sebuah busur
dapat menyatakan panjang sebuah jalan dari 2 buah titik, jumlah rata-rata
kendaraan perhari yang melalui sebuah jalan, dll.

POLITEKNIK KEDIRI 2
B.1.2 REPRESENTASI GRAPH
Representasi Graph dapat dilakukan dengan 2 cara yaitu melalui metrik maupun
linkedlist. Penjelasan lebih lanjut akan dijelaskan ppada sub bab berikut.
a. Representasi Graph Tak Berarah Berbentuk Metrik

Graf tersebut dapat direpresentasikan dalam sebuah matrik 5x5 , dimana baris
dan kolom di matriks tersebut menunjukan vertex yang ada.

b. Representasi Graph Berarah Berbentuk Metrik

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

POLITEKNIK KEDIRI 3
 menandakan tidak ada edge yang mengubungkan secara langsung dua vertex
tersebut.
c. Representasi Graph Berarah dan Berbobot Berbentuk Metrik
Ada kalanya graph memiliki nilai. Anggaplah nilai tersebut adalah jarak. Maka dari
situ nantinya kita akan dapat mencari rute tercepat untuk sampai ke titik vertek
tujuan yang telah ditentukan. Contoh representasi Graph berarah dan memiliki
bobot ditunjukkan pada gambar di abwah ini.

d. Representasi Graph berbentuk Linked List

Selain melalui matriks graph juga bisa direpresentasikan dengan linkedlist.
Konsep keterkaitan graph pada linked list dijelaskan sebagai berikut.

Contoh representasi graph berbentuk linked list ditunjukkan sebagai berikut.

a. Graph tidak berarah b. Graph berarah

POLITEKNIK KEDIRI 4
 c. Graph berarah dan berbobot

B.1.3 METODE PENCARIAN VERTEKS DAN LINTASAN TERPENDEK

Ada 2 algoritma yang bisa digunakan untuk mencari nilai vertex pada graph, yaitu
algoritma Depth First Search (DFS) dan Breadth First Search (BFS). Sedangkan untuk
mencari lintasan terpendek dapat digunakan Algoritma Dijkstra’s dan Dynamic
Programming. Keseluruhan algoritma tersebut akan dibahas pada pertemuan
selanjutnya.

B2. TREE
Tree merupakan salah satu bentuk struktur data bukan linier yang
menggambarkan bentuk hierarki antara elemen-elemen. Tree biasanya terdiri dari root
(akar) dan node-node (simpul-simpul) yang berada di bawah root. Struktur seperti tree
sangat banyak sekali dgunakan dalam dunia nyata, misalnya: struktur organisasi suatu
perusahaan, pengaturan filesystem, daftar isi sebuah buku, dan masih banyak lagi.
Ilustrasi tree ditunjukkan pada gambar di bawah ini.

POLITEKNIK KEDIRI 5
Beberapa istilah terkait tree dijelaskan pada tabel berikut:
NAMA KETERANGAN CONTOH
Degree jumlah edge yang keluar dan node E memiliki in degree 1 dan out
(derajat) masuk dari sebuah node. degree 2
Root (akar) node yang memiliki derajat node A adalah root
keluar >=0 dan derajat masuk =
0.
Subtree / bagian salah satu node dibawah tree C adalah right subtree dari A dan
child root sampai ke bawah. tree B merupakan left subtree dari A
node G dan F merupakan child dari
node C node F merupakan parent dari
node J dan K
Ancestor Node yang berada di atas node node B adalah ancestor dari node E
lain.
Descendant node yang berada di bawah node E adalah descendant dari node A.
node lain.
Leaf (daun) semua node yang derajat node D, H, I, J, K, dan G adalah leaf
masuknya 1 dan derajat
keluarnya 0.
Sibling node yang mempunyai level node D adalah sibling dari node A
yang sama dan parent yang
sama.
Height level tertinggi dari tree height dari tree A adalah 3 + 1 = 4
(ketinggian) ditambah 1.
Weight jumlah leaf(daun) pada tree. weight dari tree A adalah 6
(bobot)

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.

Binary tree terdiri dari :

1. Full Binary Tree : semua node (kecuali leaf pasti memiliki 2 anak dan tiap subtree
memiliki panjang path yang sama)

POLITEKNIK KEDIRI 6
 2. Complete Binary Tree : mirip dengan full binary tree, tetapi tiap subtree boleh
memiliki panjang path yang berbeda dan tiap node (kecuali leaf memiliki 2 anak)

3. Skewed Binary Tree : binary tree yang semua nodenya (kecuali leaf) hanya
memiliki satu anak

Operasi Pada Binary Search Tree (BST) ada 4 yaitu

1. Traversal
2. Search
3. Insertion
4. Delete

POLITEKNIK KEDIRI 7
1. Pembacaan (Traversal) data pada binary tree dibagi menjadi 3 yaitu:
a. PreOrder: Cetak root lalu mencetak seluruh data pada sub pohon kiri.
Kemudian mencetak data pada sub pohon kanan.

Maka akan terbaca : A-B-D-E-C-E-F-G

b. InOrder:mencetak seluruh data pada sub pohon kiri, root kemudian sub
pohon kanan.
Maka akan terbaca: D-B-E-A-F-C-G
c. PostOrder: Mencetak seluruh data pada sub pohon kiri. Kemudian
mencetak data pada sub pohon kanan lalu root
Maka akan terbaca: D-E-B-F-G-C-A
2. Pencarian pada BST didasarkan dari perbandingan dengan nilai root. Jika data
yang dicari lebih kecil dari root maka akan ke node kiri, jika lebih besar maka akan
ke node kanan.

3. Penambahan Node
Penambahan node pada BST harus mengikuti aturan minMax, dimana node yang
bernilai lebih kecil dari root diletakkan pada subtree sebelah kiri sedangkan node

POLITEKNIK KEDIRI 8
 yang bernilai lebih besar diletakkan pada subtree sebelah kanan. Jika ada nilai
yang sama maka node tersebut di-overwrite.

4. Penghapusan Node
Proses penghapusan data pada binary search tree lebih rumit daripada proses
searching maupun proses insertion. Tahapan proses penghapusan yaitu:
1. Carilah node yang akan dihapus
2. Apabila node tersebut leaf (tidak mempunyai anak), hapuslah node tersebut
3. Bila node tersebut memiliki 1 anak, setelah node dihapus, anaknya
menggantikan posisi orangtuanya (node yang dihapus)

4. Bila node tersebut memiliki 2 anak. Setelah node dihapus, gantikan node
tersebut dengan elemen terkecil dari right sub-tree ATAU elemen terbesar
dari left sub-tree

POLITEKNIK KEDIRI 9
C. TUGAS PENDAHULUAN
1. Apa yang dimaksud dengan ADT Graph?
2. Jelaskan maksud bagian graph yaitu vertex dan edge...?
3. Apa yang dimaksud dengan representasi graph menggunakan adjacency matrik?
D. PERALATAN DAN KOMPONEN
1. Komputer /Laptop sebagai hardware
2. Netbeans sebagai editor source code

E. LANGKAH PRAKTIKUM
1. Buatlah kelas bernama M5_Binary kemudian ketikkan source code berikut:
package StrukturData;

/**
*
* @author asus
*/
import java.util.Scanner;

import java.io.*;
import java.util.*; // for Stack class
////////////////////////////////////////////////////////////////

class Node {

public int iData; // data item (key)

public double dData; // data item
public Node leftChild; // this node's left child
public Node rightChild; // this node's right child

public void displayNode() // display ourself

{
System.out.print('{');
System.out.print(iData);
System.out.print(", ");
System.out.print(dData);
System.out.print("} ");
}
} // end class Node
////////////////////////////////////////////////////////////////

class Tree {

private Node root; // first node of tree

// -------------------------------------------------------------
public Tree() // constructor
{
root = null;
} // no nodes in tree yet
// -------------------------------------------------------------

public Node find(int key) // find node with given key

{ // (assumes non-empty tree)
Node current = root; // start at root
while (current.iData != key) // while no match,
{
if (key < current.iData) // go left?
{
current = current.leftChild;
} else // or go right?
{
current = current.rightChild;
}

POLITEKNIK KEDIRI 10
 if (current == null) // if no child,
{
return null; // didn't find it
}
}
return current; // found it
} // end find()
// -------------------------------------------------------------

public void insert(int id, double dd) {

Node newNode = new Node(); // make new node
newNode.iData = id; // insert data
newNode.dData = dd;
if (root == null) // no node in root
{
root = newNode;
} else // root occupied
{
Node current = root; // start at root
Node parent;
while (true) // (exits internally)
{
parent = current;
if (id < current.iData) // go left?
{
current = current.leftChild;
if (current == null) // if end of the line,
{ // insert on left
parent.leftChild = newNode;
return;
}
} // end if go left
else // or go right?
{
current = current.rightChild;
if (current == null) // if end of the line
{ // insert on right
parent.rightChild = newNode;
return;
}
} // end else go right
} // end while
} // end else not root
} // end insert()
// -------------------------------------------------------------

public boolean delete(int key) // delete node with given key

{ // (assumes non-empty list)
Node current = root;
Node parent = root;
boolean isLeftChild = true;

while (current.iData != key) // search for node

{
parent = current;
if (key < current.iData) // go left?
{
isLeftChild = true;
current = current.leftChild;
} else // or go right?
{
isLeftChild = false;
current = current.rightChild;
}
if (current == null) // end of the line,
{
return false; // didn't find it
}
} // end while
// found node to delete

// if no children, simply delete it

if (current.leftChild == null
&& current.rightChild == null) {
if (current == root) // if root,
{

POLITEKNIK KEDIRI 11
 root = null; // tree is empty
} else if (isLeftChild) {
parent.leftChild = null; // disconnect
} else // from parent
{
parent.rightChild = null;
}
} // if no right child, replace with left subtree
else if (current.rightChild == null) {
if (current == root) {
root = current.leftChild;
} else if (isLeftChild) {
parent.leftChild = current.leftChild;
} else {
parent.rightChild = current.leftChild;
}
} // if no left child, replace with right subtree
else if (current.leftChild == null) {
if (current == root) {
root = current.rightChild;
} else if (isLeftChild) {
parent.leftChild = current.rightChild;
} else {
parent.rightChild = current.rightChild;
}
} else // two children, so replace with inorder successor
{
// get successor of node to delete (current)
Node successor = getSuccessor(current);

// connect parent of current to successor instead

if (current == root) {
root = successor;
} else if (isLeftChild) {
parent.leftChild = successor;
} else {
parent.rightChild = successor;
}

// connect successor to current's left child

successor.leftChild = current.leftChild;
} // end else two children
// (successor cannot have a left child)
return true; // success
} // end delete()
// -------------------------------------------------------------
// returns node with next-highest value after delNode
// goes to right child, then right child's left descendents

private Node getSuccessor(Node delNode) {

Node successorParent = delNode;
Node successor = delNode;
Node current = delNode.rightChild; // go to right child
while (current != null) // until no more
{ // left children,
successorParent = successor;
successor = current;
current = current.leftChild; // go to left child
}
// if successor not
if (successor != delNode.rightChild) // right child,
{ // make connections
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
return successor;
}
// -------------------------------------------------------------

public void traverse(int traverseType) {

switch (traverseType) {
case 1:
System.out.print("\nPreorder traversal: ");
preOrder(root);
break;
case 2:

POLITEKNIK KEDIRI 12
 System.out.print("\nInorder traversal: ");
inOrder(root);
break;
case 3:
System.out.print("\nPostorder traversal: ");
postOrder(root);
break;
}
System.out.println();
}
// -------------------------------------------------------------

private void preOrder(Node localRoot) {

if (localRoot != null) {
System.out.print(localRoot.iData + " ");
preOrder(localRoot.leftChild);
preOrder(localRoot.rightChild);
}
}
// -------------------------------------------------------------

private void inOrder(Node localRoot) {

if (localRoot != null) {
inOrder(localRoot.leftChild);
System.out.print(localRoot.iData + " ");
inOrder(localRoot.rightChild);
}
}
// -------------------------------------------------------------

private void postOrder(Node localRoot) {

if (localRoot != null) {
postOrder(localRoot.leftChild);
postOrder(localRoot.rightChild);
System.out.print(localRoot.iData + " ");
}
}
// -------------------------------------------------------------

public void displayTree() {

Stack globalStack = new Stack();
globalStack.push(root);
int nBlanks = 32;
boolean isRowEmpty = false;
System.out.println(
"......................................................");
while (isRowEmpty == false) {
Stack localStack = new Stack();
isRowEmpty = true;

for (int j = 0; j < nBlanks; j++) {

System.out.print(' ');
}

while (globalStack.isEmpty() == false) {

Node temp = (Node) globalStack.pop();
if (temp != null) {
System.out.print(temp.iData);
localStack.push(temp.leftChild);
localStack.push(temp.rightChild);

if (temp.leftChild != null
|| temp.rightChild != null) {
isRowEmpty = false;
}
} else {
System.out.print("--");
localStack.push(null);
localStack.push(null);
}
for (int j = 0; j < nBlanks * 2 - 2; j++) {
System.out.print(' ');
}
} // end while globalStack not empty
System.out.println();
nBlanks /= 2;

POLITEKNIK KEDIRI 13
 while (localStack.isEmpty() == false) {
globalStack.push(localStack.pop());
}
} // end while isRowEmpty is false
System.out.println(
"......................................................");
} // end displayTree()
// -------------------------------------------------------------
} // end class Tree
////////////////////////////////////////////////////////////////

class BinarySearchTree {

public static void main(String[] args) throws IOException {

System.out.println("==============================");
System.out.println(" Binary Search Tree ");
System.out.println("==============================");

int value;
Tree theTree = new Tree();

theTree.insert(50, 1.5);
theTree.insert(25, 1.2);
theTree.insert(75, 1.7);
theTree.insert(12, 1.5);
theTree.insert(37, 1.2);
theTree.insert(43, 1.7);
theTree.insert(30, 1.5);
theTree.insert(33, 1.2);
theTree.insert(87, 1.7);
theTree.insert(93, 1.5);
theTree.insert(97, 1.5);

while (true) {
System.out.println("\n>> Operasi BST: ");
System.out.print("Masukkan huruf "
+ "\ns : show the tree (menampilkan tree)"
+ "\ni : insert a node (memasukkan node)"
+ "\nf : find a node (mencari node)"
+ "\nd : delete a node (menghapus node)"
+ "\nt : traverse (pencarian)\n");
System.out.print(">> Pilihan Operasi : ");
int choice = getChar();
switch (choice) {
case 's':
theTree.displayTree();
break;
case 'i':
System.out.print("Input nilai yang akan dimasukkan dalam tree:
");
value = getInt();
theTree.insert(value, value + 0.9);
break;
case 'f':
System.out.print("Input nilai yang dicari: ");
value = getInt();
Node found = theTree.find(value);
if (found != null) {
System.out.print("Nilai ditemukan : ");
found.displayNode();
System.out.println();
} else {
System.out.print("Nilai tidak ditemukan ");
}
System.out.print(value + '\n');
break;
case 'd':
System.out.print("Input nilai yang akan dihapus : ");
value = getInt();
boolean didDelete = theTree.delete(value);
if (didDelete) {
System.out.print("Terhapus " + value + '\n');
} else {
System.out.print("Tidak bisa dihapus ");
}
System.out.print(value + '\n');

POLITEKNIK KEDIRI 14
 break;
case 't':
System.out.println("1. Preorder\n2. Inorder \n3. Postorder");
System.out.print("Masukkan 1/2/3: ");
value = getInt();
theTree.traverse(value);
break;

default:
System.out.print("Invalid entry\n");
} // end switch
} // end while
} // end main()
// -------------------------------------------------------------

public static String getString() throws IOException {

InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
// -------------------------------------------------------------

public static char getChar() throws IOException {

String s = getString();
return s.charAt(0);
}
//-------------------------------------------------------------

public static int getInt() throws IOException {

String s = getString();
return Integer.parseInt(s);
}
// -------------------------------------------------------------
} // end class TreeApp
////////////////////////////////////////////////////////////////

2. Pahami setiap baris codenya.

3. Jelaskan maksud dari setiap baris code, kerjakan secara berkelompok.

F. TUGAS
1. Ilustrasikan model binary search tree di bawah ini setelah anda melakukan
perintah-perintah berikut:
a. Hapus 15
b. Hapus 7
c. Tambahkan 16

POLITEKNIK KEDIRI 15
 2. Buatlah source code yang akan menampilkan hasil yang sama dengan ilustrasi di
atas mulai dari data yang lengkap, penghapusan node 15 dan 7 serta penambahan
node 16.

G. PENUTUP
Pastikan hal-hal berikut sebelum Anda keluar dari laboratorium :
1. Meja dan kursi tertata kembali dalam keadaan rapi.
2. Komputer dan Monitor dalam keadaan mati.
3. Peralatan dan komponen dikembaikan ke tempat asalnya.
4. Laboratorium dalam keadaan bersih dan rapi.
5. Jangan meninggalkan barang pribadi di laboratorium

G. REFERENSI
Wibowo, Nur Cahyo., Ridwandono, Doddy., Modul Praktikum Struktur Data:
Surabaya,2016
https://algorithms.tutorialhorizon.com/binary-search-tree-complete-
implementation/
http: //okeinformatika.blogspot.com/2015/12 /algoritma-dan-struktur-data-
pertemuan.html?m=1

POLITEKNIK KEDIRI 16