Struktur Data

(Data Structures)
( 4 SKS )

FLORIDA DAMANIK

STMIK MIKROSKIL MEDAN

2020

18 Juni 2020 STMIK Mikroskil Medan 1

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
Binary Search Tree adalah pohon biner dengan kekhususan
sebagai berikut :
Jika P adalah sebuah akar, dan semua info yang tersimpan
pada simpul selalu unik, maka :
• semua simpul pada subpohon kiri mempunyai nilai lebih kecil
dari Info(P), dan
• semua simpul pada subpohon kanan mempunyai nilai lebih
besar dari Info(P)
Perhatikan gambar berikut ini :

18 Juni 2020 STMIK Mikroskil Medan 2

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
Struktur binary search tree adalah sebagai berikut :
typedef ... InfoType; // tipe info
terdefinisi
type ... address; // bergantung representasi
fisik, mengacu ke Node
typedef address BST;
typedef struct TNode
{ InfoType Info;
BST Left;
BST Right;
} Node;

18 Juni 2020 STMIK Mikroskil Medan 3

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
Jika P adalah sebuah binary search tree, maka terdapat
selektor sebagai berikut :
• Info(P) untuk mengakses info dari simpul / akar pohon P
• Left(P) untuk mengakses subpohon kiri dari P
• Right(P) untuk mengakses subpohon kanan dari P

18 Juni 2020 STMIK Mikroskil Medan 4

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
Operasi dan Fungsi Dasar
1.SearchBST
int SearchBST(BST P, InfoType X)
{ /* mencari apakah ada simpul dengan info = X pada pohon
pencarian
biner P; jika ada, akan mengembalikan nilai 1,
jika tidak, mengembalikan nilai 0 */
if (P == NIL)
return(0);
else if (X == Info(P))
return (1);
else if (X < Info(P))
return(SearchBST(Left(P),X));
else return(SearchBST(Right(P),X));
}

18 Juni 2020 STMIK Mikroskil Medan 5

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
2. InsertBST
void InsertBST(BST *P, InfoType X)
{ /* I.S. P mungkin kosong
F.S. X akan disisipkan sebagai elemen binary search
tree P
Proses : menyisipkan X menjadi elemen binary search
tree */
if (*P == NIL) // Sisip
{ // alokasi alamat untuk simpul baru
Info(*P) = X;
Left(*P) = NIL;
Right(*P) = NIL;
}
else if (X < Info(*P))
InsertBST(&Left(*P),X);
else InsertBST(&Right(*P),X);
}

18 Juni 2020 STMIK Mikroskil Medan 6

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
Contoh :
Jika inputnya adalah 21 buah bilangan integer sebagai berikut :
8 9 11 15 19 20 21 7 3 2 1 5 6 4 13 14 10 12 17 16 18
8

7 9

3 11

2 5 10 15

1 4 6 13 19

12 14 17 20

16 18 21

18 Juni 2020 STMIK Mikroskil Medan 7

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
3. DeleteBST
Penghapusan sebuah simpul dengan info = X pada sebuah
pohon pencarian biner P tidak semudah penyisipan.
Kasus-kasus :
• tidak ada simpul dengan info = X
• simpul dengan info = X merupakan simpul daun,
sehingga dapat langsung dihapus. Perhatikan gambar
berikut ini :
Initial State Final State

10 10

5 15 5 15

3 8 13 18 3 8 18

18 Juni 2020 STMIK Mikroskil Medan 8

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
o simpul dengan info = X hanya mempunyai satu anak (kiri xor
kanan), sehingga tempatnya digantikan oleh simpul
anaknya. Perhatikan gambar berikut ini :
Initial State Final State

10 10

5 15 5 18

3 8 18 3 8

18 Juni 2020 STMIK Mikroskil Medan 9

 POHON (TREE)
