198
P
P
R
R
A
A
K
K
T
T
I
I
K
K
U
U
M
M
2
2
7
7
-
-
2
2
8
8
B
B
I
I
N
N
A
A
R
R
Y
Y
S
S
E
E
A
A
R
R
C
C
H
H
T
T
R
R
E
E
E
E
A.
TUJUAN
Mahasiswa diharapkan mampu :
1.
Memahami dan mengimplementasaikan Konsep Binary Search Tree
2.
Memahami keunggulan dari algoritma Binary Search Tree
3.
Mampu mengimplementasikan algoritma Binary Search Tree
B.
DASAR TEORI
Binary search tree adalah salah satu bentuk dari pohon.Di mana masing-masing pohon
tersebut hanya memiliki dua buah upapohon, yakni upapohon kiri dan upapohon kanan.Ciri khas
yang melekat pada binary search tree ini yang bisa juga dibilang sebagai keunggulan dari binary
search tree adalah peletakan isi dari nodenya yang terurut berdasarkan besarnya dari isinya
tersebut.Isinya bisa saja berupa integer, karakter, atau apapun sesuai dengan spesifikasi binary
search tree yang ada. Operasi dasar dari binary search tree(BST) ini sendiri sangatlah sederhana,
yakni hanya fungsi perbandingan dan fungsi rekursif. Di mana anak pohon sebelah kiri node
adalah anak pohon yang lebih kecil dari node, sedangkan anak pohon sebelah kanan node
memiliki isi yang lebih besar daripada isi node. Biasanya penyimpanan data di dalam binary
search tree ini bisa juga berupa record di mana pengurutannya hanya tinggal melihat key dari
record tersebut, missal nomor absen, NIM, tanggal, dll.
Keunggulan Binary Search
a.
Search Method
Metode search adalah penentu paling dalam program atau bisa dibilang nyawa dari
programdatabase. Kenapa search sangat penting untuk efisien.?Bayangkan saja apabila ada
miliaran data yang ada di dalam database pada sebuah komputer server dan harus diolah dan
selalu harus diupdate setiap hari ataupun diakses pengguna untuk dicari isi data yang
diinginkanya. Lalu, yang kita gunakan adalah struktur data yang tidak efisien, di mana suatu
saat computer server akan mengalami minimal hang atau yang paling parah adalah server
down sehingga tidak bisa diakses dan akhirnya justru membuang waktu bahkan lebih
199
parahnya bisa menyebabkan data dalam harddisk server menghilang. Tentunya kita sangat
menghindari hal semacam itu terjadi bukan.
Metode Search sendiri ada banyak, seperti yang sudah sempat disinggung sedikit
pada pendahuluan. Bahwa search macamnya ada linear search, binary search, binary search
tree, dll. Di sini hanya akan dibahas 3 contoh tersebut. Linear search merupakan tipe search
yang paling mendasar dalam dunia search. Pada dasarn linear search ini sangat
sederhana.Yakni memulai pencarian dari elemen pertama kemudian bergeser terus ke elemen
berikutnya hingga menemukan isi elemen yang dicari. Apabila elemen yang dicari tidak ada,
maka linear search akan terus melakukan traversal hingga elemen terakhir. Mari kita
bayangkan apabila terdapat banyak sekali data yang harus ditraversal dan data yang dicar
itidak ada di dalam database(worst case possibility). Efektivitas dari linear search ini adalah
dengan O(n) worst case tergantung dari jumlah elemen yang ada di dalam database tersebut.
Metode search yang berikutnya yakni binary search, bedanya binary search dari linear search
adalah dengan pembagian jumlah elemen menjadi dua bagian. Sehingga pencarian bisa lebih
efektif dengan cara membagi pencarian ke dua arah. Worst case dari binary search ini adalah
O(log n) sehingga cara ini bisa dibilang cukup efisien.
Metode search yang terakhir adalah binary search tree (sebenarnya bukan merupakan
metode search). binary search tree memiliki kompleksitas algoritma O(log n) yang tidak ada
bedanya dengan metode binary search. Tetapi seharusnya metode search pada binary search
tree bisa lebih singkat, karena jalur yang dipilih sudah tergolong spesifik, sehingga tidak
perlu memeriksa semua elemen untuk mencari elemen tertentu.
b.
Struktur Data
Struktur data merupakan keunggulan dari binary search tree jika kita bandingkan
dengan array pada umunya.Mengapa hal tersebut bisa dibilang sebagai keunggulan? Karne
struktur data dari binary search tree adalah linked list dengan elemennya terurut. Dengan
demikian apabila struktur datanya sudah terurut maka pengaksesannya pun jauh lebih
mudah.Hal yang diakibatkan dari struktur data tersebut adalah kita tidak perlu melakukan
sorting terhadap data yang sudah ada. Berbeda dengan struktur data yang lain,
seperti struktur data array, linked list biasa membutuhkan sebuah fungsi sort untuk
mengurutkan datanya. Keunggulan lain yang disebabkan struktur data dari pohon ini adalah
200
kemudahan insertion process. Pada proses pemasukan data padabinary search tree, sangatlah
mudah, sama sekali tidak ada pergeseran data. Proses yang terjadi hanyalah pencarian lokasi
yang tepat untuk data yang dimasukkan tersebut, kemudian dikaitkan ke data di atasnya
sehingga dia menjadi anggota binary search tree yang baru
Gambar 1.Binary Tree
Kendati demikian, struktur data pada binary search tree menyebabkan proses
penghapusan data pada binary search treetergolong cukup rumit. Mengapa rumit? Karena
harus ada traversal data untuk mencari node tertentu untuk menggantikan posisi dari node
yang telah dihapus(informasi akan diperjelas di dalam Gambar). Selain itu, kelemahan
pemasukan data pada binary search tree jika dibandingkan dengan Tabel Eksplisit adalah
table eksplisit tidak memerlukan pengulangan untuk penambahan elemen baru,
sedangkan binary search tree membutuhkan proses sekuensial untuk menambahkan satu
elemen baru. Namun hal tersebut dapat ditutupi dengan sorted element dari binary search
tree.
201
C.
TUGAS PENDAHULUAN
Buatlah resume 1 halaman mengenai Binary Search Tree dan berikan penjelasannya.!
D.
PERCOBAAN
Node.java
1. class Node {
2.
3. int iData; // data yang digunakan sebagai nilai kunci.
4. Node leftChild; // Simpul rujukan ke anak sebelah kiri.
5. Node rightChild; // Simpul rujukan ke anak sebelah kanan.
6. }
BinaryTree.java
1. class BinaryTree { 2.
3. private Node root; // Membentuk akar (root) BinaryTree 4.
5. public Object find(int key) {
6. Node current = root; // Mulai dari akar (root) 7. while (current.iData != key) // Selama tidak sesuai 8. {
9. if (key < current.iData) // Pergi ke cabang kiri? 10. {
11. current = current.leftChild;
12. } else {
13. current = current.rightChild; // Atau pergi ke cabang kanan. 14. }
15. if (current == null) // Jika tidak memiliki anak. 16. {
17. return null;
18. }
19. }
20. return current; // Data yang dicari ditemukan.
21. }
22.
23. public void insert(int id) {
24. {
25. Node newNode = new Node(); // Membuat Node yang akan disisipkan.
26. newNode.iData = id; // Menyisipkan data.
27. if (root == null) // Jika tidak ada Node di akar (root).
28. {
29. root = newNode;
30. } else {
31. Node current = root; // Mulai dari akar (root).
32. Node parent;
33. while (true) // hadir secara internal.
34. {
35. parent = current;
36. if (id < current.iData) // Pergi ke kiri.
202
38. current = current.leftChild;
39. if (current == null) // Akhir cabang kiri.
40. { // Sisipkan di kiri.
41. parent.leftChild = newNode;
42. return;
43. }
44. } // Akhir perjalanan ke kiri.
45. else // Atau pergi ke kanan.
46. {
47. current = current.rightChild;
48. if (current == null) // Akhir perjalanan cabang kanan.
49. { // Sisipkan di kanan.
50. parent.rightChild = newNode;
51. return;
52. }
53. } // Akhir perjalanan ke kanan.
54. } // Akhir while
55. } // Akhir bukan akar (root).
56. } // Akhir insert()
57. }
58.
59. public boolean delete(int id) { // (Asumsi pohon tidak kosong)
60. Node current = root;
61. Node parent = root;
62. boolean isLeftChild = true;
63. while (current.iData != id) // Mencari Node yang akan dihapus.
64. {
65. parent = current;
66. if (id < current.iData) // Pergi ke kiri?
67. {
68. isLeftChild = true;
69. current = current.leftChild;
70. } else // Atau pergi ke kanan?
71. {
72. isLeftChild = false;
73. current = current.rightChild;
74. }
75. if (current == null) // Akhir baris
76. {
77. return false; // Node yang dicari tidak ditemukan.
78. }
79. } // end while
80. // Node yang akan dihapus ditemukan.
81. // Jika Node tidak memiliki anak, hapus!
82. if (current.leftChild == null
83. && current.rightChild == null) {
84. if (current == root) // Jika Node yang dihapus merupakan akar (Node).
85. {
86. root = null; // Pohon biner menjadi kosong.
87. } else if (isLeftChild) // Jika Node yang dihapus adalah
anak sebelah kiri.
88. {
89. parent.leftChild = null; // Pemutusan koneksi.
90. } else // Jika Node yang akan dihapus adalah anak sebelah
kanan.
203
92. parent.rightChild = null;
93. }
94. } // Jika tidak ada anak kanan, ganti dengan subpohon kiri.
95. else if (current.rightChild == null) {
96. if (current == root) {
97. root = current.leftChild;
98. } else if (isLeftChild) // Anak sebelah kiri induk.
99. {
100. parent.leftChild = current.leftChild;
101. } else // Anak sebelah kanan induk.
102. {
103. parent.rightChild = current.leftChild;
104. }
105. } // Jika tak ada anak kiri, gantikan dengan subpohon sebelah
kanan.
106. else if (current.leftChild == null) {
107. if (current == root) {
108. root = current.rightChild;
109. } else if (isLeftChild) // Anak sebelah kiri induk.
110. {
111. parent.leftChild = current.rightChild;
112. } else // Anak sebelah kanan induk.
113. {
114. parent.rightChild = current.rightChild;
115. }
116. } else // Dua anak, gantikan dengan successor inorder.
117. {
118. // Mendapatkan successor Node untuk dihapus (current)
119. Node successor = getSuccessor(current);
120. // Menghubungkan induk Node saat ini ke successor.
121. if (current == root) { 122. root = successor; 123. } else if (isLeftChild) { 124. parent.leftChild = successor; 125. } else { 126. parent.rightChild = successor; 127. }
128. // connect successor to current's left child
129. successor.leftChild = current.leftChild;
130. } // end else two children
131. // (successor tidak mempunyai anak sebwlah kiri)
132. return true;
133. } // end delete()
134. // Mengembalikan Node yang memiliki nilai terbesar berikuntnya
setelah delNode,
135. // pergi ke anak kanan, kemudian turunan kiri anak sebalah kanan.
136. private Node getSuccessor(Node delNode) {
137. Node successorParent = delNode;
138. Node successor = delNode;
139. Node current = delNode.rightChild; // Pergi ke anak sebelah
kanan.
140. while (current != null) // Hingga habis.
141. { // Anak kiri.
142. successorParent = successor;
143. successor = current;
204
145. }
146. // Jika successor bukan anak seblah kanan.
147. if (successor != delNode.rightChild) { // Buat hubungan.
148. successorParent.leftChild = successor.rightChild;
149. successor.rightChild = delNode.rightChild;
150. }
151. return successor;
152. }
153. //Mencari simpul (Node) yang memiliki nilai terkecil.
154. public Node minimum() {
155. Node current, last = null;
156. // Mulai dari akar (root).
157. current = root;
158. // Hingga dasar pohon biner.
159. while (current != null) {
160. // Mencatat Node
161. last = current;
162. // Pergi ke anak kiri.
163. current = current.leftChild;
164. }
165. return last;
166. }
167. } // end class BinaryTree
TestBinaryTree.java
1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStreamReader;
4.
5. public class TestBinaryTree {
6.
7. private static int cari;
8. private static int cacahData;
9.
10. public static void main(String[] args) {
11. BinaryTree bt = new BinaryTree(); // Membuat objek bt bertipe
BinaryTree.
12. System.out.print("Berapa data yang akan dimasukkan ke BinaryTree? ");
13. cacahData = inputData();
14. for (int i = 0; i < cacahData; i++) {
15. System.out.print("Data ke-" + (i + 1) + " = ");
16. bt.insert(inputData());
17. }
18. System.out.print("Data yang Anda cari ? ");
19. cari = inputData();
20. Node found = (Node) bt.find(cari); // find node with key 25
21. if (found != null) {
22. System.out.println("Node dengan key " + cari + " ditemukan.");
23. } else {
24. System.out.println("Node key " + cari + " tidak dapat ditemukan.");
25. }
26. }
27.
28. private static int inputData() {
205
InputStreamReader(System.in));30. String angkaInput = null;
31. try {
32. angkaInput = bfr.readLine();
33. } catch (IOException e) {
34. e.printStackTrace();
35. }
36. int Data = Integer.valueOf(angkaInput).intValue();
37. return Data;
38. }
39. }
E.
LATIHAN
Latihan 1 : buat class BinerySearchTree, kemudian analisa dan gambarkan pohonya
sesuai code berikut :
1. import java.util.*; 2. class Node{ 3. int data; 4. Node left; 5. Node right; 6. Node(int x){ 7. this.data = x; 8. } 9. }
10. public class BinarySearchTree{
11. private Node root;
12. /**
13. * Mengecek apakah tree masih kosong
14. **/
15. private boolean isEmpty(){ 16. return (root == null);
17. }
18. /**
19. * Memasukkan suatu nilai ke dalam tree.
20. * Jika nilai tersebut lebih kecil dari nilai node, maka bergerak ke kiri terus
21. * hingga menjadi child, begitu juga sebaliknya. 22. **/
23. public void insert(int input){ 24. Node temp = new Node(input); 25. if (isEmpty())
26. root = temp; 27. else {
28. Node cursor = root, 29. parent = null;
30. while (cursor != null){
31. parent = cursor; 32. if (input < cursor.data) 33. cursor = cursor.left; 34. else 35. cursor = cursor.right; 36. }
206
37. /**
38. * Menambahkan Node baru pada kiri/kanan Node parent bergantung
39. * pada nilai input dan nilai yang disimpan Node parent
40. **/ 41. if (input < parent.data){ 42. parent.left = temp; 43. return; 44. } 45. else { 46. parent.right = temp; 47. return; 48. } 49. } 50. }
51. /* Mencari suatu nilai dalam tree berdasarkan prinsip :
52. * Selama belum menemukan nilai yang sama,
53. * Jika nilai yang dicari lebih kecil dari nilai yang disimpan dalam
Node
54. * maka bergerak ke left Child begitu juga sebaliknya.
55. **/
56.
57. public boolean delete(int key){
58. Node cursor = root,
59. parent = null;
60. boolean found = false,
61. isLeftChild = true; //menandai apakah Node yang dihapus merupakan
left child
62. if (!isEmpty()){
63. while (cursor != null){
64. parent = cursor;
65. if (key == cursor.data){
66. found = true;
67. break;
68. }
69. else if (key < cursor.data){
70. isLeftChild = true; 71. cursor = cursor.left; 72. } 73. else { 74. isLeftChild = false; 75. cursor = cursor.right; 76. } 77. } 78. if (!found) 79. return false; 80. else { 81. /**
82. * Untuk menghapus leaf (tidak punya child)
83. **/
84. if (cursor.left == null && cursor.right == null){
85. if (cursor == root) 86. root = null; 87. else if (isLeftChild) 88. parent.left = null; 89. else 90. parent.right = null;
207
91. }
92.
93. /* Jika node yang akan dihapus hanya memiliki salah satu
subtree
94. * maka tinggal memindahkan subtree menggantikan node yang
dihapus
95. **/
96. else if (cursor.left == null){
97. if (cursor == root) 98. root = cursor.right; 99. else if (isLeftChild) 100. parent.left = cursor.right; 101. else 102. parent.right = cursor.right; 103. }
104. else if (cursor.right == null){
105. if (cursor == root) 106. root = cursor.left; 107. else if (isLeftChild) 108. parent.left = cursor.left; 109. else 110. parent.right = cursor.left; 111. } 112. /**
113. * Jika node yang akan dihapus memiliki 2 child, maka cari
successornya
114. * dengan fungsi getSuccessor kemudian hubungkan subtree bagian kanan
115. * dari node yang dihapus dengan successor
116. **/
117. else {
118. Node successor = getSuccessor(cursor);
119. if (cursor == root) 120. root = successor; 121. else if (isLeftChild) 122. parent.left = successor; 123. else 124. parent.right = successor;
125. //menyambung successor dengan cursor.right
126. successor.right = cursor.right; 127. } 128. } 129. } 130. return true; 131. } 132.
133. private Node getSuccessor(Node localNode){
134. Node parent = null,
135. successor = localNode,
136. cursor = localNode.left;
137. while (cursor != null){
138. parent = successor; 139. successor = cursor; 140. cursor = cursor.right; 141. } 142. if (successor != localNode.left){ 143. parent.right = successor.left;
208
144. successor.left = localNode.left; 145. } 146. return successor; 147. } 148. /**149. * Method traverse untuk mengelilingi Node-Node dalam tree
150. **/
151. public void traverse(int tipe){
152. switch (tipe){ 153. case 1: 154. System.out.print("\nPreorder traversal:\n"); 155. preOrder(root); 156. break; 157. case 2: 158. System.out.print("\nInorder traversal:\n"); 159. inOrder(root); 160. break; 161. case 3: 162. System.out.print("\nPostorder traversal:\n"); 163. postOrder(root); 164. break; 165. } 166. System.out.println('\n'); 167. }
168. private void preOrder(Node localRoot){
169. if (localRoot == null) return;
170. System.out.print(localRoot.data+" ");
171. preOrder(localRoot.left);
172. preOrder(localRoot.right);
173. }
174. private void inOrder(Node localRoot){
175. if (localRoot == null) return;
176. inOrder(localRoot.left);
177. System.out.print(localRoot.data+" ");
178. inOrder(localRoot.right);
179. }
180. private void postOrder(Node localRoot){
181. if (localRoot == null) return;
182. postOrder(localRoot.left);
183. postOrder(localRoot.right);
184. System.out.print(localRoot.data+" ");
185. }
186.
187. public static void main(String[] args)
188. {
189. BinarySearchTree a = new BinarySearchTree();
190. //penambahan node pada binary tree
191. a.insert(5); 192. a.insert(4); 193. a.insert(6); 194. a.insert(1); 195. a.insert(4); 196. a.insert(9);
197. //penelusuran node pada binary tree
198. a.traverse(1); //pre-order
209
200. a.traverse(3); //post-order
201. }
202. }
