You are on page 1of 11

LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER


UNIVERSITAS BRAWIJAYA

BAB : AVL TREE


NAMA : HASBI HASSADIQIN
NIM : 185150300111015
TANGGAL : 26/04/2020
ASISTEN : - FARRAS NABIL
- YUSUF RAHMAN

A. DEFINISI MASALAH

Kembangkan Program Latihan Praktikum 12.1 dengan menambahkan method


untuk menghapus suatu node pada pohon AVL dengan 3 kondisi yaitu jika node
yang dihapus adalah daun, jika node yang dihapus mempunyai satu anak dan jika
node yang dihapus mempunyai 2 anak.

B. SOURCE CODE

Tugas1
1 #include<iostream>
2 #include<stdlib.h>
3 using namespace std;
4 struct Node{
5 int key;
6 struct Node *left,*right;
7 int height;};
8 int max(int a, int b);
9 int height(struct Node *N){
10 if (N == NULL)
11 return 0;
12 return N->height;}
13 int max(int a, int b){
14 return (a > b)? a : b;}
15 struct Node* newNode(int key){
16 struct Node* node = (struct Node*)
17 malloc(sizeof(struct Node));
18 node->key = key;
19 node->left = NULL;
20 node->right = NULL;
21 node->height = 1;
22 return(node);}
23 struct Node *rightRotate(struct Node *y){
24 struct Node *x = y->left;
25 struct Node *T2 = x->right;
26 x->right = y;
27 y->left = T2;
28 y->height = max(height(y->left),
height(y->right))+1;
29 x->height = max(height(x->left),
height(x->right))+1;
30 return x;}
31 struct Node *leftRotate(struct Node *x){
32 struct Node *y = x->right;
33 struct Node *T2 = y->left;
34 y->left = x;
35 x->right = T2;
36 x->height = max(height(x->left),
height(x->right))+1;
37 y->height = max(height(y->left),
height(y->right))+1;
38 return y;}
39 int getBalance(struct Node *N){
40 if (N == NULL)
41 return 0;
42 return height(N->left) - height(N->right);}
43 struct Node* insert(struct Node* node, int key){
44 if (node == NULL)
45 return(newNode(key));
46 if (key < node->key)
47 node->left = insert(node->left, key);
48 else if (key > node->key)
49 node->right = insert(node->right, key);
50 return node;
51 node->height = 1 + max(height(node->left),
52 height(node->right));
53 int balance = getBalance(node);
54 if (balance > 1 && key < node->left->key)
55 return rightRotate(node);
56 if (balance < -1 && key > node->right->key)
57 return leftRotate(node);
58 if (balance > 1 && key > node->left->key) {
59 node->left = leftRotate(node->left);
60 return rightRotate(node);}
61 if (balance < -1 && key < node->right->key){
62 node->right = rightRotate(node->right);
63 return leftRotate(node);}
64 return node;}
65 struct Node * minValueNode(struct Node* node){
66 struct Node* current = node;
67 while (current->left != NULL)
68 current = current->left;
69 return current;}
70 struct Node* deleteNode(struct Node* root, int
key){
71 if (root == NULL)
72 return root;
73 if ( key < root->key )
74 root->left = deleteNode(root->left, key);
75 else if( key > root->key )
76 root->right = deleteNode(root->right, key);
77 else{
78 if( (root->left == NULL) || (root->right ==
NULL) ){
79 struct Node *temp = root->left ? root-
>left :
80 root->right;
81 if (temp == NULL){
82 temp = root;
83 root = NULL;}
84 else
85 *root = *temp;
86 free(temp);}
87 else{
struct Node* temp =
88 minValueNode(root->right);
root->key = temp->key;
89 root->right = deleteNode(root-
90 >right, temp->key);}}
if (root == NULL)
91 return root;
92 root->height = 1 + max(height(root-
93 >left),
height(root-
94 >right));
int balance = getBalance(root);
95 if (balance > 1 && getBalance(root-
96 >left) >= 0)
return rightRotate(root);
97 if (balance > 1 && getBalance(root-
98 >left) < 0){
root->left = leftRotate(root-
99 >left);
return rightRotate(root);}
100 if (balance < -1 && getBalance(root-
101 >right) <= 0)
return leftRotate(root);
102 if (balance < -1 && getBalance(root-
103 >right) > 0){
root->right = rightRotate(root-
104 >right);
return leftRotate(root);}
105 return root;}
106 void preOrder(struct Node *root){
107 if(root != NULL){
108 cout<<" "<<root->key;
109 preOrder(root->left);
110 preOrder(root->right);}}
111 int main(){
112 struct Node *root = NULL;
113 root = insert(root, 10);
114 root = insert(root, 20);
115 root = insert(root, 15);
116 root = insert(root, 13);
117 root = insert(root, 89);
118 root = insert(root, 76);
119 root = insert(root, 45);
120 root = insert(root, 32);
121 root = insert(root, 17);
122 cout<<("Hasil Preorder : ");
123 preOrder(root);
124 root = deleteNode(root, 10);
125 cout<<("\nHasil Preorder setelah menghapus 10 :
126 ");
preOrder(root);cout<<endl;
127 return 0;}
128
C. PEMBAHASAN

Tugas1
1 Pendeklarasian header library iostream
2 Pendeklarasian header library stdlib.h
3 Pemanggilan fungsi std untuk menyingkat penulisan syntax std pada setiap
cin dan cout.
4 Pendeklarasian sebuah struct
5 Mendeklarasikan suatu variabel dengan tipe data integer
6 Pendeklarasian pointer node bernama left dan right
7 Mendeklarasikan suatu variabel dengan tipe data integer
8 Mendeklarasikan suatu variabel dengan tipe data integer
9 Mendeklarasikan suatu variabel dengan tipe data integer
10 Sebuah fungsi if dalam if else
11 Pengembalian nilai kembali ke 0
12 Pengembalian nilai ke nilai tinggi dari tree
13 Mendeklarasikan suatu variabel dengan tipe data integer
14 Pengembalian nilai
15 Pendeklarasian sebuah struct
16 Pendeklarasian object node
17 Pengalokasian memori struct node
18 Pendeklarasian data node
19 Pendeklarasian penunjuk pointer prev node
20 Pendeklarasian penunjuk pointer next node
21 Pendeklarasian penunjuk nilai tinggi dari tinggi tree
22 Pengembalian nilai ke node
23 Pendeklarasian sebuah struct
24 Pendeklarasian object node bernama x
25 Pendeklarasian object node bernama T2
26 Pendeklarasian data node x
27 Pendeklarasian data node y
28 Pendeklarasian data height node y
29 Pendeklarasian data height node x
30 Pengembalian nilai ke 0
31 Pendeklarasian sebuah struct
32 Pendeklarasian object bernama y
33 Pendeklarasian object bernama T2
34 Pendeklarasian data node x
35 Pendeklarasian data node y
36 Pendeklarasian data height node y
37 Pendeklarasian data height node x
38 Pengembalian nilai ke y
39 Pendeklarasian suatu method
40 Sebuah fungsi if dalam if else
41 Pengembalian nilai ke 0
42 Pengembalian nilai ke hasil pengurangan tinggi tree kanan dan kiri
43 Pendeklarasian sebuah struct
44 Sebuah fungsi if dalam if else
45 Pengembalian nilai ke data key new node
46 Sebuah fungsi if dalam if else
47 Pendeklarasian nilai penunjuk prev node
48 Sebuah fungsi else if dalam if else
49 Pendeklarasian nilai penunjuk next node
50 Pengembalian nilai ke node
51 Pendeklarasian penunjuk node next
52 Pencarian nilai level penunjuk node next
53 Mendeklarasikan suatu variabel dengan tipe data integer
54 Fungsi if else dari seleksi kondisi if else
55 Pengembalian nilai ke rotasi kanan node
56 Fungsi if else dari seleksi kondisi if else
57 Pengembalian nilai ke rotasi kiri node
58 Fungsi if else dari seleksi kondisi if else
59 Pendeklarasian nilai penunjuk node prev
60 Pengembalian nilai ke rotasi kanan node
61 Fungsi if else dari seleksi kondisi if else
62 Pendeklarasian nilai penunjuk node next
63 Pengembalian nilai ke rotasi kiri node
64 Pengembalian nilai ke node
65 Pendeklarasian sebuah struct
66 Pendeklarasian object bernama current
67 Sebuah fungsi while dari perulangan do while
68 Pendeklarasian object current bernilai penunjuk prev node current
69 Pengembalian nilai ke object current
70 Pendeklarasian sebuah struct
71 Fungsi if dari seleksi kondisi if else
72 Pengembalian nilai ke root
73 Fungsi if dari seleksi kondisi if else
74 Pendeklarasian penunjuk prev node root
75 Fungsi else if dari seleksi kondisi if else
76 Pendeklarasian penunjuk next node root
77 Fungsi else dari seleksi kondisi if else
78 Fungsi if dari seleksi kondisi if else
79 Pembuatan object temp
80 Nilai penunjuk next node root
81 Fungsi if dari seleksi kondisi if else
82 Pendeklarasian object temp sama dengan object root
83 Pendeklarasian object root sama dengan NULL
84 Fungsi else dari seleksi kondisi if else
85 Pendeklarasian pointer root sama dengan nilai pointer temp
86 Penghapusan object temp
87 Fungsi else dari seleksi kondisi if else
88 Pendeklarasian object bernama temp
89 Pendeklarasian data node root sama dengan data node
90 Pendeklarasian penunjuk next node sama dengan penghapusan node
91 Fungsi if dari seleksi kondisi if else
92 Pengembalian nilai ke root
93 Pendeklarasian nilai level tree node
94 Nilai level tree dari penunjuk next node root
95 Mendeklarasikan suatu variabel dengan tipe data integer
96 Fungsi if dari seleksi kondisi if else
97 Pengembalian nilai ke rotasi kanan node root
98 Fungsi if dari seleksi kondisi if else
99 Pendeklarasian penunjuk prev node root
100 Pengembalian nilai ke rotasi kanan node root
101 Fungsi if dari seleksi kondisi if else
102 Pendeklarasian penunjuk prev node root
103 Fungsi if dari seleksi kondisi if else
104 Pendeklarasian penunjuk next node root
105 Pengembalian nilai ke rotasi kiri node root
106 Pengembalian nilai ke root
107 Pendeklarasian suatu void
108 Fungsi if dari seleksi kondisi if else
109 Sebuah fungsi untuk mengoutput
110 Pemanggilan method preorder
111 Pemanggilan method preorder
112 Sebagai fungsi untuk source code utama dengan tipe data integer dan untuk
membuka fungsi utama
113 Pembuatan object bernama root
114 Pendeklarasian nilai object root sama dengan pemanggilan method insert
115 Pendeklarasian nilai object root sama dengan pemanggilan method insert
116 Pendeklarasian nilai object root sama dengan pemanggilan method insert
117 Pendeklarasian nilai object root sama dengan pemanggilan method insert
118 Pendeklarasian nilai object root sama dengan pemanggilan method insert
119 Pendeklarasian nilai object root sama dengan pemanggilan method insert
120 Pendeklarasian nilai object root sama dengan pemanggilan method insert
121 Pendeklarasian nilai object root sama dengan pemanggilan method insert
122 Pendeklarasian nilai object root sama dengan pemanggilan method insert
123 Sebuah fungsi untuk mengoutput
124 Pemanggilan method preOrder
125 Pendeklarasian object root bernilai pemanggilan method deletenode
126 Sebuah fungsi untuk mengoutput
127 Pemanggilan method preorder dan pembuatan baris baru
128 Pengembalian nilai ke 0

D. SCREENSHOT PROGRAM

Tugas1

E. PRAKTIKUM

1. Percobaan Pertama: Implementasi AVL Tree


Beberapa method sama atau serupa dengan Binary Search Tree. Perbedaan utama
terdapat pada tambahan proses balancing dengan single dan double rotation. Perlu
tidak nya dilakukan balancing perlu diperiksa setiap kali melakukan insert dan
remove.
a. Buatlah program sesuai dengan source code Program Latihan Praktikum 12.1
b. Jalankan program
1 #include<iostream>
2 #include<cstdio>
3 #include<sstream>
4 #include<algorithm>
5 #define pow2(n) (1 << (n))
6 using namespace std;
7
8 struct avl_node{
9 int data;
10 struct avl_node *left;
11 struct avl_node *right;
12 }*root;
13
14 class avlTree{
15 public:
16 int height(avl_node *);
17 int diff(avl_node *);
18 avl_node *rr_rotation(avl_node *);
19 avl_node *ll_rotation(avl_node *);
20 avl_node *lr_rotation(avl_node *);
21 avl_node *rl_rotation(avl_node *);
22 avl_node* balance(avl_node *);
23 avl_node* insert(avl_node *, int );
24 void display(avl_node *, int);
25 avlTree(){
26 root = NULL;
27 }
28 };
29
30 // Height of AVL Tree
31 int avlTree::height(avl_node *temp){
32 int h = 0;
33 if (temp != NULL){
34 int l_height = height (temp->left);
35 int r_height = height (temp->right);
36 int max_height = max (l_height, r_height);
37 h = max_height + 1;
38 }
39 return h;
40 }
41
42 //Height Difference
43 int avlTree::diff(avl_node *temp){
44 int l_height = height (temp->left);
45 int r_height = height (temp->right);
46 int b_factor= l_height - r_height;
47 return b_factor;
48 }
49
50 //Right- Right Rotation
51 avl_node *avlTree::rr_rotation(avl_node *parent){
52 avl_node *temp;
53 temp = parent->right;
54 parent->right = temp->left;
55 temp->left = parent;
56 return temp;
57 }
58
59 //Left- Left Rotation
60 avl_node *avlTree::ll_rotation(avl_node *parent){
61 avl_node *temp;
62 temp = parent->left;
63 parent->left = temp->right;
64 temp->right = parent;
65 return temp;
66 }
67
68 //Left - Right Rotation
69 avl_node *avlTree::lr_rotation(avl_node *parent){
70 avl_node *temp;
71 temp = parent->left;
72 parent->left = rr_rotation (temp);
73 return ll_rotation (parent);
74 }
75
76 // Right- Left Rotation
77 avl_node *avlTree::rl_rotation(avl_node *parent){
78 avl_node *temp;
79 temp = parent->right;
80 parent->right = ll_rotation (temp);
81 return rr_rotation (parent);
82 }
83
84 // Balancing AVL Tree
85 avl_node *avlTree::balance(avl_node *temp){
86 int bal_factor = diff (temp);
87 if (bal_factor > 1){
88 if (diff (temp->left) > 0)
89 temp = ll_rotation (temp);
90 else
91 temp = lr_rotation (temp);
92 }
93 else if (bal_factor < -1){
94 if (diff (temp->right) > 0)
95 temp = rl_rotation (temp);
96 else
97 temp = rr_rotation (temp);
98 }
99 return temp;
100 }
101
102 // Insert Node Kedalam Tree
103 avl_node *avlTree::insert(avl_node *root, int value){
104 if (root == NULL){
105 root = new avl_node;
106 root->data = value;
107 root->left = NULL;
108 root->right = NULL;
109 return root;
110 }
111 else if (value < root->data){
112 root->left = insert(root->left, value);
113 root = balance (root);
114 }
115 else if (value >= root->data){
116 root->right = insert(root->right, value);
117 root = balance (root);
118 }
119 return root;
120 }
121
122 /* Menampilkan AVL Tree
123 void avlTree::display(avl_node *ptr, int level){
124 int i;
125 if (ptr!=NULL){
126 .........
127 }
128 }*/
129
130 int main(){
131 avlTree avl;
132 int nilai;
133 cout << "Masukkan nilai data berikut:" << endl;
134 // sisip data 10 bilangan acak dari 0-99 ke dalam
135 tree
136 srand(time(NULL));
137 for (int i = 0; i < 5; i++) {
138 nilai = rand() % 100;
139 cout << nilai << " ";
140 root = avl.insert(root, nilai);
141 }
142
143 // avl.display(root, 1);
144 return 0;
}

11.1 Hasil Percobaan


1. Tulislah urutan data random yang dimasukkan dari Program Latihan
Praktikum 12.1!

Gambarkan secara manual AVL Tree untuk setiap data yang dimasukkan
sesuai urutan data pada hasil percobaan 1.

Gambar AVL untuk data pertama dimasukkan Gambar AVL untuk data kedua dimasukkan
Gambar AVL untuk data ketiga dimasukkan Gambar AVL untuk data keempat dimasukkan

Gambar AVL untuk data kelima dimasukkan

2. Gambarkan juga hasil akhir BST berdasarkan urutan data pada hasil percobaan
1 yang nanti akan digunakan sebagai pembanding pada analisis hasil.
11.2 Analisis Hasil
1. Berdasarkan hasil gambar BST dan AVL Tree pada percobaan diatas, Apa
yang membedakan antara BST dengan AVL Tree?

Jawaban : BST adalah tree yang pemasukannya hanya dilakukan


pembandingan besar kecilnya nilai. Jika masukan lebih kecil maka nilai
tersebut akan masuk ke sebelah kiri subtree. Jika masukan lebih besar, maka
nilai tersebut akan masuk ke sebelah kanan subtree. AVL tree mempunyai
ketentuan yang berbeda dengan BST. AVL tree mempunyai ketentuan, yaitu
harus sebanding atau rata. Dimana pada saat subtree kanan dan subtree kiri
tidak sebanding. AVL tree akan melakukan rotation.

2. Kenapa perlu dilakukan proses single rotation dan double rotation untuk
membentuk AVL Tree? Apa yang membedakan kedua proses tersebut?

Jawaban : Single rotation adalah perubahan tree yang hanya dilakukan 1


rotasi jika ketidak rataan hanya sedikit. Double rotation adalah perubahan
tree yang dilakukan sebanyak 2 rotasi. Double rotation dipakai jika
pemberlakuan single rotation tidak membuat tree rata.

F. KESIMPULAN

AVL tree adalah suatu pembuatan tree yang dimana membutuhkan suatu
fungsi perataan tree. AVL tree mempunyai ketentuan jika tree yang dibuat tidak
rata akan menjalankan suatu fungsi bernama rotation. Terdapat 2 cara rotation,
yaitu single rotation dan double rotation. Single rotation adalah perubahan tree
yang hanya dilakukan 1 rotasi jika ketidak rataan hanya sedikit. Double rotation
adalah perubahan tree yang dilakukan sebanyak 2 rotasi. Double rotation dipakai
jika pemberlakuan single rotation tidak membuat tree rata.

You might also like