LAPORAN PRAKTIKUM ALGORITMA DAN

STRUKTUR DATA
PROGRAM TEKNOLOGI INFORMASI DAN ILMU
KOMPUTER
UNIVERSITAS BRAWIJAYA

BAB : ADT GRAPH

NAMA : FATHURRAHMAN ANNAFABI
NIM : 145150207111142
TANGGAL : 07/12/2015
ASISTEN : - FIKI HAFIZ ALFARISI
- RANU GOLDAN ELZATAR

A. DEFINISI MASALAH

1. Menambahkan method untuk mengetahui berapa jumlah edge yang masuk

atau keluar dari suatu node.

2. Menambahkan pada ADT program di atas untuk merepresentasikan graph

dengan matrik adjacency.

3. Membuat sub program untuk mendapatkan tetangga dari suatu node

tertentu.

4. Melakukan penulusuran node dari grap menggunakan BFS dan DFS

menggunakan struktur data yang pernah dibuat stack atau antrian.

5. Melakukan modifikasi pada ADT graph sehingga suatu hubungan antar

node terdapat nilai jarak.

6. Berdasarkan hasil modifikasi pada tugas 5, menyusun method untuk

menghitung jarak terpendek dari suatu node asal ke node tujuan.

B. SOURCE CODE

Method untuk mengetahui jumlah edge

