PRAKTIKUM 27-28 BINARY SEARCH TREE 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 198
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 199
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. Gambar 2.Menghapus Node di Binary Tree 200
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. 37. { 201
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. 91. { 202
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; 144. current = current.leftchild; // Pergi ke anak sebelah kiri. 203
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() { 29. BufferedReader bfr = new BufferedReader(new 204
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. } 205
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; 206
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; 207
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 199. a.traverse(2); //in-order 208
200. a.traverse(3); //post-order 201. } 202. } Latihan 2 :Dengan menggunakan class BinarySearchTree lakukan pemanggilan method insert() dengan mengirimkan input berturut-turut sesuai dengan deret berikut : {10, 5,20,2,6,19,25,21}, root adalah 10. Gambarkan hasil akhir binary search tree tersebut! F. LAPORAN RESMI Kerjakan hasil percobaan(d) dan latihan(e) di atas dan tambahkan analisa. 209