Binary Search Tree (Pohon Pencarian Biner)
o simpul dengan info = X mempunyai anak kiri dan anak
kanan, sehingga akan digantikan oleh simpul terkanan dari
subpohon kiri, atau simpul terkiri dari subpohon kanan.
Perhatikan gambar berikut ini :
Initial State Final State (1) Final State (2)

7 7 7

3 9 2 9 4 9

1 5 8 1 5 8 1 5 8

2 4 6 4 6 2 6

18 Juni 2020 STMIK Mikroskil Medan 10

Definisi dan Sifat BST
T1 dan T2 juga berupa Binary Search Tree
BST merupakan penjelmaan dari proses Pencarian,
karena bentuknya yang teratur (Sorted)

Perhatikan gambar tree berikut :

7 7
4 12 8 12

3 6 9 3 5 6
Binary Search Tree Bukan Binary Search Tree
Representasi BST
1. Representasi Binary Search Tree (Binary Tree) dengan
Array :
- Node root mempunyai indeks array : 0
- Leftchild suatu node dengan indeks p : (2p + 1)
- Rightchild suatu node dengan indeks p : (2p + 2)
- Parent suatu node dengan indeks p : (p-1 div 2)

2. Representasi Binary Search Tree (Binary Tree) dengan

Array :
struct BST
{ struct BST *Kiri;
data_type info;
struct BST *Kanan;
};
struct BST *Root;
Operasi-Operasi BST :
1. Mengosongkan BST (Makenul(T))
Tujuan : Untuk Menciptakan BST pertama sekali atau
mengosongkan BST yang sudah terisi
(mengosongkan yang sudah terisi tidak dianjurkan,
sebab untuk representasi linked list akan membuat
node tetap berada dimemori)

2. Mencek apakah BST kosong (Empty(T))

Tujuan : Untuk Mengetahui apakah BST T kosong
atau tidak. Suatu fungsi yang menghasilkan nilai True
jika BST kosong atau nilai False jika BST tidak
kosong. Operasi ini biasa dilakukan sebelum
melakukan operasi menghapus, mencari atau
menampilkan
Operasi-Operasi BST :
3. Mencari Tree Minimum (Tree_Minimum(T))
Tujuan : Untuk mencari isi node paling minimum.
Proses pencarian dilakukan mulai dari root dan
berlanjut ke leftchild hingga Null. Hal ini dilakukan,
sebab elemen node minimum dijamin paling kiri

4. Mencari Tree Maksimum (Tree_Maksimum(T))

Tujuan : Untuk mencari isi node paling maksimum.
Proses pencarian dilakukan mulai dari root dan
berlanjut ke rightchild hingga Null. Hal ini dilakukan,
sebab elemen node maksimum dijamin paling kanan
Operasi-Operasi BST :
5. Memasukkan data baru ke dalam BST (Insert(x,T))
Tujuan : Suatu operasi untuk memasukkan elemen x
ke dalam BST (BST unik, dimana tidak ditemukan 2
atau lebih elemen yang sama). Untuk operasi insert
berlaku ketentuan :
- Pencarian lokasi untuk node yang akan diinsert
selalu dimulai dari root
- Jika node yang diinsert lebih kecil dari root , maka
insert di daun pada left subtree
- Jika node yang diinsert lebih besar dari root , maka
insert di daun pada right subtree
Operasi-Operasi BST :
6. Mencari elemen tertentu dalam BST (Search(x,T))
Tujuan : Suatu operasi untuk mencari elemen x
apakah ada dalam BST atau tidak. Apabila ada maka
fungsi menghasilkan nilai True dan False apabila
tidak ada

• Menghapus elemen tertentu dari BST (Delete(x,T))