46 public void jumlahEdge() {

System.out.println("------------------------------------------
47 ");
System.out.println(" Jumlah Edge
48 ");

System.out.println("------------------------------------------
49 ");
50 for (int i = 0; i < jNode; i++) {
System.out.println("Vertex["+i+"] Edge Masuk :
51 "+inEdge(i)+", Edge Keluar : "+outEdge(i));
52 }

System.out.println("------------------------------------------
53 \n");
54 }
55 public int inEdge(int idx) {
56 int count = 0;
57 for (int i = 0; i < jNode; i++) {
58 Node temp = node[i];
59 while (temp != null) {
60 if (idx == temp.getDt()) {
61 count++;
62 }
63 temp = temp.getNext();
64 }
65 }
66 return count;
67 }
68 public int outEdge(int idx) {
69 int count = 0;
70 Node temp = node[idx];
71 while (temp != null) {
72 count++;
73 temp = temp.getNext();
74 }
75 return count;
76 }

Method untuk menampilkan matriks adjacency

78 public void matrixAdjacency() {

System.out.println("------------------------------------------
79 ");
System.out.println(" Matrix Adjacency
80 ");

System.out.println("------------------------------------------
81 ");
82 System.out.print(" ");
83 for (int i = 0; i < jNode; i++) {
84 System.out.print("["+(i)+"]");
85 }
86 System.out.println("");
87 for (int i = 0; i < jNode; i++) {
88 System.out.print("["+(i)+"]| ");
89 for (int j = 0; j < jNode; j++) {
90 System.out.print(matAdj[i][j] + " ");
91 }
92 System.out.println("|");
93 }
94
 System.out.println("------------------------------------------
-\n");
95 }

Method untuk mendapatkan tetangga

97 public void tetangga() {

System.out.println("------------------------------------------
98 ");
System.out.println(" Tetangga Node
99 ");

System.out.println("------------------------------------------
100 ");
101 for (int i = 0; i < jNode; i++) {
102 System.out.print("Tetangga ["+i+"] : ");
103 Node temp = tetangga[i];
104 Node n = node[i];
105 while (temp != null) {
106 System.out.print(temp.getDt()+" <= ");
107 temp = temp.getNext();
108 }
109 System.out.print("Node["+i+"]");
110 while (n != null) {
111 System.out.print(" => "+n.getDt());
112 n = n.getNext();
113 }
114 System.out.println();
115 }

System.out.println("------------------------------------------
116 \n");
117 }

Method BFS dan DFS

119 Public void bfs() {

System.out.println("------------------------------------------
120 ");
System.out.println(" Breadth First Search
121 ");

System.out.println("------------------------------------------
122 ");
123 find = false;
124 array = new int[jNode];
125 array[0] = 0;
126 System.out.print(array[0]);
127 int Checkpoint = 1;
128 int i = 0;
129 int p = 1;
130 while (array[jNode - 1] == 0) {
131 for (int j = 0; j < jNode; j++) {
132 if (matAdj[i][j] >= 1) {
133 for (int k : array) {
134 if (array[k] == j) {
135 find = true;
136 }
137 }
138 if (find != true) {
139 array[Checkpoint] = j;
140 Checkpoint++;
141 }
142 }
143 find = false;
144 }
145 i = array[p];
146 p++;
147 }
148 for (int l = 1; l < jNode; l++) {
149 System.out.print(" >> " + array[l]);
150 }

System.out.println("\n----------------------------------------
151 --\n");
152 }
153 public void dfs(int idx) {
154 array = new int[jNode];

System.out.println("------------------------------------------
155 ");
System.out.println(" Depth First
156 Search("+idx+")");

System.out.println("------------------------------------------
157 ");
158 dfsNode(0);
159 System.out.print(0);
160 for (int i = 1; i < jNode; i++) {
161 if (idx == 0) {
162 break;
163 } else if (idx != array[i]) {
164 System.out.print(" >> " + array[i]);
165 } else if (idx == array[i]) {
166 System.out.println(" >> " + array[i]);
167 break;
168 }
169 }

System.out.println("------------------------------------------
170 \n");
171 }
172 public void dfsNode(int idx) {
173 int[] temp = new int[jNode + 1];
174 int count = 0;
175 find = false;
176 for (int j = 0; j < jNode; j++) {
177 if (matAdj[idx][j] >= 1) {
178 for (int w : array) {
179 if (array[w] == j) {
180 find = true;
181 }
182 }
183 if (find != true) {
184 temp[count] = j;
185 count++;
186 }
187 }
188 find = false;
189 }
190 for (int k = 0; k < jNode; k++) {
191 for (int w = 0; w < jNode; w++) {
192 if (temp[k] == array[w]) {
193 find = true;
194 }
195 }
196 if (find != true) {
197 array[checkpoint] = temp[k];
198 checkpoint++;
199 dfsNode(temp[k]);
200 }
201 find = false;
202 }
203 }

Modifikasi pada ADT Graph

1 public class Graph {
2 private class Node {
3 private int data, jarak;
4 private Node next;
 5 public Node(int dt, Node n, int j) {
6 data = dt;
7 next = n;
8 jarak = j;
9 }
10 public int getDt() {
11 return data;
12 }
13 public Node getNext() {
14 return next;
15 }
16 public int getJarak() {
17 return jarak;
18 }
19 }
20 private Node[] node;
21 private int jNode;
22 int matAdj[][];
23 Node[] tetangga;
24 private int[] array;
25 int checkpoint = 1;
26 boolean find = false;
27 public Graph(int n) {
28 jNode = n;
29 node = new Node[jNode];
30 tetangga = new Node[jNode];
31 for (int i = 0; i < jNode; i++) {
32 node[i] = null;
33 tetangga[i] = null;
34 }
35 matAdj = new int [jNode][jNode];
36 }
37 public void addAdj(int head, int adj, int jrk) {
38 Node n = new Node(adj, node[head], jrk);
39 node[head] = n;
40 matAdj[head][adj] = 1;
41 matAdj[adj][head] = 1;
42 Node temp = new Node(head, tetangga[adj], jrk);
43 tetangga[adj] = temp;
44 }
216 public void cetak() {
217 for (int i = 0; i < jNode; i++) {
218 System.out.print("[" + i + "]");
219 Node n = node[i];
220 while (n != null) {
System.out.print("->" + n.getDt()+"(Jarak :
221 "+n.getJarak()+") ");
222 n = n.getNext();
223 }
224 System.out.println();
225 }
226 }
227 public static void main(String s[]) {
228 Graph g = new Graph(5);
229 //(head, adj, jarak)
230 g.addAdj(0, 3, 10);
231 g.addAdj(0, 1, 5);
232 g.addAdj(1, 4, 15);
233 g.addAdj(1, 2, 20);
234 g.addAdj(2, 4, 5);
235 g.addAdj(2, 1, 20);
236 g.addAdj(4, 3, 5);
237 g.jumlahEdge();
238 g.matrixAdjacency();
239 g.tetangga();
240 g.bfs();
241 g.dfs(3);
242 g.cetak();
243 System.out.println("");
244 g.getDistance(0, 1);
245 }
246 }
235 g.addAdj(2, 1, 20);
236 g.addAdj(4, 3, 5);
237 g.jumlahEdge();
238 g.matrixAdjacency();
239 g.tetangga();
240 g.bfs();
241 g.dfs(3);
242 g.cetak();
243 System.out.println("");
244 g.getDistance(0, 1);
245 }
246 }

Method untuk menghitung jarak terpendek

205 public void getDistance(int source, int destination) {
206
System.out.println("------------------------------------------
 ");
System.out.println(" Jarak dari Node["+source+"]
207 ke Node["+destination+"]");

System.out.println("------------------------------------------
208 ");
if(node[source].getJarak() >
209 node[destination].getJarak()) {
System.out.println("Jarak terpendek =
210 "+node[destination].getJarak());
211 } else {
System.out.println("Jarak terpendek =
212 "+node[source].getJarak());
213 }

System.out.println("------------------------------------------
214 ");
215 }

C. PEMBAHASAN

Method untuk mengetahui jumlah edge

46 Pendefinisian method jumlahEdge
47 Mencetak garis
48 Mencetak header Jumlah Edge
49 Mencetak garis
50 Perulangan jumlah tertentu dengan batas jNode
51 Mencetak edge masuk dan edge keluar
53 Mencetak garis
55 Pendefinisian method inEdge dengan parameter dan tipe int
56 Menginisialisasi variabel count dengan nilai 0
57 Perulangan jumlah tertentu dengan batas jNode
58 Menginisialisasi variabel temp dengan nilai dari node
59 Perulangan dengan syarat temp != null
60 Seleksi kondisi jika idx == temp.getDt
61 Menginkremen variabel count
63 Menginisialisasi temp dengan pemanggilan method getNext
66 Mengembalikan nilai count
68 Pendefinisian method outEdge dengan parameter dan tipe int
69 Menginisialisasi variabel count dengan nilai 0
70 Menginisialisasi variabel temp dengan nilai dari node
71 Perulangan dengan syarat temp != null
72 Menginkremen variabel count
73 Menginisialisasi temp dengan pemanggilan method getNext
75 Mengembalikan nilai count

Method untuk menampilkan matriks adjacency

78 Pendefinisian method matrixAdjacency
79 Mencetak garis
80 Mencetak header Matrix Adjacency
81 Mencetak garis
82 Mencetak spasi
83 Perulangan jumlah tertentu dengan batas jNode
84 Mencetak indeks untuk kolom
86 Mencetak enter
87 Perulangan jumlah tertentu dengan batas jNode
88 Mencetak indeks untuk baris
89 Perulangan jumlah tertentu dengan batas jNode
90 Mencetak nilai tiap indeks
92 Mencetak garis
94 Mencetak garis

Method untuk mendapatkan tetangga

97 Pendefinisian method tetangga
98 Mencetak garis
99 Mencetak header Tetangga Node
100 Mencetak garis
101 Perulangan jumlah tertentu dengan batas jNode
102 Mencetak statemen dengan indeks
103 Menginisialisasi temp dengan nilai dari tetangga tiap indeks
104 Menginisialisasi n dengan nilai dari node tiap indeks
105 Perulangan dengan syarat temp != null
106 Mencetak nilai temp.getNext() dan "<="
107 Menginisialisasi temp dengan pemanggilan method getNext
109 Mencetak statemen dengan indeks
110 Perulangan dengan syarat n != null
111 Mencetak nilai temp.getNext() dan "=>"
112 Menginisialisasi n dengan pemanggilan method getNext
114 Mencetak enter
116 Mencetak garis

Method BFS dan DFS

119 Pendefinisian method bfs
120 Mencetak garis
121 Mencetak header Breadth First Search
122 Mencetak garis
123 Menginisialisasi find dengan nilai false
124 Menginisialisasi batas array dengan jNode
125 Menginisialisasi array indeks 0 dengan nilai 0
126 Mencetak array indeks 0
127 Menginisialisasi Checkpoint dengan nilai 1
128 Menginisialisasi i dengan nilai 0
129 Menginisialisasi p dengan nilai 0
130 Perulangan dengan syarat array indeks ke jNode-1 == 0
131 Perulangan jumlah tertentu dengan batas jNode
132 Seleksi kondisi jika matAdj[i][j] >= 1
133 Perulangan untuk setiap indeks array
134 Seleksi kondisi jika array indeks k == j
135 Menginisialisasi find dengan nilai true
138 Seleksi kondisi jika find != true
139 Menginisialisasi array indeks ke Checkpoint dengan nilai j
140 Menginkremen variabel Checkpoint
143 Menginisialisasi find dengan nilai false
145 Menginisialisasi i dengan nilai array indeks p
146 Menginkremen variabel p
148 Perulangan jumlah tertentu dengan batas jNode
149 Mencetak ">>" dengan indeks array
151 Mencetak garis
153 Pendefinisian method dfs dengan parameter
154 Menginisialisasi batas array dengan jNode
155 Mencetak garis
156 Mencetak header Depth First Search dengan indeks
157 Mencetak garis
158 Memanggil method dfsNode dengan argumen 0
159 Mencetak 0
160 Perulangan jumlah tertentu dengan batas jNode
161 Seleksi kondisi jika idx == 0
162 Break untuk menghentikan perulangan
163 Jika idx != array[i]
164 Mencetak ">>" dengan indeks array
165 Jika idx == array[i]
166 Mencetak ">>" dengan indeks array
167 Break untuk menghentikan perulangan
170 Mencetak garis
172 Pendefinisian method dfsNode dengan parameter
173 Menginisialisasi batas temp dengan jNode+1
174 Menginisialisasi count dengan nilai 0
175 Menginisialisasi find dengan nilai false
176 Perulangan jumlah tertentu dengan batas jNode
177 Seleksi kondisi jika matAdj[idx][j] >= 1
178 Perulangan untuk setiap indeks array
179 Seleksi kondisi jika array indeks w == j
180 Menginisialisasi find dengan nilai true
183 Seleksi kondisi jika find != true
184 Menginisialisasi temp indeks count dengan nilai j
185 Menginkremen variabel count
188 Menginisialisasi find dengan nilai false
190 Perulangan jumlah tertentu dengan batas jNode
191 Perulangan jumlah tertentu dengan batas jNode
192 Seleksi kondisi jika temp indeks k == array indeks w
193 Menginisialisasi find dengan nilai true
196 Seleksi kondisi jika find != true
197 Menginisialisasi array indeks checkpoint dengan nilai temp[k]
198 Menginkremen variabel Checkpoint
199 Memanggil method dfsNode dengan argumen temp[k]
201 Menginisialisasi find dengan nilai false

Modifikasi pada ADT Graph

1 Nama kelas, yaitu Graph
2 Pendefinisian inner class dengan nama Node
3 Pendefinisian atribut data dan jarak dengan tipe int
4 Pendefinisian atribut next dengan tipe Node
5 Konstruktor Node dengan parameter
6 Menginisialisasi data dengan dt
7 Menginisialisasi next dengan n
8 Menginisialisasi jarak dengan j
10 Pendefinisian method getDt dengan tipe int
11 Mengembalikan nilai data
13 Pendefinisian method getNext dengan tipe Node
14 Mengembalikan nilai next
16 Pendefinisian method getJarak dengan tipe int
17 Mengembalikan nilai jarak
20 Pendefinisian atribut array node dengan tipe Node
21 Pendefinisian atribut jNode dengan tipe int
22 Pendefinisian atribut array 2 dimensi matAdj dengan tipe int
23 Pendefinisian atribut array tetangga dengan tipe Node
24 Pendefinisian atribut array dengan tipe int
25 Pendefinisian atribut checkpoint dengan tipe int dan nilai 1
26 Pendefinisian atribut find dengan tipe boolean dan nilai false
27 Konstruktor Graph dengan parameter
28 Menginisialisasi jNode dengan nilai n
29 Menginisialisasi batas array node
30 Menginisialisasi batas array tetangga
31 Perulangan jumlah tertentu dengan batas jNode
32 Menginisialisasi tiap indeks array node dengan nilai null
33 Menginisialisasi tiap indeks array tetangga dengan nilai null
35 Menginisialisasi batas array matAdj
37 Pendefinisian method addAdj dengan parameter
38 Instansiasi object n dari kelas Node
 39 Menginisialisasi indeks array node dengan nilai dari n
40 Menginisialisasi array matAdj pada baris head kolom adj dengan nilai 1
41 Menginisialisasi array matAdj pada baris adj kolom head dengan nilai 1
42 Instansiasi object temp dari kelas Node
43 Menginisialisasi indeks array tetangga dengan nilai dari n
216 Pendefinisian method cetak
217 Looping for dengan syarat i < jNode
218 Mencetak nilai i
219 Menginisiasi Node n dengan nilai dari node[i]
220 Looping while dengan syarat n!= null
221 Menceak Jarak
222 Menginisialisasi n dengan pemanggilan method getNext
224 Mencetak enter
227 Main method
228 Instansiasi object g dari kelas Graph
230 Memanggil method addAdj dengan argumen (0, 3, 10)
231 Memanggil method addAdj dengan argumen (0, 1, 5)
232 Memanggil method addAdj dengan argumen (1, 4, 15)
233 Memanggil method addAdj dengan argumen (1, 2, 20)
234 Memanggil method addAdj dengan argumen (2, 4, 5)
235 Memanggil method addAdj dengan argumen (2, 1, 20)
236 Memanggil method addAdj dengan argumen (4, 3, 5)
237 Memanggil method jumlahEdge
238 Memanggil method matrixAdjacency
239 Memanggil method tetangga
240 Memanggil method bfs
241 Memanggil method dfs
242 Memanggil method cetak
243 Mencetak enter
244 Memanggil method getDistance dengan argumen
235 Memanggil method addAdj dengan argumen (2, 1, 20)
236 Memanggil method addAdj dengan argumen (4, 3, 5)
237 Memanggil method jumlahEdge
238 Memanggil method matrixAdjacency
239 Memanggil method tetangga
240 Memanggil method bfs
241 Memanggil method dfs
242 Memanggil method cetak
243 Mencetak enter
244 Memanggil method getDistance dengan argumen

Method untuk menghitung jarak terpendek

205 Pendefinisian method getDistance dengan parameter
206 Mencetak garis
 207 Mencetak header Jarak dari Node ke Node
208 Mencetak garis
Seleksi if dengan syarat node[source].getJarak() >
209 node[destination].getJarak()
210 Mencetak jarak terpendek
211 Seleksi else jika syarat if tidak terpenuhi
212 Mencetak jarak terpendek
214 Mencetak garis

D. SCREENSHOT PROGRAM
E. KESIMPULAN

1. ADT Graph merupakan konsep struktur data non linier, yang terdiri dari
kumpulan node (Vertex) dan saling berhubungan (Edge). Setiap node dapat
dihubungkan dengan node-node yang lain tanpa adanya hubungan
heirarkhis seperti tree, dengan kata lain Graph memiliki relasi many to
many, yaitu tiap elemen dapat memiliki 0 atau lebih dari 1 cabang.

2. Penerapan ADT Graph dalam dunia nyata misalnya: untuk pemetaan kota-
kota dalam aplikasi google maps, routing dalam teori jaringan komputer,
untuk penentuan rute terpendek dalam sebuah perjalanan wisata.