FILKOM-3A

LAPORAN PRAKTIKUM Modul 9

ADT BINARY TREE

NAMA : WAHYU BIMANTARA

NIM : 175150218113027
PERIODE : SEMESTER GANJIL 2018/2019

FAKULTAS ILMU KOMPUTER

TEKNIK INFORMATIKA
UNIVERSITAS BRAWIJAYA
9.5 Prosedur Praktikum
a. Buatlah program sesuai dengan source code Program Latihan Praktikum 9.1
b. Jalankan program

Program Latihan Praktikum 9.1

1 /** @author BIMA */
2 import java.util.Random;
3 class Node {
4 int data;
5 Node nodeKiri;
6 Node nodeKanan;
7 public Node(int dt){
8 data = dt;
9 nodeKiri = nodeKanan = null;
10 }
11 public void sisipDt(int dtSisip ){
12 if (dtSisip < data){
13 if(nodeKiri == null)
14 nodeKiri = new Node( dtSisip );
15 else nodeKiri.sisipDt( dtSisip );
16 }
17 else if(dtSisip > data){
18 if ( nodeKanan == null )
19 nodeKanan = new Node(dtSisip);
20 else nodeKanan.sisipDt(dtSisip);
21 }
22 }
23 }
24 public class Tree{
25 private Node root;
26 public Tree() {
27 root = null;
28 }
29 public void sisipDtNode(int dtSisip){
30 if (root == null)
31 root = new Node( dtSisip );
32 else
33 root.sisipDt(dtSisip);
34 }
35
36 public void preorderTraversal() {
37 preorder(root);
38 }
39 private void preorder(Node node){
40 if(node == null) return;
41 System.out.printf( "%d ", node.data );
42 preorder(node.nodeKiri);
43 preorder(node.nodeKanan);
44 }
45
46 public void inorderTraversal(){
47 inorder( root );
48 }
49 private void inorder(Node node){
50 if (node == null) return;
51 inorder(node.nodeKiri);
52 System.out.printf( "%d ", node.data );
53 inorder( node.nodeKanan );
54 }
55
56 public void postorderTraversal(){
57 postorder( root );
58 }
59 private void postorder(Node node){
60 if (node == null) return;
61 postorder(node.nodeKiri);
62 postorder(node.nodeKanan);
63 System.out.printf( "%d ", node.data );
64 }
65
66 public static void main(String args[]) {
67 Tree Tree = new Tree();
68 int nilai;
69 Random randomNumber = new Random();
70 System.out.println( "sisip nilai data berikut : " );
71 // sisipDt 10 bilangan acak dari 0-99 ke dalam tree
72 for ( int i = 1; i <= 10; i++ ) {
73 nilai = randomNumber.nextInt( 100 );
74 System.out.print(nilai + " " );
75 Tree.sisipDtNode(nilai);
76 }
77 System.out.println ( "\n\nPreorder traversal" );
78 Tree.preorderTraversal();
79 System.out.println ( "\n\nInorder traversal" );
80 Tree.inorderTraversal();
81 System.out.println ( "\n\nPostorder traversal" );
82 Tree.postorderTraversal();
83 System.out.println();
84 }
85 }
9.6 Hasil Percobaan

9.7 Analisis Hasil

1. Jelaskan apa berbedaan dari 3 macam penelusuran node yang ada di Program
Latihan Praktikum 9.1 yaitu preorder, inorder, dan postorder !
Jawab:
Preorder Transversal  Cetak isi Node yang dikunjungi.
 Kunjungi cabang kiri.
 Kunjungi cabang kanan.
Inorder Transversal  Kunjungi cabang kiri.
 Cetak isi Node yang dikunjungi.
 Kunjungi cabang kanan.

Postorder Tranversal  Kunjungi cabang kiri.

 Kunjungi cabang kanan.
 Cetak isi Node yang dikunjungi

