1

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

AVLT.java
import java.util.Scanner;
class Node {
int data;
int tinggi; //tinggi node
Node pKiri;
Node pKanan;
Node pInduk;// pointer ke induk
//constructor node
public Node(int dt, int tg, Node pKi, Node pKa, Node pI) {
this.data = dt;
this.tinggi = tg;
this.pKiri = pKi;
this.pKanan = pKa;
this.pInduk = pI;
}
}
public class AVLT {
private Node root;
public AVLT() {
root = null;
}
//cari dt di tree, mengembalikan true jika ditemukan
//dan false jika tidak
public boolean cariDt(int dt) {
Node temp = root;
while (temp != null) {
if (dt == temp.data) {
return true;
} //cariDt subtree pKiri
else if (dt < temp.data) {
temp = temp.pKiri;
} //cariDt subtree pKanan
else {
temp = temp.pKanan;
}
}
//dt tidak ditemukan
return false;
}
//sisip dt ke dalam tree, returns true if berhasil,
// false jika gagal

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//tree diseimbangkan menggunakan algoritma AVL

public boolean sisipDt(int dt) {
if (root == null) {
//sisip dt di root
root = new Node(dt, 1, null, null, null);
return true;
} //tree tidak kosong
else {
//mulai dari root
Node temp = root;
Node prev = null;
//cari lokasi penyisipan dt
while (temp != null) {
if (dt == temp.data) {
return false;
} //sisip dt di subtree pKiri
else if (dt < temp.data) {
prev = temp;
temp = temp.pKiri;
} //sisip dt di subtree pKanan
else {
prev = temp;
temp = temp.pKanan;
}
}
//buat node baru
temp = new Node(dt, 1, null, null, prev);
if (dt < prev.data) {
prev.pKiri = temp;//sisip di pKiri
} else {
prev.pKanan = temp; //sisipDt at pKanan
}//mulai dari node yang disisipkan dan
//bergerak menuju root
while (temp != null) {
//subtree pKiri dan pKanan memenuhi kondisi AVL
if (Math.abs(tinggi(temp.pKiri)
- tinggi(temp.pKanan)) <= 1) {
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
} //kasus 1 algoritma AVL
else if (tinggi(temp.pKiri)
- tinggi(temp.pKanan) >= 2
&& tinggi(temp.pKiri.pKiri)
>= tinggi(temp.pKiri.pKanan)) {
Node parent = temp.pInduk;
Node pKiri = temp.pKiri;
temp.pKiri = pKiri.pKanan;
if (temp.pKiri != null) {

98
99
10
0
10
1
10
2
10
3
10
4
10
5
10
6
10
7
10
8
10
9
11
0
11
1
11
2
11
3
11
4
11
5
11
6
11
7
11
8
11
9
12
0
12
1
12
2
12

temp.pKiri.pInduk = temp;
}
pKiri.pKanan = temp;
temp.pInduk = pKiri;
pKiri.pInduk = parent;
if (parent == null) {
root = pKiri;
} else if (parent.pKiri == temp) {
parent.pKiri = pKiri;
} else {
parent.pKanan = pKiri;
}
//hitung tinggi subtree pKanan
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
temp = pKiri;
//hitung tinggi dari root
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
} //case 2 algoritma AVl
else if (tinggi(temp.pKanan)
- tinggi(temp.pKiri) >= 2
&& tinggi(temp.pKanan.pKanan)
>= tinggi(temp.pKanan.pKiri)) {
Node parent = temp.pInduk;
Node pKanan = temp.pKanan;
temp.pKanan = pKanan.pKiri;
if (temp.pKanan != null) {
temp.pKanan.pInduk = temp;
}
pKanan.pKiri = temp;
temp.pInduk = pKanan;
pKanan.pInduk = parent;
if (parent == null) {
root = pKanan;
} else if (parent.pKanan == temp) {
parent.pKanan = pKanan;
} else {
parent.pKiri = pKanan;
}
//hitung tinggi subtree pKanan
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
temp = pKanan;
//hitung tinggi dari root
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
} //kasus 3 dari algoritma AVL
else if (tinggi(temp.pKiri)

3
12
4
12
5
12
6
12
7
12
8
12
9
13
0
13
1
13
2
13
3
13
4
13
5
13
6
13
7
13
8
13
9
14
0
14
1
14
2
14
3
14
4
14
5
14
6
14
7

- tinggi(temp.pKanan) >= 2
&& tinggi(temp.pKiri.pKanan)
>= tinggi(temp.pKiri.pKiri)) {
Node parent = temp.pInduk;
Node pKiripKanan = temp.pKiri.pKanan;
temp.pKiri.pKanan = pKiripKanan.pKiri;
if (temp.pKiri.pKanan != null) {
temp.pKiri.pKanan.pInduk = temp.pKiri;
}
pKiripKanan.pKiri = temp.pKiri;
temp.pKiri.pInduk = pKiripKanan;
temp.pKiri = pKiripKanan.pKanan;
if (temp.pKiri != null) {
temp.pKiri.pInduk = temp;
}
pKiripKanan.pKanan = temp;
temp.pInduk = pKiripKanan;
pKiripKanan.pInduk = parent;
if (parent == null) {
root = pKiripKanan;
} else if (parent.pKiri == temp) {
parent.pKiri = pKiripKanan;
} else {
parent.pKanan = pKiripKanan;
}
//hitung tinggi subtree pKanan
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
temp = pKiripKanan;
//hitung tinggi dari root
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
} //kasus 4 dari algoritma AVL
else if (tinggi(temp.pKanan)
- tinggi(temp.pKiri) >= 2
&& tinggi(temp.pKanan.pKiri)
>= tinggi(temp.pKanan.pKanan)) {
Node parent = temp.pInduk;
Node pKananpKiri = temp.pKanan.pKiri;
temp.pKanan.pKiri = pKananpKiri.pKanan;
if (temp.pKanan.pKiri != null) {
temp.pKanan.pKiri.pInduk = temp.pKanan;
}
pKananpKiri.pKanan = temp.pKanan;
temp.pKanan.pInduk = pKananpKiri;
temp.pKanan = pKananpKiri.pKiri;
if (temp.pKanan != null) {
temp.pKanan.pInduk = temp;
}

14
8
14
9
15
0
15
1
15
2
15
3
15
4
15
5
15
6
15
7
15
8
15
9
16
0
16
1
16
2
16
3
16
4
16
5
16
6
16
7
16
8
16
9
17
0
17
1
17

pKananpKiri.pKiri = temp;
temp.pInduk = pKananpKiri;
pKananpKiri.pInduk = parent;
if (parent == null) {
root = pKananpKiri;
} else if (parent.pKanan == temp) {
parent.pKanan = pKananpKiri;
} else {
parent.pKiri = pKananpKiri;
}
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
temp = pKananpKiri;
temp.tinggi = Math.max(tinggi(temp.pKiri),
tinggi(temp.pKanan)) + 1;
}
temp = temp.pInduk;
}
//penyisipan berhasil
return true;
}
}
private void seimbangkan(Node x, Node y, Node z, Node
parentz){
System.out.println(x);
if (x.data < y.data && y.data < z.data) {
Node temp = y;
z.pKiri = y.pKanan;
y.pKanan = z;
if (parentz != null) {
if (z.data < parentz.data) {
parentz.pKiri = temp;
}else{
parentz.pKanan = temp;
}
}else{
root = temp;
}
}else if (x.data > y.data && y.data > z.data) {
Node temp = y;
z.pKanan = y.pKiri;
y.pKiri = z;
if (parentz != null) {
if (z.data < parentz.data) {
parentz.pKiri = temp;
}else{
parentz.pKanan = temp;
}

2
17
3
17
4
17
5
17
6
17
7
17
8
17
9
18
0
18
1
18
2
18
3
18
4
18
5
18
6
18
7
18
8
18
9
19
0
19
1
19
2
19
3
19
4
19
5
19
6

}else{
root = temp;
}
}else if (x.data > y.data && y.data < z.data) {
Node temp = y;
z.pKiri = x;
y.pKanan = x.pKiri;
x.pKiri = temp;
seimbangkan(y, x, z, parentz);
}else if (x.data < y.data && y.data > z.data) {
Node temp = y;
z.pKanan = x;
y.pKiri = x.pKanan;
x.pKanan = temp;
seimbangkan(y, x, z, parentz);
}
}//seimbangkan selesai
int getHeight(Node node){
int height = 1;
if (node == null) {
return 0;
}
if (node.pKiri != null) {
height = 1 + getHeight(node.pKiri);
}
if (node.pKanan != null) {
height = Math.max(height, 1 +
getHeight(node.pKanan));
}
return height;
}
//akhir tinggi
Node findParent(int data){
Node pWalker = root;
Node pParent = null;
boolean ketemu = false;
while(!ketemu && pWalker != null){
if (pWalker.data == data) {
ketemu = true;
}else if (data < pWalker.data) {
pParent = pWalker;
pWalker = pWalker.pKiri;
}else{
pParent = pWalker;
pWalker = pWalker.pKanan;
}

19
7
19
8
19
9
20
0
20
1
20
2
20
3
20
4
20
5
20
6
20
7
20
8
20
9
21
0
21
1
21
2
21
3
21
4
21
5
21
6
21
7
21
8
21
9
22
0
22

}
if (ketemu) {
return pParent;
}else{
return null;
}
}
Node findMin(Node node){
Node pWalker = node;
if (pWalker == null) {
return null;
}
while(pWalker.pKiri != null){
pWalker = pWalker.pKanan;
}
return pWalker;
}
Node findMax(Node node){
Node pWalker = node;
if (pWalker == null) {
return null;
}
while(pWalker.pKanan != null){
pWalker = pWalker.pKanan;
}
return pWalker;
}
//findMax Selesai
private boolean isNotSeimbang(Node node){
if (node == null) {
return false;
}
return Math.abs(getHeight(node.pKiri) getHeight(node.pKanan)) > 1 ? true : isNotSeimbang(node.pKiri)
|| isNotSeimbang(node.pKanan);
}
void reBalance(Node node){
Node unBalance = node;
boolean seimbang = true;
while(unBalance != null && seimbang){
seimbang = !isNotSeimbang(unBalance);
if (seimbang) {
unBalance = findParent(unBalance.data);
}
}
if (seimbang || unBalance == null) {

1
22
2
22
3
22
4
22
5
22
6
22
7
22
8
22
9
23
0
23
1
23
2
23
3
23
4
23
5
23
6
23
7
23
8
23
9
24
0
24
1
24
2
24
3
24
4
24
5

return;
}
Node y = getHeight(unBalance.pKiri) >
getHeight(unBalance.pKanan) ? unBalance.pKiri :
unBalance.pKanan;
Node x = getHeight(y.pKiri) > getHeight(y.pKanan) ?
y.pKiri : getHeight(y.pKiri) < getHeight(y.pKanan) ? y.pKanan
: y == unBalance.pKanan ? y.pKanan : y.pKiri;
seimbangkan(x,y,unBalance,findParent(unBalance.data));
}
//reBalance Selesai
public void delete(int data){
Node pWalker = root;
Node pParent = null;
boolean ketemu = false;
while(!ketemu && pWalker != null){
if (pWalker.data == data) {
ketemu = true;
}else if (data < pWalker.data) {
pParent = pWalker;
pWalker = pWalker.pKiri;
}else{
pParent = pWalker;
pWalker = pWalker.pKanan;
}
}
if (!ketemu || pWalker == null) {
pParent = findParent(findMin(pWalker.pKanan).data);
int tempData = findMin(pWalker.pKanan).data;
if (pParent != null) {
if (findMin(pWalker.pKanan).data <
pParent.data) {
pParent.pKiri =
findMin(pWalker.pKanan).pKanan;
}else{
pParent.pKanan = findMin
(pWalker.pKanan).pKanan;
}
pWalker.data = tempData;
reBalance(pParent);
}
}else if (pWalker.pKiri != null) {
pParent = findParent(findMax(pWalker.pKiri).data);
int tempData = findMax(pWalker.pKiri).data;
if (pParent != null) {
if (findMax(pWalker.pKiri).data < pParent.data)
{
pParent.pKiri =

24
6
24
7
24
8
24
9
25
0
25
1
25
2
25
3
25
4
25
5
25
6
25
7
25
8
25
9
26
0
26
1
26
2
26
3
26
4
26
5
26
6
26
7
26
8
26
9
27

findMax(pWalker.pKiri).pKiri;
}else{
pParent.pKanan =
findMax(pWalker.pKiri).pKiri;
}
pWalker.data = tempData;
reBalance(pParent);
}
}else if (pWalker.pKiri == null || pWalker.pKanan ==
null) {
if (pParent != null) {
if (pWalker.data < pParent.data) {
pParent.pKiri = null;
}else{
pParent.pKanan = null;
}
reBalance(pParent);
}else{
root = null;
}
}
}
//delete selesai
public int tinggi() {
return root.tinggi;
}
private int tinggi(Node node) {
if (node == null) {
return 0;
} else {
return node.tinggi;
}
}
//hitung node-node dari tree
public int jumlahNode() {
return jumlahNode(root);
}
public void inOrderTraversal() {
inOrder(root);
}
private void inOrder(Node r) {
if (r == null) {
return;
}

0
27
1
27
2
27
3
27
4
27
5
27
6
27
7
27
8
27
9
28
0
28
1
28
2
28
3
28
4
28
5
28
6
28
7
28
8
28
9
29
0
29
1
29
2
29
3
29
4

inOrder(r.pKiri);
System.out.printf("-%d", r.data);
inOrder(r.pKanan);
}
//hitung node-node dari tree
private int jumlahNode(Node node) {
if (node == null) {
return 0;
} else {
return 1 + jumlahNode(node.pKiri)
+ jumlahNode(node.pKanan);
}
}
public boolean isEmpty(){
return (root == null);
}
public static void main(String[] args) {
AVLT t = new AVLT();
t.sisipDt(3);
t.inOrderTraversal();
System.out.println();
t.sisipDt(4);
t.inOrderTraversal();
System.out.println();
t.sisipDt(6);
t.inOrderTraversal();
System.out.println();
t.sisipDt(5);
t.inOrderTraversal();
System.out.println();
t.sisipDt(15);
t.inOrderTraversal();
System.out.println();
t.sisipDt(10);
t.inOrderTraversal();
System.out.println();
t.sisipDt(20);
t.inOrderTraversal();
System.out.println();
t.sisipDt(17);
t.inOrderTraversal();
System.out.println();
t.sisipDt(25);
t.inOrderTraversal();
System.out.println();
Scanner in = new Scanner (System.in);

29
5
29
6
29
7
29
8
29
9
30
0
30
1
30
2
30
3
30
4
30
5
30
6
30
7
30
8
30
9
31
0
31
1
31
2
31
3
31
4
31
5
31
6
31
7
31
8
31

int del;
do{
System.out.println("Pilih nilai yang ingin
dihapus : ");
del = in.nextInt();
if (t.isEmpty()) {
System.out.println("Tree masih kosong");
}else{
t.delete(del);
}
t.inOrderTraversal();
System.out.println(" ");
}while(del != 10);
}
}

9
32
0
32
1
32
2
32
3
32
4
32
5
32
6
32
7
32
8
32
9
33
0
33
1
33
2
33
3
33
4
33
5
33
6
33
7
33
8
33
9
34
0
34
1
34
2
34
3

34
4
34
5
34
6
34
7
34
8
34
9
35
0
35
1
35
2
35
3
35
4
35
5
35
6
35
7
35
8
35
9
36
0
36
1
36
2
36
3
36
4
36
5
36
6
36
7
36

8
36
9
37
0
37
1
37
2
37
3
37
4
37
5
37
6
37
7
37
8
37
9
38
0
38
1
38
2
38
3
38
4
38
5
38
6
38
7
38
8
38
9
39
0
39
1
39
2

39
3
39
4
39
5
39
6
39
7
39
8
39
9
40
0
40
1
40
2
40
3
40
4
40
5
40
6
40
7
40
8
40
9
41
0
41
1
41
2
41
3
41
4
41
5
41
6
41

7
41
8
41
9
42
0
42
1
42
2
42
3
42
4
42
5
42
6
42
7
42
8
42
9
43
0
43
1
43
2
43
3
43
4
43
5
43
6
43
7
43
8
43
9
44
0
44
1

44
2
44
3
44
4
44
5
44
6
44
7
44
8
44
9
45
0
45
1
45
2
45
3
45
4
45
5
45
6
45
7
45
8
45
9
46
0
46
1
46
2
46
3
46
4
46
5
46

6
46
7
46
8
46
9
47
0
47
1
47
2
47
3
47
4
47
5
47
6
47
7
47
8
47
9
48
0
48
1
48
2
48
3
48
3
48
4
48
5
48
6
48
7
48
8
49
0

50
0
50
1
50
2
50
3
50
4
50
5
50
6
50
7
50
8
50
9
51
0
51
1
51
2
51
3

Pembahasan 383-513
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397

MainKalkulator.java
Memanggil method reBalance berparameter pParent
Kurung tutup
Melakukan kondisi else if jika pWalker.pKiri tidak sama dengan null
Inisialisasi pParent = findParent(findMax(pWalker.pKiri).data)
Inisialisasi variable tempData bertipe integer
Melakukan seleksi kondisi if jika pParent tidak sama dengan null
Melakukan seleksi kondisi nested if jika (findMax.pKiri).data < pParent.data)
Kurung buka
Inisialisasi pParent,pKiri = findMax(pWalker.pKiri).pKiri
Lanjutan sebelumnya
Kondisi else
Inisialisasi pParent.pKana = findMax(pWalker.pKiri).pKiri
Lanjutan sebelumnya
Kurung tutup
Inisialisasi pWalker.data = tempData