Tujuan : Suatu operasi untuk menghapus elemen x
dari BST apabila ditemukan. Apabila dilakukan
penghapusan, dimungkinkan terjadi perubahan pada
BST dengan ketentuan :
- Jika yang didelete adalah leaf (daun) maka BST
tidak berubah
Operasi-Operasi BST :
- Jika yang didelete adalah node yang hanya
memiliki satu anak, maka anak tersebut langsung
menggantikan posisi dari parent-nya
- Jika yang didelete adalah node dengan 2 anak (2
subtree), maka node yang diambil menggantikan
node yang dihapus adalah :
a. Jika berasal dari left subtree, maka diambil node
paling kanan (nilai terbesar)
b. Jika berasal dari right subtree, maka diambil
node paling kiri (nilai terkecil)
Operasi-Operasi BST :
8. Menampilkan semua elemen dalam BST (Tampil(T))
Tujuan : Suatu operasi untuk menampilkan semua
elemen dimiliki BST. Urutan tampilan elemen dapat
disesuaikan dengan operasi penelusuran : Preorder,
Inorder atau Postorder
Definisi Binary Balanced Tree

1. Binary Balanced Tree (Pohon Biner Seimbang): Adalah

pohon biner yang Height SubTree kirinya dan Height
SubTree kanannya maksimum selisih 1.
2. Pohon seperti ini ditemukan oleh 3 orang matematika
rusia: Adelson-Velskii-Landis, oleh karena itu dikenal
juga sebagai AVL Tree
3. Dan Kedua SubTree adalah juga pohon biner
seimbang.
4. Dengan balanced Tree maka rata-rata kompleksitas
Search akan diturunkan. Sebab komparasi maksimal
dalam 1 search hanya sebanyak (height+1) kali, dan
height balanced tree lebih rendah dibandingkan saat
unbalanced.
Definisi Binary Balanced Tree

4. Search pada BalancedTree lebih cepat daripada search

pada UnBalancedTree.
5. Akibat sampingan: insertion dan deletion juga lebih
cepat dilakukan pada balanced tree.
N= 2
Perhatikan : N= 1
N= 4
N= 3
Definisi Binary Balanced Tree

6. AVL Tree adalah height balanced 1-tree yang berarti

maksimum perbedaan height antara subtree kiri dan kanan
adalah satu
a. TallLeft bila subtree kiri lebih panjang dari subtree kanan
(simbol -)
b. TallRight bila subtree kanan lebih panjang dari subtree
kiri (simbol +)
c. Balance bila Subtree kiri dan kanan mempunyai height
sama, simbolnya 0
Search Path :
Path pencarian lokasi untuk dilakukan operasi insert dimulai
dari Root

Pivot Point :
- Adanya node pada search path yang balancenya TallLeft
(tanda -) atau TallRight (tanda +) dan terletak paling dekat
dengan node yang baru
- Contoh : Jika diinsert node baru dengan nilai 5, maka pivot
pointnya di node 25

Operasi Insert :
- Kasus-1
Tidak ada pivot point dan setiap node adalah balance, maka
bisa langsung diinsert sama seperti BST
- Kasus 2
Jika ada PP tetapi subtree yang akan ditambahkan node baru
memiliki height yang lebih kecil, maka bisa langsung di insert
- Kasus 3
Jika ada PP dan subtree yang akan ditambahkan node baru
memiliki height yang lebih besar, maka tree harus digenerate
supaya tetap menghasilkan AVL Tree
Regenerate :
- Single Rotation
a. Single Left Rotation
b. Single Right Rotation
- Double Rotation
a. Double Left Rotation
b. Double Right Rotation
Algoritma Single Right Rotation :
BST SRR (BST R)
{ BST P = R->Kiri;
R-Kiri = P->Kanan;
P->Kanan = R;
return P;
}

Algoritma Single Left Rotation :