2. Apa tipe data yang dapat disimpan di node Program Latihan Praktikum 9.1? Jika
ingin menyimpan data yang berupa String bagian kode program manakah yang
harus diganti?
Jawab:
Tipe datanya adalah integer dapat dilihat pada code berikut ini
class Node {
int data;
Jika Ingin menyimpan data berupa String Maka code yang harus diganti:

Variabel data pada class Node

1 class Node {
String data;

Parameter construktor dari class Node

2 public Node(String dt){
 Untuk setiap Comparasinya berganti dari
if (dtSisip < data){
menjadi menggunakan method compareToIgnoreCase sebab yang dibandingkan
adalah String
3 if (dtSisip.compareToIgnoreCase(data)<0){

Kemudian format %d pada method printf berganti menjadi %s

4SySystem.out.printf( "%s ", node.data );

Kemudian tinggal uji coba dengan String huruf atau kata pada method main

9.8 Kesimpulan
Binary Tree adalah Tree yang masing-masing nodenya menunjuk paling
banyak 2 node yang lain, dimana sebuah node hanya bisa mempunyai satu
parent dan punya child paling banyak 2. Root adalah node yang memiliki
hirarki tertinggi dan dibentuk pertama kali sehingga tidak memiliki
parent. Cara penelusuran node pada binary tree yaitu preorder, inorder
dan postorder.

9.9 Latihan
1. Tambahkan method untuk menghitung banyaknya node pada Binary Tree
Jawab:
Pada class Tree tambahkan variable jumlah, Lalu tambahkan variabelr jumlah++
di method sisipDtNode sebab jika terdapat penambahan node maka jumlah node
awal akan berubah. Kemudian tinggal kita buat method untuk menghitung jumlah
nodenya Lalu tinggal kita panggil dan cetak di class main

// Method hitung jumlah node

public int getJumlah() {
return jumlah;
}
2. Tambahkan method untuk menghitung banyaknya daun2
Jawab:

// Method hitung jumlah daun

public void JumlahDaun() {
JumlahDaun(root);
}
private void JumlahDaun(Node node) {
if (node.nodeKanan == null) {
if (node.nodeKiri == null) {
daun++;
} else {
JumlahDaun(node.nodeKiri);
}
} else if (node.nodeKiri == null) {
if (node.nodeKanan == null) {
daun++;
} else {
JumlahDaun(node.nodeKanan);
}
} else if (node.nodeKanan != null && node.nodeKiri != null) {
JumlahDaun(node.nodeKiri);
JumlahDaun(node.nodeKanan);
}
}
3. Tambahkan method untuk menghitung tinggi dari pohon
Jawab:
Method ini memanggil metod Hitunglevel
// Method Hitung Tinggi Pohon
public int HitungTinggi() {
return Hitunglevel() + 1;
}

4. Tambahkan method panjang yang menerima suatu pohon biner dan menentukan
berapa level yang dimiliki pohon tersebut.
Jawab:
//Method mendapatkan panjang dari tree
private int setPanjang(int p) {
this.panjang = p;
int a = this.HitungTinggi() - this.Hitunglevel();
return a;
}
private int getPanjang() {
return panjang;
}
// Method Hitung level pohon
public int Hitunglevel() {
 return Hitunglevel(root);
}
private int Hitunglevel(Node node) {
if (node != null) {
int a = Hitunglevel(node.nodeKiri);
int b = Hitunglevel(node.nodeKanan);
if (a > b) {
return a = a + 1;
} else {
return b = b + 1;
}
} else {
return -1;
}
}

Program Completenya

Program Latihan Praktikum 9.1 update latihan

1 /** @author BIMA */
2 import java.util.Random;
3 class Node {
4
5 int data;
6 Node nodeKiri;
7 Node nodeKanan;
8
9 public Node(int dt) {
10 data = dt;
11 nodeKiri = nodeKanan = null;
12 }
13
14 public void sisipDt(int dtSisip) {
15 if (dtSisip < data) {
16 if (nodeKiri == null) {
17 nodeKiri = new Node(dtSisip);
18 } else {
19 nodeKiri.sisipDt(dtSisip);
20 }
21 } else if (dtSisip > data) {
22 if (nodeKanan == null) {
23 nodeKanan = new Node(dtSisip);
24 } else {
25 nodeKanan.sisipDt(dtSisip);
26 }
27 }
28 }
29 }
30
31 public class Tree {
32 private Node root;
33 int jumlah, daun;
34 private int panjang;
35 public Tree() {
36 root = null;
37 }
38 public void sisipDtNode(int dtSisip) {
39 if (root == null) {
40 root = new Node(dtSisip);
41 } else {
42 root.sisipDt(dtSisip);
43 }
44 jumlah++;
45 }
46
47 public void preorderTraversal() {
48 preorder(root);
49 }
50
51 private void preorder(Node node) {
52 if (node == null) {
53 return;
54 }
55 System.out.printf("%d ", node.data);
56 preorder(node.nodeKiri);
57 preorder(node.nodeKanan);
58 }
59
60 public void inorderTraversal() {
61 inorder(root);
62 }
63 private void inorder(Node node) {
64 if (node == null) {
65 return;
66 }
67 inorder(node.nodeKiri);
68 System.out.printf("%d ", node.data);
69 inorder(node.nodeKanan);
70 }
71 public void postorderTraversal() {
72 postorder(root);
73 }
74 private void postorder(Node node) {
75 if (node == null) {
76 return;
77 }
78 postorder(node.nodeKiri);
79 postorder(node.nodeKanan);
80 System.out.printf("%d ", node.data);
81 }
82
83 // Method hitung jumlah node
84 public int getJumlah() {
85 return jumlah;
86 }
87
88 // Method hitung jumlah daun
89 public void JumlahDaun() {
90 JumlahDaun(root);
91 }
92 private void JumlahDaun(Node node) {
93 if (node.nodeKanan == null) {
94 if (node.nodeKiri == null) {
95 daun++;
96 } else {
97 JumlahDaun(node.nodeKiri);
98 }
99 } else if (node.nodeKiri == null) {
100 if (node.nodeKanan == null) {
101 daun++;
102 } else {
103 JumlahDaun(node.nodeKanan);
104 }
105 } else if (node.nodeKanan != null && node.nodeKiri != null) {
106 JumlahDaun(node.nodeKiri);
107 JumlahDaun(node.nodeKanan);
108 }
109 }
110
111 // Method Hitung Tinggi Pohon
112 public int HitungTinggi() {
113 return Hitunglevel() + 1;
114 }
115
116 //Method mendapatkan panjang dari tree
117 private int setPanjang(int p) {
118 this.panjang = p;
119 int a = this.HitungTinggi() - this.Hitunglevel();
120 return a;
121 }
122 private int getPanjang() {
123 return panjang;
124 }
125 // Method Hitung level pohon
126 public int Hitunglevel() {
127 return Hitunglevel(root);
128 }
129 private int Hitunglevel(Node node) {
130 if (node != null) {
131 int a = Hitunglevel(node.nodeKiri);
132 int b = Hitunglevel(node.nodeKanan);
133 if (a > b) {
134 return a = a + 1;
135 } else {
136 return b = b + 1;
137 }
138 } else {
139 return -1;
140 }
141 }
142
143 public static void main(String args[]) {
144 Tree Tree = new Tree();
145 int nilai;
146 Random randomNumber = new Random();
147 System.out.println("sisip nilai data berikut : ");
148 for (int i = 0; i < 10; i++) {
149 nilai = randomNumber.nextInt(100);
150 System.out.print(nilai + " ");
151 Tree.sisipDtNode(nilai);
152 }
153 System.out.println("");
154 System.out.println("\nPreorder traversal");
155 Tree.preorderTraversal();
156 System.out.println("\n\nInorder traversal");
157 Tree.inorderTraversal();
158 System.out.println("\n\nPostorder traversal");
 159 Tree.postorderTraversal();
160 System.out.println("\n\nJumlah node pada binary tree adalah : "+
161 Tree.getJumlah());
162
163 Tree.JumlahDaun();
164 System.out.print("\nBanyak daun : " + Tree.daun);
System.out.println("\n\nTinggi Tree : " +
165 Tree.HitungTinggi());
166 System.out.println("\nLevel Tree : " + Tree.Hitunglevel());
167
168 System.out.println("");
169
170 }
171 }

Output
9.10 Tugas
1. Buatlah program Complete Binary Tree dengan menggunakan array.
Jawab:
Program Latihan Praktikum 9.1 Tugas Array
1 /** @author BIMA*/
2 import java.util.Random;
3 public class TreeArray {
4 static int pAkhir = 0;
5 static int nData = 0;
6 static Integer a[];
7 int templevel = 1;
8 int n = 1;
9
10 public static void display(int x) {
11 System.out.print("[" + a[x] + "] ");
12 }
13
14 static boolean isEmpty() {
15 return (nData == 0);
16 }
17
18 private void sisipData(int dt, int x) {//method menambah data
19 n = x;
20 if (a[1] == null) {//jika
21 a[1] = new Integer(dt);
22 } else {
23 if (dt < a[n].intValue()) {
24 if (a[n * 2] == null) {
25 a[n * 2] = new Integer(dt);
26 nData++;
27 if (n * 2 > pAkhir) {
28 pAkhir = n * 2;
29 }
30 } else {
31 n = n * 2;
32 sisipData(dt, n);
33 }
34 } else if (dt > a[n].intValue()) {
35 if (a[n * 2 + 1] == null) {
36 a[n * 2 + 1] = new Integer(dt);
37 nData++;
38 if (n * 2 + 1 > pAkhir) {
39 pAkhir = n * 2 + 1;
40 }
41 } else {
42 n = n * 2 + 1;
43 sisipData(dt, n);
44 }
45 }
46 }
47 }
48
49 static void addNode(int i, int isi) {
50 a[i] = new Integer(isi);
51 nData++;
52 pAkhir = i;
53 }
54
55 public static void inorderTraversal(Integer array[], int akhir) {
56 a = array;
57 pAkhir = akhir;
58
59 if (!isEmpty()) {
60 inorder(1);
61 } else {
62 System.out.println("Kosong");
63 }
64 }
65
66 static void inorder(int x) {
67 if (x <= pAkhir && a[x] != null) {
68 inorder(2 * x);
69 display(x);
70 inorder(2 * x + 1);
71 }
72 }
73
74 public static void preorderTraversal(Integer array[], int akhir) {
75 a = array;
76 pAkhir = akhir;
77
78 if (!isEmpty()) {
79 preorder(1);
80 } else {
81 System.out.println("Binary Tree Kosong");
82 }
83 }
84
85 static void preorder(int x) {
86 if (x <= pAkhir && a[x] != null) {
87
88 display(x);
89 preorder(2 * x);
90 preorder(2 * x + 1);
91 }
92 }
93
94 public static void postorderTraversal(Integer array[], int akhir) {
95 a = array;
96 pAkhir = akhir;
97
98 if (!isEmpty()) {
99 postorder(1);
100 } else {
101 System.out.println("Binary Tree Kosong");
102 }
103 }
104
105 static void postorder(int x) {
106 if (x <= pAkhir && a[x] != null) {
107
108 postorder(2 * x);
109 postorder(2 * x + 1);
110 display(x);
111 }
112 }
113
114 public int jumlahNode() {
115 int jmlNode = 0;
116 for (int i = 1; i <= pAkhir; i++) {
117 if (a[i] != null) {
118 jmlNode++;
119 }
120 }
121 return jmlNode;
122 }
123
124 public int jumlahDaun() {
125 int jmlDaun = 0;
126 for (int i = 1; i <= pAkhir; i++) {
if (a[i] != null && a[i * 2] == null && a[i * 2 + 1] ==
127 null){
128 jmlDaun++;
129 }
130 }
131 return jmlDaun;
132 }
133
134 public int hitunglevel() {
135 int bantuLevel = pAkhir;
136 int level = -1;
137 while (a[bantuLevel] != null) {
138 bantuLevel /= 2;
139 level++;
140 }
141 return level;
142 }
143
144 public int tinggi() {
145 return hitunglevel() + 1;
146 }
147
148 public static void main(String args[]) {
149 TreeArray Pohon = new TreeArray();
150 int nilai;
151 a = new Integer[1000];
152 Random randomNumber = new Random();
153 System.out.println("Data : ");
154 for (int i = 0; i < 10; i++) {
155 nilai = randomNumber.nextInt(100);
156 System.out.print(nilai + " ");
157 Pohon.sisipData(nilai, 1);
158 }
159 System.out.println("\n\nPreorder traversal :");
160 Pohon.preorderTraversal(a, pAkhir);
161
162 System.out.println("\n\nInorder traversal :");
163 Pohon.inorderTraversal(a, pAkhir);
164
165 System.out.println("\n\nPostorder traversal :");
166 Pohon.postorderTraversal(a, pAkhir);
167 System.out.println();
168
169 System.out.print("\n\nJumlah node pada binary tree adalah : ");
170 System.out.println(Pohon.jumlahNode());
171
172 System.out.print("Banyak daun : ");
173 System.out.println(Pohon.jumlahDaun());
174
175 System.out.print("Tinggi Tree : ");
176 System.out.println(Pohon.tinggi());
177
178 System.out.print("level Tree : ");
179 System.out.println(Pohon.hitunglevel());
180
181 }
182 }
Output