398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441

Memanggil method rebalance berparameter pParent

Kurung tutup
Melakukan kondisi else if jika pWalker.pKiri = = null || pWalker.pKanan = = null
Lanjutan sebelumnya
Melakukan seleksi kondisi if jika pParent tidak sama null
Melakukan seleksi kondisi nested if jika pWalker.data < pParent.data
Inisialisasi pParent.pKiri sama dengan null
Kondisi else
Inisialisasi pParent.pKanan = null
Kurung tutup
Memanggil method rebalance berparamter pParent
Kondisi else
Inisialisasi root sama dengan null
Kurung tutup
Kurung tutup
Kurung tutup
Komentar
Deklarasi method tinggi
Mengembalikan nilai root.tinggi
Kurung tutup
Deklarasi method privte tinggi berparameter Node node
Melakukan seleksi kondisi if jika node sama dengan null
Mengembalikan nilai 0
Kondisi else
Mengembalikan nilai node.tinggi
Kurung tutup
Kurung tutup
Komentar
Deklarasi method jumlahNode
Mengembalikan nilai jumlahNode(root)
Kurung tutup
Deklarasi method void inOrderTraversal
Memanggil method inOrder berparameter root
Kurung tutup
Deklarasi method private inOrder berparameter Node r
Melakukan seleksi kondisi if jika r sama dengan null
Mengembalikan nilai
Kurung tutup
Memanggil mehod inOrder berparameter r.pKiri