BST SLR (BST R)
{ BST P = R->Kanan;
R->Kanan = P->Kiri;
P->Kiri = R;
return P;
}
Algoritma Double Right Rotation :
BST DRR (BST R)
{ BST P = R->Kiri;
BST Q = P->Kanan;
R->Kiri = Q->Kanan;
P->Kanan = Q->Kiri;
Q->Kanan = R;
Q->Kiri = P;
return Q;
}
Algoritma Double Left Rotation :
BST DLR (BST R)
{ BST P = R->Kanan;
BST Q = P->Kiri;
R->Kanan = Q->Kiri;
P->Kiri = Q->Kanan;
Q->Kiri = R;
Q->Kanan = P;
return Q;
}
Definisi AVL Tree
Balanced Binary Tree/Pohon Biner Seimbang : pohon
biner dengan tinggi subtree kiri dan kanan berbeda
maksimum 1, dan setiap subtree-nya juga berupa pohon
seimbang.
Pohon seperti ini ditemukan oleh 3 orang matematika rusia:
Adelson-Velskii-Landis, oleh karena itu dikenal juga
sebagai AVL Tree.
N= 2
N= 1

N= 4
N= 3
Definisi (lanj)
N= 5 N= 6

N= 7
 Fungsi Pembangun BalancedTree
function BuildBalancedTree(n:integer)BinTree
{ IS: n terdefinisi positif
FS:membentuk sebuah balanced tree biner dengan n buah node/simpul
yang dibaca, separuh node dari pohon akan menjadi pohon kiri dan
separuhnya kanan. Info pohon diinputkan oleh user secara PreOrder.
Catt: Ini Fungsi yg melayani interaksi usertidak lazim}
kamus:
newNode : BinTree
algoritma:
if (n=0) then
newNode  Nil
else
nL  n div 2
nR  n - nL - 1
input(X) {input X:infotype dari user via keyboard}
newNode  allocate(Node)
Info(newNode)  X
Left(newNode)  BuildBalancedTree(nL)
Right(newNode)  BuildBalancedTree(nR)
 newNode
Jika input adalah 21 bilangan integer berikut:
8,9,11,15,19,25,21,7,3,2,1,5,6,4,13,14,10,12,17,16,18

9 5

11 7 6 12
15 25 1
3 4 14 17 18
19 21 2 13 10 16

Perhatikan, pohon di atas adalah BalancedTree, tetapi

bukan BST
Definisi Binary Balanced Tree

1. Binary Balanced Tree (Pohon Biner Seimbang): Adalah

pohon biner yang Height SubTree kirinya dan Height
SubTree kanannya maksimum selisih 1.
2. Pohon seperti ini ditemukan oleh 3 orang matematika
rusia: Adelson-Velskii-Landis, oleh karena itu dikenal
juga sebagai AVL Tree
3. Dan Kedua SubTree adalah juga pohon biner
seimbang.
 Balanced Tree
Balanced Tree/Pohon Seimbang : pohon dengan
tinggi subtree kiri dan kanan berbeda maksimum 1,
dan setiap subtree-nya juga berupa pohon
seimbang.
Pohon seperti ini ditemukan oleh 3 orang matematika
rusia: Adelson-Velskii-Landis, oleh karena itu dikenal
juga sebagai AVL Tree. N= 2
N= 1

N= 4
N= 3
 Contoh Balanced Tree
Unbalanced Tree
A A Balanced Tree
B C B C
D E E D
Unbalanced Tree
Unbalanced Tree
A
A A
C B C
C
D E D E
E
Unbalanced Tree F
 Kegunaan Balanced Tree
• Dengan balanced Tree maka rata-rata
kompleksitas Search akan diturunkan. Hal ini
disebabkan komparasi maksimal dalam 1 search
hanya sebanyak (height+1) kali, dan height
balanced tree lebih rendah dibandingkan saat
unbalanced.
• Search pada BalancedTree lebih cepat daripada
search pada UnBalancedTree.
• Akibat sampingan: insertion dan deletion juga
lebih cepat dilakukan pada balanced tree.
 Kombinasi Canggih:
Balanced Tree + BST
• Kombinasi: Pohon yang balanced tetapi juga
BST. Atau BST tetapi yang juga balanced.
• Balanced Tree menjamin bentuk yang optimal
untuk search
• BST menjamin keterurutan sehingga
memberikan kepastian “arah searching”.
Misalnya info yang dicari tidak di kiri tetapi di
kanan, maka arah searching akan ke kanan,
dan kiri tidak dilakukan searching.
 Contoh BST+Balanced
Tidak balanced+BST)
6 6 Balanced + BST
5 9 5 9
7 12 3 7
Tidak balanced+BST)
6
6 6
9 5 9
5 9
7 12 10 12
12
Tidak balanced +
Balanced +
Tidak BST)
Tidak BST
 Pemutaran Pohon BST

Operasi Insert dan Delete node pada Pohon dengan tetap

mempertahankan pohonnya BST, bisa membuat Pohon
yang tadinya seimbang menjadi tidak seimbang.
Oleh karena itu diperlukan cara untuk membuat pohon
yang tidak seimbang tersebut menjadi kembali
seimbang, dengan tetap mempertahankan sifat BST.
Diperkenalkan prosedur Balancing.
Prosedur Balancing mengandalkan pemutaran pohon
secara tunggal maupun secara ganda.
 Pemutaran Tunggal
kasus beratKiri
T T
8 x 8 menjadi seimbang

T
6 diubah 6
6
3 3
3 8
BST x  Left(T)
UnBalanced Left(T)  Right(x)
Right(x)T
Tx BST
Balanced
 Ilustrasi Kasus Berat Kiri
T
x  Left(T)
Left(T)  Right(x) 8
Right(x)T
Tx x

6
T
6
3
3 8
 Pemutaran Tunggal
kasus beratKanan
T
T menjadi seimbang
3 x T
3
diubah 6
6
6
8 3 8
8
x  Right(T)
Right(T)  Left(x)
BST Left(x)T BST
UnBalanced Tx Balanced
 Pemutaran Tunggal
8 5

5 T1 8
T3

T1 T2 T2 T3
pemutaran tunggal ke
kanan
3 9

9 3
T1 T3

T2 T3 T1 T2
pemutaran tunggal ke kiri
 Pemutaran Tunggal
kasus Ki-Ka (langsung)
T
T
x 8 menjadi seimbang
8
T
3 diubah 3 y
5
A 5 A B 5
3 8
C
B C x  Left(T)
y Right(x)
Right(x)Left(y) A B C
BST Left(y)  x
UnBalanced Left(T)Right(y) BST
Right(y)T Balanced
Ty
 Ilustrasi Kasus Ki-Ka
T

x  Left(T) 8
y Right(x)
x
Right(x)Left(y)
T
Left(y)  x
3 y
Left(T)Right(y)
Right(y)T 5
A 5
Ty
3 8
B C

A B C
 Pemutaran Tunggal
kasus Ka-Ki (langsung)
T T
menjadi seimbang
3 3 x
T
8 5
y 8 diubah
5 C
5 3 8
A B A B C
x  Right(T) A B C
y Left(x)
BST Left(x)Right(y)
UnBalanced Right(y)  x
Right(T)Left(y) BST
Left(y)T
Balanced
Ty
 Pemutaran Ganda
melakukan pemutaran tunggal 2 kali
T T
8 8
y y
yLeft(T)
3 3 x xRight(y)
5 5 Right(y)Left(x)
Left(x)y
6 6 yx
Pemutaran Ganda (lanjt)
T
T=y=x
8
y=x 5

8
5 3
6
3 6

Left(T)Right(y)
Right(y)T
Ty
 Pemutaran Ganda

ini dulu 12 baru itu

T4 7
3

T1 7 3 12

T2 T3 T1 T2 T3 T4

pemutaran ganda ke kiri lalu ke kanan

 Pemutaran Ganda

3 baru itu

T1
12 7
ini dulu

7 T4 3 12

T2 T3 T1 T2 T3 T4

pemutaran ganda ke kanan lalu ke kiri

 Pemutaran Ganda
kasus Ki-Ka (tak langsung)
T T

8 x 8
menjadi skewedLeft
3 T
diubah 3 y
8
5 5
x  Left(T) 5
BST y Right(x)
UnBalanced Right(x)Left(y) BST belum
3 Balanced,
Left(y)x
Left(T)  y putar sekali
lagi
 Pemutaran Ganda