442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
483
484

Proses mencetak nilai r.data

Memanggil method inOrder berparameter r.pKanan
Kurung tutup
Komentar
Deklarasi method private jumlahNode berparameter Node node
Melakukan seleksi kondisi if jika node sama dengan null
Mengembalikan nilai 0
Kondisi else
Mengembalikan nilai 1 + jumlahNode(node.Kiri) + jumlahNode(node.pKanan)
Lanjutan sebelumnya
Kurung tutup
Kurung tutup
Deklarasi method boolean isEmpty
Mengembalikan nilai rott sama dengan null
Kurung tutup
Deklarasi method main
Instansiasi objek t
Objek t memanggil method sisipDt berparameter 3
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Objek t memanggil method sisipDt berparameter 4
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Objek t memanggil method sisipDt berparameter 6
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Objek t memanggil method sisipDt berparameter 5
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Objek t memanggil method sisipDt berparameter 15
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Objek t memanggil method sisipDt berparameter 10
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Objek t memanggil method sisipDt berparameter 20
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Objek t memanggil method sisipDt berparameter 17
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru

485
486
487
488
490
500
501
502
503
504
505
506
507
508
509
510
511
512
513

Objek t memanggil method sisipDt berparameter 25

Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Instansiasi Scanner
Inisialisasi variable del
Melakukan perulangan do-while
Proses mencetak Pilih nilai yang ingin dihapus
Lanjutan sebelumnya
Inputan user pada variable del
Melakukan seleksi kondisi if jika t.isEmpty
Proses mnecetak Tree masih kosong
Kondisi else
Objek t memanggil method delete berparameter del
Kurung tutup
Objek t memanggil method inOrderTraversal
Proses mencetak baris baru
Batas perulangan while del tidak sama dengan 10
Kurung tutup
Kurung tutup