kasus Ki-Ka (tak langsung)
T T
diubah 3 menjadi skewedRight
3 x T
8 3
y 8
5 5 5

BST x  Right(T) 8
y Left(x)
BST belum
UnBalanced Balanced,
Left(x)Right(y)
Right(y)x putar sekali
Right(T)  y lagi
 Balancing
procedure Balancing (input/output T:BinTree)
{IS: T BST terdefinisi mungkin kosong
FS: T menjadi BST seimbang }
Kamus x,y:BinTree
Algoritma
if(not IsBalancedTree(T)) then
if(IsHigherLeft(T)) then {condong kiri}
if(IsBalancedTree(Left(T))) then
if(Height(Left(Left(T)))<Height(Right(Left(T)))) then
xLeft(T) {Ki-Ka lsg}
yRight(x)
Right(x)Left(y)
Left(y)  x
Left(T) Right( y)
Right(y)T
Ty
else {pemutaran tunggal ke kanan}
x  Left(T)
Left(T)  Right(x)
Right(x)  T
Tx
else Balancing(Left(T)) {putar subtree terbawah dulu}
 Balancing (lanjt)

else {condong kanan}

if(IsBalancedTree(Right(T))) then
if(Height(Right(Right(T)))<Height(Left(Right(T)))) then
xRight(T) {Ka-Ki lsg}
yLeft(x)
Left(x)Right(y);
Right(y)  x
Right(T) Left(y)
Left(y)T
Ty
else {pemutaran tunggal ke kiri}
xRight(T)
Right(T)  Left(x)
Left(x)  T
Tx
else Balancing(Right(T)) {putar subtree terbawah dulu}
Balancing(T) {pemutaran ganda = jika masih ada subtree yang belum }
{seimbang, putar lagi}
 Pohon Biner Berbenang
(Threaded Binary Tree/TBT)
Latar Belakang
• Pada daun suatu pohon biner, pointer left dan right tidak
menunjuk apa-apa. Beberapa node hanya punya satu
anak, sehingga pointer satunya juga tidak menunjuk apa-
apa.
• AJ Perlis dan C Thornton mengemukakan ide, bahwa
pointer kosong (nil) tersebut sebaiknya menunjuk suatu
node tertentu.
• Mereka mengusulkan node yang ditunjuk oleh pointer
kosong itu adalah jika dia node kanan maka menunjuk
suksesor berdasarkan traversal In-Order dan jika dia node
kiri maka menunjuk predesesor berdasarkan traversal In-
Order .
• Pohon ini disebut threaded binary tree (pohon biner
berbenang)
Implementasi Binary Search Tree :

Ketentuan :
a. Semua left child harus lebih kecil dari parent
b. Semua right child harus lebih besar dari parent
Keuntungan : Pencarian node target menjadi lebih efisien dan cepat

Operasi-Operasi Standar BST :

- Mengosongkan BST
- Mencek apakah BST kosong
- Mencari Tree Minimum
- Mencari Tree Maksimum
- Memasukkan data baru ke dalam BST
- Mencari elemen tertentu dalam BST
- Menghapus data tertentu dari dalam BST
- Menampilkan semua elemen dalam BST
a. Mengosongkan BST (Makenull)
void Makenul (BST T)
{ T = NULL; }

b. Memeriksa Apakah BST Kosong

int Empty(BST T)
{ if (T== NULL)
return 1;
else
return 0;
}
c. Pencarian Tree Minimum

BST TREE_MINIMUM (BST T)

{ if (! Empty (T))
{ while (T->Kiri !=NULL)
{ T = T->Kiri; }
return T;
}
}
c. Pencarian Tree Maksimum

BST TREE_MAKSIMUM (BST T)

{ if (! Empty (T))
{ while (T->Kanan !=NULL)
{ T = T->Kanan; }
return T;
}
}
Operasi Insert :
- Pencarian lokasi untuk node yang akan diinsert selalu dimulai dari root
- Jika node yang diinsert lebih kecil dari root , maka insert di daun pada left
subtree
- Jika node yang diinsert lebih besar dari root , maka insert di daun pada
right subtree
e. Memasukkan data baru ke dalam BST

Void Insert( int x, BST T)

Begin
If (T = Nil) Then (* Jika ditemukan T yang nil *)
Begin
New(T); (* ciptakan node baru ditunjuk oleh T *)
T^.Kiri := Nil; (* Set pointer kiri = nil *)
T^.Info := x; (* Isi data pada node = x *)
T^.Kanan := Nil; (* Set pointer kanan = nil *)
End
Else (If x = T^.Data) Then (* x sudah ada dalam T *)
Writeln(‘Error : data tersebut sudah ada *)
Else (If x < T^.Data) Then
Insert(x, T^.Ki) (*jika x < data yg ditunjuk T, maka sisipkan x ke kiri*)
Else (* x > data yang ditunuk T sisipkan x ke kanan *)
Insert(x, T^.Ka)
End;
f. Mencari elemen tertentu dalam BST

Function Search (x: TipeData, T : BST) : Boolean;

Begin
If (T = Nil) Then
Search := False
Else If (x = T^.Info) Then
Search := True (* x ditemukan *)
Else If (x < T^.Info) Then
Search := Search(x, T^.Kiri) (*cari x ke kiri *)
Else (*x > T^.Info *)
Search:= Search(x, T^.Kanan) (* cari secara rekursif ke kanan *)
End;
Operasi Delete
Ketentuan Delete :
- Jika yang didelete adalah leaf maka tidak perlu dilakukan modifikasi
terhadap lokasi
- Jika yang didelete adalah node yang hanya memiliki satu anak, maka
anak tersebut langsung menggantikan posisi dari parent-nya
- Jika yang didelete adalah node dengan 2 anak (2 subtree), maka node
yang diambil menggantikan node yang dihapus adalah :
a. Berasal dari left subtree yang diambil adalah node yang paling
kanan (nilai terbesar)
b. Berasal dari right subtree yang diambil adalah node yang
paling kiri (nilai terkecil)
g. Menghapus data tertentu dari dalam BST

Procedure Delete (x : TipeData; Var T : BST);

Var
Bantu : Pointer;
Begin
If (T = Nil) Then
Writeln(‘Error : ‘, x, ‘ tidak ditemukan ‘)
Else If (x < T^.Info) Then
Delete(x, T^.Kiri) (* rekursif ke kiri *)
Else If (x > T^.Info) Then
Delete(x, T^.Kanan) (*rekursif ke kanan *)
Else (*x ditemukan *)
If (T^.Kiri = Nil And T^.Kanan = Nil) Then (*Kasus x adalah daun *)
Begin
Bantu := T; (*Tangkap node dengan pointer Bantu *)
T := Nil; (*potong T yang tadinya menunjuk node berisi x *)
Dispose(Bantu) (*deallocate Bantu atau lepaskan node *)
End
 Else If (T^.Kiri = Nil) Then (*x berada pada node dimana kirinya nil *)
Begin
Bantu := T;
T := T^.Kanan; (* Set T = pointer kanannya *)
Bantu^.Kanan := Nil; (*putuskan hubungan node dgn kanannya *)
Dispose (Bantu); (*lepaskan node berisi x *)
End
Else If (T^.Kanan = Nil) Then (*x berada dinode dimana kanannya nil
*)
Begin
Bantu := T;
T := T^.Kiri ; (* Set T = pointer kirinya *)
Bantu^.Kiri := Nil; (*putuskan hubungan node dengan kirinya *)
Dispose (Bantu); (* lepaskan node yang berisi x *)
End
Else (* pointer kiri dan kanan T tidak kosong *)
T^.Info := DeleteMin(T^.Kanan)
End;
Fungsi Untuk Mendukung Operasi Delete :
Function DeleteMin (Var A : BST) : TipeData;
Var
Bantu : Pointer;
Begin
If (T^.Kiri = Nil) Then (*ditemukan data terkecil *)
Begin
Bantu := T ; (* tangkap node yang berisi data terkecil *)
DeleteMin := T^.Info; (*Ambil&simpan data terkecil *)
T := T^.Kanan; (* Set T = pointer kanannya *)
Bantu^.Kanan := Nil; (*lepas hubungan node tsb dgn anaknya *)
Dispose (Bantu); (*lepaskan node yang berisi data terkecil *)
End
Else
DeleteMin := DeleteMin(T^.Ki); (*rekursif ke kiri *)
End;
h. Menampilkan semua elemen dalam BST

Procedure Tampil(T);
Var Pilih : Integer;
Begin
Clrscr;
Writeln(‘1. Tampil Secara Preorder’);
Writeln(‘2. Tampil Secara Inorder’);
Writeln(‘3. Tampil Secara Postorder’);
Writeln;
Write(‘Silahkan Pilih : ‘); Readln(Pilih);
If (Pilih = 1) Then
Preorder(T)
Else If (Pilih = 2) Then
Inorder (T)
Else
Postorder(T);
Readln
End;
 AVL TREE

Definisi : BST yang mempunyai ketentuan bahwa maks

perbedaan tinggi antara subtree kiri dan kanan adalah satu
Height-Balanced Tree :
- BST adalah Height Balanced p-tree yang artinya maksimum
perbedaan height antara subtree kiri dan kanan adalah p
- AVL Tree adalah height balanced 1-tree yang berarti
maksimum perbedaan height antara subtree kiri dan kanan
adalah satu
a. TallLeft bila subtree kiri lebih panjang dari subtree kanan
(simbol -)
b. TallRight bila subtree kanan lebih panjang dari subtree
kiri (simbol +)
c. Balance bila Subtree kiri dan kanan mempunyai height
sama, simbolnya 0
Search Path :
Path pencarian lokasi untuk dilakukan operasi insert dimulai
dari Root

Pivot Point :
- Adanya node pada search path yang balancenya TallLeft
(tanda -) atau TallRight (tanda +) dan terletak paling dekat
dengan node yang baru
- Contoh : Jika diinsert node baru dengan nilai 5, maka pivot
pointnya di node 25

Operasi Insert :
- Kasus-1
Tidak ada pivot point dan setiap node adalah balance, maka
bisa langsung diinsert sama seperti BST
- Kasus 2
Jika ada PP tetapi subtree yang akan ditambahkan node baru
memiliki height yang lebih kecil, maka bisa langsung di insert
- Kasus 3
Jika ada PP dan subtree yang akan ditambahkan node baru
memiliki height yang lebih besar, maka tree harus digenerate
supaya tetap menghasilkan AVL Tree
Regenerate :
- Single Rotation
a. Single Left Rotation
b. Single Right Rotation
- Double Rotation
a. Double Left Rotation
b. Double Right Rotation
Algoritma Single Right Rotation :
BST SRR (BST R)
{ BST P = R->Kiri;
R-Kiri = P->Kanan;
P->Kanan = R;
return P;
}

Algoritma Single Left Rotation :

BST SLR (BST R)
{ BST P = R->Kanan;
R->Kanan = P->Kiri;
P->Kiri = R;
return P;
}
Algoritma Double Right Rotation :
BST DRR (BST R)
{ BST P = R->Kiri;
BST Q = P->Kanan;
R->Kiri = Q->Kanan;
P->Kanan = Q->Kiri;
Q->Kanan = R;
Q->Kiri = P;
return Q;
}
Algoritma Double Left Rotation :
BST DLR (BST R)
{ BST P = R->Kanan;
BST Q = P->Kiri;
R->Kanan = Q->Kiri;
P->Kiri = Q->Kanan;
Q->Kiri = R;
Q->Kanan = P;
return Q;
}