Struktur Data Materi Dimas PDF

Diktat : KBMI3305 - Struktur Data Hal : 16
BAB I
PENDAHULUAN
I.1. PENGERTIAN
Berbicara dengan struktur data maka perlu memperhatikan beberapa aspek seperti
logika, algoritma dan kompleksitas program. Struktur data menjadi sangat penting dalam
mendisain sebuah program yang efisien dengan akses yang sangat efektif. Sebuah program
merupakan proses bentukan dari stuktur data dan algoritma.
Data diorganisasi sedemikian rupa dengan cara yang berbeda-beda, baik menurut logika
maupun model model matematika kemudian disusun menurut aturan-aturan yang benar yang
disebut dengan struktur data. Data adalah fakta-fakta / angka-angka yang sudah terekam tetapi
belum digunakan untuk suatu keperluan. Struktur adalah elemen-elemen pebentuk atau
pengaturan hubungan antar elemen dalam suatu sistem.
Model data dapat dipandang dengan 2 cara yaitu :

1. Struktur yang cukup menghubungkan data dalam dunia nyata
2. Struktur sederhana untuk dapat mengefektifkan proses data yang diperlukan.
Struktur data dibagi atas 3 tingkatan struktur yaitu :

1. Defenisi fungsional
2. Referensi logika
3. Referensi fisik
Nilai data (data value) adalah suatu data yang dipandang sebagai satu kesatuan tunggal (single
entity) sedangkan tipe data adalah kombinasi antara himpunan nilai data (set of value) dan
himpunan operasi terhadap nilai-nilai data tersebut.
Struktur data abstrak dibagi menjadi beberapa bagian yaitu :

1. List linier (Linked list)
2. linked list banyak (Multi linked list)
3. Tumpukan (Stack)
4. Antrian (Queue)
5. Pohon (Tree)
6. Grafik (Graph)
Struktur data non abstrak dikelompokkan dalam beberapa bagian yaitu :

1. Set
2. Array
3. Record
4. File
5. Pointer, dan lain-lain
Tipe data abstrak (TDA)

Dapat dipadang sebagai model matematika dan sekumpulan operasi yang didefenisikan
terhadap suatu model.
SINAR SINURAT, ST STMIK BUDIDARMA

Contoh :
Himpunan bilangan bulat : { ...,-3,-2,-1,0,1,2,3, ... } operasi yang dapat dilakukan terhadap
himpunan ini adalah gabungan, irisan, dan lain-lain.
TDA dapat dibagi menjadi :

1. Generalisasi : proses membangkitkan tipe-tipe data dasar / primitif (real, integer, dan lain-
lain) seperti juga prosedur yang merupakan generalisasi dari operasi-operasi dasar, seperti :
+, -, *, /, dan lain-lain
2. Enkapsulasi : Merupakan TDA yang melingkupi / menyelimuti tipe data, artinya defenisi
jenis data dan operasi-operasi yang diperbolehkan dilokalisasi dalam satu bagian program.
Tipe data dari sebuah variabel adalah kumpulan nilai tertentu yang dimuat oleh variabel
tersebut. Misalnya tipe data boolean yang hanya bernilai true atau false dan tidak boleh
yang lain.
I.2. KONSEP ARRAY

Array merupakan struktur data yang paling sederhana, kesederhanaannya dapat dilihat
dari pemberian notasi model linier (dimensi). Dalam array linier dengan jumlah data terbatas
(finite) didefenisikan sebagai berikut : A1, A2, A3, ..., An atau dengan notasi dalam kurung :
A(1), A(2), A(3), ..., A(n)
atau dengan notasi dalam kurung siku :
A[1], A[2], A[3], ... A[n].
Dilihat dari notasi-notasi di atas bahwa A adalah variabel operand dan 1, 2, 3, ... , n adalah
indeks yang menyatakan sekuensi proses.
Selain model notasi linier satu dimensi juga diperbolehkan untuk dua atau tiga dimensi
misalnya, dengan dimensi 2 :
A[1,1], A[1,2], ..., A[1,n], A[2,1], A[2,2], , A[m,n]
dan oleh karena itu array disebut juga dengan dense list (struktur data statis).
Dimensi Array :
1. Array 1 dimensi : List dan vektor
2. Array 2 dimensi : tabel dan matriks
3. Array multidimensional : secara teoritis bahwa jumlah dimensi tidak terbatas akan tetapi
hanya dibatasi oleh besarnya memory
4. Array-array special :
Array segitiga (triagular array) :
Lower triangular array : array 2-dimensi berbentuk bujur sangkar (U1 = U2), dimana
semua komponen di atas diagonal berisi 0
Upper triangular array : perbedaan lower triangular array adalah semua komponen di
bawah diagonal yang berisi 0. Penyimpanan memerlukan lebih sedikit memory,
karena angka 0 tidak perlu disimpan. Rumus AMF untuk triangular array adalah :
Address (S[i,j] = C0 + C1 x (i x (i-1)) + C2 x j, dimana C0 = B, C1 = L/2 , C2 = L
Jumlah elemen = (U x (U+100/2 dan
Jumlah memory = L x jumlah elemen
Array jarang (Sparse Array) : Array yang kebanyakan komponennya mempunyai satu
nilai yang sama, misalnya nilai 0, hanya sebagian kecil yang tidak sama dengan 0.

I.3. KONSEP LINKED LIST
List dianalogikan sebagai daftar (record), kemudian beberapa daftar / record digabung
atau dihubungkan sebagai rangkaian suatu proses yang disebut dengan link. Suatu entitas
dimana record-recor yang termuatdi dalamnya dihubungkan (linked) menjadi satu proses
bersama disebut linked list. Linked list untuk pertama kalinya dapat dikenali dan dihubungkan
dengan suatu pointer head. Perhatikan diagram berikut dalam gambar 1.1
Contoh :
Record / list
Gambar 1.1. Bentuk list

Pada gambar 1.1. ditunjukkan bahwa head akan merujuk (menyimpan alamat) record
tersebut. Rangkaian linked list dikenali dengan head, listlist terkait dan tail
Jenis-jenis linked list antara lain :

1. List dengan elemen terkahir menunjuk diri sendiri
2. List yang mencatat dari elemen pertama sampai terakhir
3. List circular
4. Double linked list
head head
tail prev prev tail
5. Binary list head head
6. Multiple linked list
Gambar 1.2. Jenis-jenis linked list

I.4. KONSEP TREE
Tree (pohon) adalah struktur data yang menyatakan frekuensi data dengan relasi dalam
suatu hirarki antara elemen-elemen data, induk relasi tersebut adalah root (akar) dan cabang-
cabang yang memiliki data disebut dengan leave dan leaf.
Contoh :
Record : mahasiswa {nim, nama, alamat{jalan, area{kota,kdpos}}, umur, jurusan, hobby}
Perhatikan diagram berikut dalam gambar 1.3.
Mahasiswa
NIM Nama Alamat Umur Jurusan Hobby
Jalan Area
Kota kdpos
Gambar 1.3. Bentuk pohon
I.5. KONSEP STACK

Stack (tumpukan) adalah struktur data (list linier) yang menganut paham LIFO (last in
first out), dimana proses yang dapat dilakukan adalah sisip dan hapus data, dan selalu
mengambil posisi di akhir tumpukan (top of stack) dengan bentuk penotasiannya dengan
postfix. Operasi pada stack adalah PUSH (memasukkan data dalam stack) dan POP
(mengambil data dari stack). Perhatikan diagram berikut dalam gambar 1.4.
Gambar 1.4. Bentuk Tumpukan
I.6. KONSEP QUEUE

Queue (antrian) adalah struktur data (list linier) yang menganut paham FIFO (first in
first out) dimana operasi penghapusan dilakukan di depan (front) list dan operasi sisip
dilakukan di belakang (rear) list. Perhatikan diagram berikut dalam gambar 1.5.
in
out
Gambar 1.5. Bentuk Antrian
1.7. KONSEP GRAPH

Graph (grafik) merupakan bagian struktur data yang mengindikasikan adanya relasi-
relasi (many to many) yang beraturan dan tidak beraturan diantara pasangan elemen-elemen
data baik untuk tipe yang sama atau berbeda dengan berbentuk network / jaringan.
Contoh Grafik :
Gambar 1.6. Bentuk salah satu graph

BAB II
FUNGSI, TIPE DATA DAN NOTASI ALGORITMA
Demi kelancaran pemahaman akan struktur data lebih lanjut maka perlu mengetahui
bentuk-bentuk fungsi dan notasi yang sering digunakan baik dalam algoritma maupun program.
II.1. FUNGSI DAN NOTASI MATEMATIKA
FUNGSI FLOOR DAN CEILING

Misalkan X adalah bilangan real, dimana X berada diantara 2 buah bilangan integer
disebut dengan FLOOR dan CEILING.
FLOOR X ( X ) adalah pembulatan nilai X ke bawah dan diambil desimal terbesar.

CEILING X ( X ) adalah pembulatan nilai X ke atas dan diambil desimal terbesar.
Contoh :
3.14 = 3 3.14 = 4
8.5 = 8 8.5 = 9
FUNGSI SISA (MODULUS)

Misalkan X adalah nilai integer dan M adalah positif integer maka nilainya adalah sisa
pembagian. Bentuknya adalah X (mod) M.
Contoh :
25 (mod) 7 = 4 25 (mod) 5 = 0 35 (mod) 11 = 2
FUNGSI INTEGER dan ABSOLUTE

Misalkan X adalah integer, maka nilai integer X ditulis INT(X) dengan mengkonversi X
ke dalam integer dan menghapus bagian fraksional bilangan.
Contoh :
int (3.14) = 3 int (8.5) = 8 int (7) = 7
abs |-15| = 15 abs |-3.33| = 3.33 abs|4.44| = 4.44
FUNGSI SUM ()
Proses berdasarkan sikuensi a1, a2, a3, ... , an maka a1 + a2 + a3 + ... + an maka bentuknya
adalah :
n
Sum () = ai
j=1
FUNGSI FAKTORIAL
Misalkan bilangan integer positif dari satu sampai dengan n dinotasi dengan n ! maka
bentuknya adalah n ! = 1 x 2 x 3 x ... x (n-2) x (n-1) x n.
Contohnya :
5! = 5 * 4!
4 = 4 * 3!
3 = 3 * 2!
2 = 2 * 1!
=2*1=2
3=3*2=6
4 = 4 * 6 = 24
5 ! = 5 * 24 = 120

FUNGSI PERMUTASI
Jumlah pasangan berurutan suatu himpunan dari n buah objek dengan jumlah pasangan
masing-masing adalah r buah besaran, dimana r n.
Misalnya : {a, b, c}
b (a,b) terdapat 6 buah pasangan n = 3 dan r = 2 maka

a rumus :
c (a,c)
n!
a (b,a) P (n, r) =
b (n r) !
c (b,c)
a (c,a)
c
b (c,b)
II.2. TIPE DATA

Dalam mendisain sebuah program yang baik maka sangat penting memperhatikan jenis
tipe data yang akan dipakai untuk menentukan efisiensi penggunaan memori.
Jenis-jenis tipe data sebagai berikut :

- Numeric integer (Int)
- Numerik real (real, Float)
- Charakter (Char)
- String
- Boolean (True, False)
- Pointer
- Ordinal (subset tipe data sederhana kecuali tipe data real dan tipe data yang didefenisi oleh
user yaitu enumerate type dan subrange type)
NUMERIK INTEGER
Merupakan nilai bilangan bulat dalam bentuk decimal maupun hexadecimal. Perhatikan
tabel 2.1. berikut :
Tabel 2.1. Tipe data integer

Tipe Ukuran memori Range nilai
(byte)
Byte 1 0 ... 125
Shortint 2 -128 ... 127
Integer 4 -32768 32767
Word 8 0 65535
Longint 10 -2147483648 2147483647
NUMERIK REAL
Nilai konstanta numeric berkisar dari 1E-38 sampai dengan 1E + 38 dengan mantissa
yang signifikan sampai dengan 11 digit. Nilai E menunjukkan 10 pangkat. Nilai konstanta
numerik real menempati memori 6 byte.
Tabel 2.2. Tipe data real

Tipe Ukuran Memori Range nilai Signifikansi
(byte) Digit
Single 4 1.5 x 10E-45 3.4 x 10E38 78
Double 8 5.0 x 10E-324 1.7 x 10E308 15 16
Extended 10 1.9 x 10E-4951 1.1 x 10E4932 19 20
Comp 16 -2E + 63 + 1 2E +63- 1 19 - 20
II.3. NOTASI ALGORITMA

Notasi algoritma yang dipakai pada umumnya adalah :
Assign ekspressi adalah = atau := atau

Misalnya : untuk meng-assign suatu nilai terhadap suatu variabel
X = 2 atau X := 2 atau X2
Assign kondisi adalah == atau =
Pembanding adalah case of atau if then [else] .

Misalnya untuk membandingkan dua buah nilai butuh operator == atau =
(tergantung bahasa pemrograman yang digunakan) dan dimuatkan ke dalam suatu
pembanding atau perulangan suatu operasi dapat dilakukan dengan :
If (a == b) then ekspressi atau if (a ==b) then ekspressi1 else ekspressi 2
Case a of
1: ekspressi1 ; 2: ekspressi2; ...... end;
Operator adalah + atau - atau / atau *

Misalya : untuk mejumlahkan atau mengurangkan atau membagi bahkan untuk
mengalikan dilakukan dengan :
a*b atau a / b atau a + b atau a-b
Perulangan adalah for do atau while ... do atau do while atau repeat until ()
Relasi adalah atau > atau atau < atau <> atau .GE. atau .GT. atau .LE. atau .LT. atau .NE.
dan lain-lain.
Misalnya : untuk membandingkan dua buah nilai maka harus menggunakan
operator kondisi atau looping
for ( a < b) do ekspressi atau while (a < b) do ekspressi
Repeat
Ekspressi
Until (kondisi)

BAB III
ARRAY, RECORD, SET, POINTER
II.1. ARRAY
Merupakan gugus yang menggambarkan struktur yang mengalokasi alamat (storage) di
memory untuk suatu operand dengan suatu indeks. Array dapat bertipe data sederhana ataupun
tipe data enumerate. Perhatikan diagram berikut pada gambar 3.1.
Tipe Array Array [ Tipe Indeks ] of Tipe
Tipe indeks Tipe Ordinal
Gambar 3.1. Diagram proses Array
Pencapaian / akses data dibagi 2 :

1. Positional access
Merupakan akses dilakukan berdasarkan nilai indeksnya, sedangkan
2. Associative access
Merupakan akses berdasarkan nilai atau isi komponennya. Akses berdasarkan indeks adalah
alamat komponen memory dapat dihitung berdasarkan komponen indeksnya.
Akses berdasarkan indeks dibedakan :

1. Alamat (address) komponen dalam memory dapat dihitung berdasarkan nilai indeksnya
2. Untuk array dengan D dimensi, dibutuhkan D penjumlahan dan D perkalian
3. Kecepatan perhitungan tidak tergantung kepada banyaknya komponen, tetapi tergantung
kepada besarnya dimensi.
Parameter array adalah berdasarkan :

1. Base Address (B)
Alamat (byte pertama) dari array yang diberikan pada saat binding time. Binding time
adalah waktu dimana array diberikan pada suatu lokasi /address di memory, bisa pada saat
compile, execute, dan lain-lain.
2. Component length (L)
Panjangnya memory untuk menyimpan satu komponen. L tergantung dari tipe komponen
dan bahasa pemrograman, misalnya pada Turbo Pascal 7.0 tipe integer mempunyai L=2,
Turbo C 2.0 tipe integer L = 2, Visual C++ 5.0 tipe integer L = 4
3. Upper Bound (Ik) dan Lower bound (Uk)
Ik adalah nilai indeks yang terkecil sedangkan Uk adalah nilai indeks yang terbesar.
Contoh : int s[10]; maka Ik = 0 , Lk = 9
4. Dimension (D)
Besarnya dimensi dari suatu array.
Contoh : int S[10][20]; atau var S : array[1..10][1..20] of integer; maka D = 2
int S[9]; atau var S : array[1..9] of integer; maka D = 1

Sistem Operasi
Gambar 3.2. Konsep Array dalam memory
ARRAY MAPPING FUNCTION (AMF)

AMF merupakan suatu fungsi untuk memetakan nilai indeks ke alamat komponen.
Fungsi Mapping / Pemetaan yaitu :
1. Row major order
Merupakan cara penyimpanan array dalam bahasa pemrograman
2. Virtual origin atau virtual base
nilai konstan C0 (lokas dari komponen dengan indeks 0) dalam AMF.
Rumus dalam AMF :

Address (S[I1][I2] [Id]) = C0 + C1 x I1 + C2 x I2 + + Cn x id ;
dimana Cd = L
Ct-1 = (Ut It + 1) x Cd x Ct ; dan i<t d ;
C0 = B (C1 x I1) - - (Cd x Id)
Rumus perhitungan besarnya penggunaan memory (M) :

M = L x ( U1 I1 + 1) x x (Cd Id + 1)
Contoh deklarasi program pascal:

Var a : array [0..4] of integer; atau int S[5];
Jika diketahui : B = 500, L = 2

Maka I1 = 0, U1 = 4
C1 = L = 2
C0 = B + (C1 x I1)
= 500 + (2 x 0) = 500
Catatan : dalam bahasa C bahwa indek selalu dimulai dari 0, maka C0 = B sedangkan dalam
bahasa Pascal dideklarasikan sendiri oleh programmer-nya.
jadi address dalam pemrograman bahasa C:

S[I] = C0 + C1 x I1 maka
S[4] = 500 + (2 x 4) = 508
S[3] = 500 + (2 x 3) = 506
S[2] = 500 + (2 x 2) = 504
S[1] = 500 + (2 x 1) = 502
Besarnya memory yang dibutuhkan adalah :

M = L x ( U1 I1 + 1) = 2 x (5 0 + 1) = 10 byte
Bila dideklarasikan suatu variabel dengan var x : array [1..n] of integer;

maka implementasi array secara linier dalam memory adalah :
X[1] X[2] X[3] X[4] X[n]
? ? ? ? ? ?
Gambar 3.3. Bentuk array linier

Contoh fragmen program dari
/* Bahasa Pascal adalah : */ /* Bahasa C/C++ adalah : */
Uses CRT; #include ,stdio.h>
Var x : array [1..7] of integer; int x[7], i;
i : byte; { for (i=0; i <= 7; i++)
Begin scanf(%d, &x[i]);
For i := 1 to 7 do Readln(x[i]); for (i=0; i<=7;i++)
For i := 1 to 7 do Writeln(x[i]); printf(%d\n,x[i]);
End. }
II.2. RECORD
Data terstruktur yang mengumpulkan beberapa item data untuk masing-masing tipe data
yang sama atau berbeda disebut field. Perhatikan diagram berikut pada gambar 3.3.
Tipe Record Record Tipe
Daftar field
Gambar 3.4. Diagram proses Record

Contoh fragmen program dari
/* Bahasa Pascal adalah : */ /* Bahasa C/C++ adalah : */
Uses CRT #include <stdio.h>
Type Data = Record struct data {
Nama :string; char *nama;
Umur : byte; int umur; }
End; data x;
Var x : data; {
Begin scanf(%s, &x.nama);
Readln(x.nama); scanf(%d, &x.umur);
Readln(x.umur); printf(%s\n, x.nama);
Writeln(x.nama, x.umur); printf(%d\n, x.umur);
End; }
Proses pembacaannya dapat digantikan dengan cara :

Begin
With x do begin
Readln(nama, umur);
end;
end
III. SET
Bagian struktur data yang mengatur objek-objek dalam set, dimana anggota-anggota set
mempuyai tipe yang sam (base type) yaitu tipe ordinal (integer, boolean, cahr, skalar kecuali
real).
Perhatikan diagram berikut pada gambar 3.4.
Tipe Set Set of Tipe Ordinal
Gambar 3.5. Diagram proses Set
Fragmen program dari Bahasa Pascal adalah :
Contoh1 :
Type huruf_hidup = set of (a, e, o, i, u);
Var teks : string;
Jlh, i : integer;
Begin
Readln(teks);
Jlh := 0;
For i:=1 to ord(teks[0]) do
If teks[i] in huruf_hidup then
Jlh := jlh + 1;
Writeln (Jumlah huruf hidup : , jlh);
End.

Contoh 2 :
{ Menghasilkan huruf yang pernah dipakai dalam suatu kalmia }
Type karakter = set of char;
Var karset : karakter;
i : byte;
pakai, kalimat : string;
Begin
Karset := [];
Write(Masukkan suatu kalimat : ); readln(kalimat);
For i:=1 to length(kalimat) do
If not ([kalimat[i]] <= karset) then
Begin
Karset := karset + kalimat[i];
Pakai := pakai + kalimat[i] +
End;
Writeln (Karakter-karakter yang digunakan : , pakai);
End.
III.4. POINTER
Merupakan struktur data berupa variable dinamis yang tidak dapat dideklarasikan secara
eksplisit seperti variabel statis dan tidak dapat langsung ditunjukkan oleh suatu pengenal
(identifier).
Pointer ini hanya dapat ditunjukkan oleh variable khusus yang berisi alamat memory
yang digunakan oelh variable dinamis. Jadi variabel pointer hanya dapat dideklarasikan dengan
tipe data pointer (simbol baca carat atau circumflex). Perhatikan contoh fragmen program
berikut :
Contoh 1 :
Type kalimat : string; pointkal = ^kalimat;
Var nama : pointkal;
Begin
Nama^ := Belajar struktur data;
Write(nama^);
End.
Contoh 2 :
Type kar = ^catchar;
Catchar = record
Kode : string;
Nama : string;
Gaji : real;
End;
Var datakar : array [1..5] of kar;
i : byte;
Begin
For i := 1 to 5 do
Begin
New (datakar[i]);

With datakar[i]^ do
Begin
Readln(kode);
Readln(nama);
Readln(gaji);
End;
End;
For i := 1 to 5 do
Begin
With datakar[i]^ do
Begin
Writeln(i, kode, nama, gaji);
End;
End;
End;
Tugas : Buatlah program dari salah satu bahasa pemrograman untuk menginput beberapa data
kemudian mengurutkan hasilnya secara menaik (ascending) atau menurun (descending).

BAB IV
LINKED LIST
Linked list merupakan struktur data dinamis, dimana list dianalogikan sebagai daftar /
record yang berisi item data. Dalam list kita harus mengenali masing-masing elemen / node,
misalnya : elemen1, elemen2, ...., elemenn.
Elemen-elemen ini harus dihubungkan (link) dengan suatu pointer (penujuk) pada
alamat-alamat tertentu. Berikut akan dijelaskan lebih dahulu deklarasi-deklarasi list.
IV.1. STATEMENT NEW, DISPOSE DAN VARIABEL POINTER
Statement NEW
Digunakan untuk mengalokasi storage dalam node baru kemudian kita mereferensi
masing-masing node baru yang menyimpan informasi tentang variabel pointer tersebut.
Statement DISPOSE
Digunakan untuk membebaskan list dari rangkaian linked list yang ada.
Type Str1 = array [1..3] of char;

Node = Record
Kata : String;
Next : ^node;
End;
Nodepointer = ^node;
Sehingga operasi dapat dilakukan dengan :

P
New (P) ? Dispose (P) { List P akan hilang }
Q
New (Q) ? Dispose (Q) { List Q akan hilang }
Gambar 4.1. Operasi New dan Dispose
Jika dimisalkan entry data adalah : P^.Kata =Agus dan Q^.Kata = Budi maka bentuk listnya
adalah sebagai berikut :
P
Agus
Q
Budi
Gambar 4.2. Operasi entri list
Perhatikan proses perpindahan ke list berikutnya dengan memisalkan bahwa :

P^.Next = 3 dan Q^.Next = 5 maka bentuk listnya sebagai berikut :
P
Agus 3
Q
Budi 5
Gambar 4.3. Operasi pointer next
Sehingga bentuk linked list yang sebenarnya dapat dideskripsikan sebagai berikut :
Head Head
1 2 3 4 5
Agus 2 Budi
Gambar 4.4. Deskripsi linked list

Misalkan statement r:=q ; p:=q; q:=r maka bentuk linked listnya adalah :
P Q
Agus 3 Budi 5
Sehingga :
R
Agus 3
P
Q Budi 5
Gambar 4.5. Operasi pertukaran head list

Bila gambar 4.5. dibubuhi operasi : Write(P^.Kata, Q^.Kata, R^.Kata) maka akan diperoleh
hasilnya : BudiAgusAgus.
IV.2. LINKED LIST (LINIER)

Linked list (linier) merupakan deretan list-list yang terhubung dengan suatu head / start
di depan. Perhatikan diagram berikut pada gambar 4.6.
Head
1 2 3 4 5
? ? ? ? ?
Informasi tentang data (record data item) Next pointer field = nil = null
Alamat node berikut (next pointer field)
Gambar 4.6. Linked list dengan 5 node

Bagaimana implementasi data dalam linked list dengan pointer masing-masing yang merujuk
mulai dari list awal sampai dengan list terakhir. Perhatikan diagram berikut dalam gambar 4.7.
Head
1 2 3 4
Agus Budi Cerry Dedy
P = Head P^.Kata P^.Next^.Kata P^.Next^.Next^.Kata P^.Next^.Next^.Next^.Kata
P^.Next P^.Next^.Next P^.Next^.Next^.Next P^.Next^.Next^.Next^.Next = nil
Gambar 4.7. Proses pointer dalam linked list
Dalam merepresentasi list-list dalam array dilakukan dengan :
1 Agus 2 1 Agus 2
Budi 3 Budi 3
Cerry 4 Cerry 4
Dedy 0 Dedy 0
? ?
a. List original b. Operasi New
Gambar 4.8. Bentuk implementasi New dalam array
IV.2.1. ALGORITMA TRAVERSAL LINKED LIST
a.Traversal proses linked list b.Traversal cetak linked list

// Traversing dengan array : // Dengan array :
Ptr = head Ptr = head
While (ptr <> nil) do While (ptr <> nil) do
Proses (info [ptr]) Write (info [ptr])
Ptr = link [ptr] Ptr = link [ptr]
Endwhile Endwhile
// Traversing proses dengan pointer : // Dengan pointer :

Ptr = head Ptr = head
While (ptr <> nil) do While (ptr <> nil) do
Proses (ptr^.info) Write (ptr^.info)
Ptr = ptr^.next Ptr = ptr^.next
Endwhile Endwhile

// Menghitung jumlah proses : Endwhile

num =0
ptr = head d. Algoritma mencari suatu item pada
While (ptr <> nil) do data terurut :
Num = num + 1 ptr = head
Ptr = ptr^.next while (ptr <> nil) do
Endwhile if (item = ptr^.info) then
ptr = ptr^.next
c.Algoritma mencari suatu item pada else
data tidak terurut : if (item = ptr^.info) then
ptr = head loc = ptr
While (ptr <> nil) do exit
If (item = ptr^.info) then else
Loc = ptr loc = nil
Else endif
Ptr = ptr^.next endif
Endif Endwhile
Loc = nil
IV.2.2. ALGORITMA SISIP DATA DALAM LINKED LIST

Head
1 2 3 4
Type node = ^data
Data = record
New(P) P New(Q) Q New(R) R Nilai : char;
Next : node
End;
Gambar 4.9. Bentuk sisipan list baru dalam linked list Var head, tail, p,q : node;
A. SISIP AWAL
Head New (Q)
Read (q^.nilai) (3)
Q^.next = nil
(2) P = Head
New (Q) P (1)
If p = nil then
Tail = Q
else
(3) Read (Q^.data
Q^.Next = P . (1)
P = Q .. (2)
a. Sisip list baru di awal linked list

B. SISIP TENGAH
Head
New (Q)
Read (Q^.nilai) , Q^.next = nil
B D E P = Head
While (p<> nil)
(2) (1)
If p^.nilai = B then
New (Q) P
C Q^.Next = P^.Next . (1)
P^.Next = Q .. (2)
(3) Read (Q^.data Else p = p^.next
Endwhile
a. Sisip list baru di tengah linked list
C. SISIP AKHIR
If ( p=nil) then Sisip_awal new (Q)
Head Else Q^.nilai = E
Last = P Q^.next = nil
B C D While (last^.next <> Nil) do P = head
Last = last^.next if p = nil then
(1)
P (2) Endwhile P=Q
New (Q)
E New (Q) else
P^.Next = Q (1) Tail^.next = Q
(3) Read (Q^.data Q^.Next = Nil .(2) Tail = Q
Endif endif
a. Sisip list baru di akhir linked list
Gambar 4.10. Proses penyisipan list baru pada linked list
IV.2.3. ALGORITMA HAPUS DATA DALAM LINKED LIST
A. HAPUS LIST AWAL
P = Head
Head If (P <> nil) then
(1)
Q = P . (1)
(2) P = Q^.Next .. (2)
Dispose (Q)
Endif
a. Hapus list awal dari linked list
B. HAPUS LIST TENGAH P = Head

Q = P^.Next . (1)
Head
(2)
P^.Next = P^.Next^.Next (2)
Q^.next = nil
(1) Dispose (Q)
Catatan :
Untuk menentukan posisi data yang akan dihapus
b. Hapus list awal dari linked list maka dapat dibuat suatu pembanding

C. HAPUS LIST AKHIR
P = Head
If (P^.next = nil) then
Head Last = P
(2)
P = Nil
While (Last^.next <> Nil) do
(1)
P = Last
b. Hapus list awal dari linked list Last = Last^.Next
EndWhile
Q = Last
If (P = Nil) then
P^.next = nil
Gambar 4.11. Proses penghapusan Else
Suatu list dari P = p^.next
Linked List Endif
Else p = p^.next
endif
Berikut ini disajikan program pascal yang mengimplementasi proses linked list (sisip awal,
tengah, akhir dan hapus awal, tengah, akhir) :
Uses CRT; Menu := p

Const garis = -------------------------------; End;
Pesan =Linked list masih kosong ;
Type simpul = ^data; Function simpul_baru : simpul;
Data = Record Var b : simpul;
Nama : string; Begin
Alamat : string; New(b) ;
Next : simpul; With b^ do
End; Begin
Var head, tail : simpul; Writeln(Nama :); readln(nama);
Pilih : char; Writeln(Alamat :); readln(alamat);
Cacah : integer; Next := nil;
End;
Function menu : char; Simpul_baru := b
Var p : char; End;
Begin
Clrscr; Procedure sisip_awal(n : integer);
Writeln(Pilihan Anda : ); Var baru : simpul;
Writeln(a. Sisip list di awal); Begin
Writeln(b. Sisip list di tengah); If n<> 0 then
Writeln(c. Sisip list di akhir); Begin
Writeln(d. Hapus list di awal); Writeln(Menambah list di awal link list);
Writeln(e. Hapus list di tengah); Writeln(copy(garis,1,45))
Writeln(f. Hapus list di akhir); End;
Writeln(g. Cetak isi linked list); Baru := simpul_baru;
Writeln(h. Selesai); If head = nil then tail := baru else
Repeat Baru^.next := head;
Writeln(Pilih salah satu : ); Head :=baru
P := upcase (readkey); End;
Until p in[A,B,C,D,E,F,G];

Procedure sisip_tengah; Begin
Var baru, Bantu : simpul; Writeln(pesan);
Posisi, i : integer; Writeln(Tekan sembarang tombol);
Begin Repeat until keypressed
Writeln(Menambah list ditengah linked list) End else
Writeln(garis); Begin
Writeln(Linked list berisi :,cacah:2, simpul); Writeln(Menghapus list di tengah);
Repeat Writeln(copy(garis,1,35));
Writeln(List baru ditempatkan di urutan Writeln(Linked list berisi :,cacah:2, simpul);
ke berapa ?); Repeat
Readln(posisi); Writeln(Urutan list yang akan dihapus ? );
Until posisi in[1 .. cacah+1); Readln(posisi);
If posisi = 1 then sisip_awal(0) else Until posisi in[1..cacah];
If posisi = cacah+1 then sisip_akhir(0) else If posisi = 1 then hapus_awal else
Begin If posisi = cacah then hapus_akhir else
Baru := simpul_baru; Begin
Bantu := head; For i:=1 to pisisi 2 do
For i:=1 to posisi-2 do Bantu := Bantu^.next;
Bantu := Bantu^.next; Bantu1 := bantu^.next;
Baru^.next := Bantu^.next; Bantu^.next := bantu1^.next;
Bantu^.next := baru; Bantu1^.next := nil;
End; Dispose(bantu1)
End; End
End
Procedure sisip_akhir(n:integer); End;
Var baru : simpul;
Begin Procedure hapus_akhir;
If n<> 0 then Var bantu : simpul;
Begin h : integer;
Writeln(Menambah list baru di akhir linked Begin
list); If head = nil then
Writeln(copy(garis,1,46)) Begin
End; Writeln(pesan);
Baru := simpul_baru; h := 0
If head = nil then End else
Head = baru else If head = tail then
Tail^.next := baru; Begin
Tail := baru; Head := nil;
End ; Tail := nil;
h:=1
Procedure hapus_awal ; End else
Begin Begin
If head <> nil then Bantu := head;
Begin While (bantu^.next <> tail) do
Head := head^.next; Bantu := bantu^.next;
Writeln(List awal telah dihapus) Tail := bantu
End else writeln(pesan); Tail^.next := nil;
Writeln(Tekan sembarang tombol); h := 1
Repeat until keypressed End ;
End; If h=1 then
Procedure hapus_tengah; Writeln(List akhir telah dihapus) ;
Var posisi,I : integer; Writeln(Tekan sembarang tombol);
Bantu, bantu1 : simpul; Repeat until keypressed
Begin End;
If cacah = 0 then

Procedure baca_list; Cacah := 0;
Var bantu : simpul; Head := nil;
i : integer; Tail := nil;
Begin Repeat
i := 1; Pilih := menu;
Writeln(Membaca isi linked list); Clrscr ;
Writeln(copy(garis,1,42)); Case pilih of
Bantu := head; a : sisip_awal(1) ;
If bantu = nil then writeln(pesan) else b : sisip_tengah;
While (bantu <> nil) do c : sisip_akhir(1);
Begin d : hapus_awal;
Writeln(Simpul : ,i:2, nama : e : hapus_tengah;
,bantu^.nama); f : hapus_akhir;
Writeln( :17,Alamat : ,bantu^.next); g : baca_list;
Inc (i) End;
End; If pilih in [A,B,C,] then
Repeat until keypressed Inc(cacah) else
End; If pilih in [D,E,F] and (cacah <> 0)
Then dec(cacah);
{Program utama} Until pilih = H
Begin End.
Tugas :
1. Buatlah prosedur untuk mengiput dua buah linked list dan menggabung keduanya
menjadi Satu
2. Buatlah prosedur untuk mencari data tertentu pada linked list
3. Buat prosedur untuk mengganti data tertentu dalam linked list
4. Buatlah prosedur untuk mengurutkan data linked list
IV.3. LINKED LIST DENGAN MULTI POINTER
IV.3.1. LIST CIRCULAR

List circular (list berputar) adalah linked list yang tidak mempunyai node awal dan
node akhir. Perhatikan diagram berikut pada gambar 4.12.
Head
Gambar 4.12. Linked list circular
Operasi-operasi pada list circular ditunjukkan pada algoritma berikut :

Traverse :
P = head
Ptr = p^.next
While ptr <> p do
Proses ptr^.data
Ptr = ptr^.next
Endwhile

Mencari (search) posisi loc yang berisi item :
Procedure search (data, next, p, item, loc)

Ptr = p^.next
While (ptr^.next <> item) and (ptr <> p) do
Ptr = p^.next
Endwhile
If ptr^.data = item then
Loc = ptr
Else loc = nil
Endif
Endproc
Menemukan posisi loc pada node awal dimana item berada :
Procedure FindHL (data, next, p, item, locp);

Save = p
Ptr = p^.next
While (ptr^.data <> item) and (ptr <> p) do
Save = ptr
Ptr = p^.next
Endwhile
If ptr^.data = item then
Loc = ptr
Locp = save
Else
Loc = nil
Locp = save
Endif
Endproc
Menghapus (delete) node awal :
Procedure dellocHL (data, next, p, avail, item)

FindHL (data, next, p, item, locp)
If loc = nil then
Write(Data tidak ada dalam list)
Exit
Endif
Locp^.next = loc^.next
Loc^.next = avail
Avail = loc
Endproc

IV.3.2. LINKED LIST MULTI ARAH
Deklarasi tipe data sebagai berikut :

Type link = ^multi_node;
Multi_node = Record
field1 : type_field1 ;
: .. ;
fieldn : type_fieldn ;
left, right : link ;
End;
Bentuk umum diagram multi linked list diperlihatkan pada gambar 4.13.
Head Tail
Pointer next
Pointer back
Data field
Gambar 4.13. Linked list dua arah
Linked list 2 arah dengan bentuk circular terdapat perbedaan dengan linked list lainnya.
Head Tail
Pointer next
Pointer back
Data field
Gambar 4.14. Linked list circular dua arah
Perhatikan proses penghapusan node tertentu dalam linked list dua arah dan urutan proses,
ditunjukkan dalam gambar 4.15. berikut :
Loc
Node N
Gambar 4.15. Proses penghapusan Linked list dua arah

Demikian juga proses penyisipan node baru pada posisi tertentu dalam linked list 2 arah.
Perhatikan urutan proses pada gambar 4.16. berikut :
Loc A Loc B
Baru
Gambar 4.16. Proses penyisipan node baru pada linked list dua arah
Operasi-operasi pada linked list 2 arah diperlihatkan pada algoritma berikut :

Menyisip list baru ke dalam linked 2 arah :
Procedure insert (data, forwd, back, p, avail, locA, locB, item)

If avail = nil then
Write(Overflow)
Exit
Endif
Baru = avail
Avail = forwd^.avail
Baru^.data = item
LocA^.forwd = new
New^.forwd = locB
LocB^.back = locA
Endproc
Menghapus node tertentu dalam linked list dua arah :
Procedure delete (data, forwd, back, p, avail, loc)

Loc^.(back^.forwd) = loc^.forwd
(Loc^.forwd)^.back = loc^.back
Loc^.forwd = avail
Avail = loc
Endproc
Berikut ini implementasi algoritma linked list dua arah dalam Bahasa pemrograman
Pascal :
Program linked_list;
Type Penunjuk = ^RecNama;
RecNama = Record
Nama : string;
Pra, post : penunjuk;
End;
Var datanama, head, tail : penunjuk;

Procedure MasukData; Begin
Var lagi : char; x := j^.post;
Begin j^.post := datanama;
Mark(datanama); x^.pra := datanama;
Head : datanama; datanama^.pra := j;
Tail := datanama; datanama^.post := x;
Lagi := Y; End
While (UpCase(lagi)=Y) do End
Begin Datanama := i
New (datanama); End
Writeln(Nama : ); End;
Readln(datanama^.nama);
Datanama^.pra := nil; Procedure tampilkan;
Tail^.post := datanama; Begin
Datanama^.pra := nil; Datanama := head;
Tail:= datanama; While datanama <> nil do
Write(Ada lagi (Y/T) : ); Begin
Readln(lagi0 ; Writeln(datanama^.nama);
End ; Datanama := datanama^.post
End ; End
End;
Procedure urutkan ;
Var x, i, j : penunjuk ; { Program utama }
Begin Begin
Tail = head; MasukData;
Datanama := head^.post; Writeln(Data sebelum diurutkan : );
Head^.pra := nil; Tampilkan;
While (datanama^.nama <> nil) do Urutkan;
Begin Writeln(Data sesudah diurutkan : );
i := datanama^.post; Tampilkan;
If datanama^.nama >= tail^.nama End.
Then begin
Datanama^.pra := tail;
Tail^.post := datanama;
Tail := datanama;
Datanama^.post := nil
End else
Begin
j := tail^.pra;
While(datanama^.nama<= j^.nama)
and (j <> nil) do
j := j^.pra;
If j = nil then
Begin
Head^.pra := datanama;
Datanama^.post := head;
Head := datanama
End else

BAB V
NOTASI POLISH, REKURSIF, STACK, QUEUE
V.1. NOTASI POLISH

Suatu metode untuk menulis/memetakan semua operator-operator sesuai dengan
presedensi (prioritas) sebelum (prefix) operand-operand, sesudah (postfix) operand-operand
atau diantara (infix) operand-operand yang juga merupakan operasi dalam stack.
Berikut diberikan evaluasi skala prioritas operator seperti :
Tabel 5.1. Skala prioritas

Operator-operator Keterangan Presedensi
(prioritas)
^ Ekponensial / pemangkatan 6
* , / , div , mod Perkalian, pembagian, sisa bagi 5
+ , - (binary) Penjumlahan, Pengurangan 4
=,,<,>,, Sama dengan, tidak sama dengan, lebih kecil, 3
lebih besar, Lebih kecil atau sama dengan,
Lebih besar atau sama dengan
not Tidak 2
and , or Dan, Atau 1
:= Sama dengan 0
Notasi infix adalah jika operator berada diantara kedua operandnya, misalnya : suatu
ekspressi c := a + b.
Notasi prefix (notasi polish) adalah jika operator berada di depan kedua operandnya,
misalnya : dari infix c := a + b menjadi := c + a b.
Notasi postfix/suffix (reverse polish) adalah jika operator berada di belakang kedua
operandnya, misalnya : dari infix c := a + b menjadi c a b + :=
Algoritma infix :
1. Scan dari kiri ke kanan sampai ketemu dengan kurung tutup yang paling awal
2. Scan kembali dari posisi sebelumnya ke kiri sampai ketemu kurung buka pertama
3. Lakukan operasi yang berada dalam tanda kurung
4. Ganti ekspresi di dalam kurung tersebut dengan hasil operasi
5. Ulangi langkah 1 sampai dengan selesai.
Kelemahan algoritma ini adalah lama dan tidak efisien
Algoritma posfix/suffix :
1. Scan dari kiri ke kanan sampai ketemu dengan operator
2. Ambil 2 operand yang berada langsung di sebelah kiri operator tersebut
3. Ganti ekspresi dengan hasil operasi
4. Scan lagi hasil operasi tadi ke kanan, jadi tidak perlu discan dari depan sekali seperti
pada proses infix
Keuntungan dari notasi postfix/suffix ini adalah tidak perlu memakai tanda kurung untuk
menyatakan prioritas pengerjaan serta lebih cepat dan efisien, karena tidak perlu selalu scan
dari depan atau paling kiri.
Untuk pekerjaan algoritma posfix/suffix ini, dipergunakan stack untuk menyimpan operand
yang dibaca, yang belum dilakukan operasi terhadapnya.
Perhatikan contoh ekspresi berikut :

Infix : ( A + ( B * C ( D / E ^ F ) * G ) * H )
Postfix : A B C * D E F ^ / G * - h * +
Tabel 5.2. Operasi Stack

No Simbol Stack Ekspresi postfix Keterangan
yang
discan
1 A ( A
2 + (+ A
3 ( (+( A
4 B (+( AB
5 * (+(* AB
6 C (+(* ABC
7 - (+(- ABC*
8 ( (+(-( ABC*
9 D (+(-( ABC*D
10 / (+(-(/ ABC*D
11 E (+(-(/ ABC*DE
12 ^ (+(-(/^ ABC*DE
13 F (+(-(/^ ABC*DEF Baris 13 : Tanda ^ dipop karena
14 ) (+(- ABC*DEF^/ sudah ketemu pasangan ( dan )
15 * (+(-* ABC*DEF^/
16 G (+(-* ABC*DEF^/G Baris 16 : Pasangan ( dan ) sudah
17 ) (+ ABC*DEF^/G*- ketemu maka dipop semua
18 * (+* ABC*DEF^/G*- operator yang ada diantara ( dan )
19 H (+* ABC*DEF^/G*-H Baris 19 : sudah ketemu pasangan
20 ) ABC*DEF^/G*-H*+ ( dan )
V.2. REKURSIF
Rekursif adalah merupakan salah bagian yang penting yang harus dipahami untuk operasi
stack (tumpukan) maupun queue (antrian).
Karakteristik rekursif adalah :

1. Terdapat satu atau lebih kasus sederhana dengan solusinya (stopping cases)
2. Kasus lain diselesaikan dengan mensubstitusi satu atau lebih kasus yang disederhanakan
(closer to stopping cases)
3. Masalah yang disederhanakan hanya pada stopping cases yang relatif mudah
diselesaikan.
Fungsi-fungsi yang menggunakan prinsip rekursif adalah :
a. Fungsi faktorial
Misalkan n ! = 1 x 2 x 3 x x n
Jika n = 0 atau 1 maka n ! = 1 lainnya n ! = n * (n 1) !
Contoh : 4 ! = 4 * 3 !
3!=3*2!
2!=2*1!
=2*1=2
3! = 3 * 2 = 6
4 ! = 4 * 6 = 24
Algoritma :
Function Factorial (n : integer) : integer;
Begin
If (n = 0) or (n = 1) then Factorial := 1 else
Factorial := n * Factorial (n 1);
End;
b. Fungsi Fibonacci
Jika n=0 atau n = 1 atau n = 2 maka Fibonacci = 1 lainnya
Fibonacci = Fibonacci (n-1) * Fibonacci(n-2);
Algoritma :
Function Fibo(n : integer) : integer;
Begin
If (n=0) or (n=1) or (n=2) then Fibo := 1 else
Fibo := Fibo(n-1) * Fibo(n-2);
End;
c. Fungsi Loop
Proses penulisan ulang dengan cara berulang-ulang (rekursif)
Algoritma :
Procedure Deret (n : integer);
Begin
Writeln(n:3);
If n <=10 then
Deret(n+1);
End;
d. Menara Hanoi
Merupakan proses rekursif dalam implementasi stack. Konsep rekursif ini dipakai untuk
memindahkan piringan dari tiang 1 ke tiang 3 dengan bantuan tiang 2.
Perhatikan diagram berikut :

Tiang 1 Tiang 2 Tiang 3
Gambar 5.1. Menara Hanoi
Implementasi algoritma dengan fragmen program dalam bahasa pemrograman

pascal :
Var cacah, cacah_gerak : integer;

Procedure Hanoi(var cacah_gerak : integer; cacah, asal, lewat, tujuan : integer);
Begin
If cacah>0 then
Begin
Hanoi(cacah_gerak, cacah-1, asal, tujuan, lewat);
Cacah_gerak := succ(cacah_gerak);
Write(Langkah ke : , cacah_gerak:2);
Write(, pindahkan piringan no. , cacah:2);
Write( dari tiang , char(asal+64));
Writeln( ke tiang , char(tujuan+64));
Hanoi(cacah_gerak, cacah-1, lewat, asal, tujuan);
End
End;
Begin
Write(Berapa jumlah piringan : ); readln(cacah);
Cacah_gerak := 0;
Hanoi(cacah_gerak, cacah, 1, 2, 3);
Writeln(Piringan sebanyak : , cacah:2, buah, memerlukan,
Cacah_gerak:3, kali pemindahan);
End.
V.3. STACK
Stack (tumpukan) merupakan bagian dari list (struktur linier) dimana item-item data
ditambah atau dihapus selalu di posisi terakhir (LIFO =last in first out) yang disebut top.
Pada stack terdapat terminologi Push dan Pop, dimana push maksudnya adalah
memasukkan elemen data pada stack sedangkan pop adalah mengambil elemen data pada
stack.
Manfaat Stack adalah sebagai berikut :

1. Pengelolaan struktur yang bersarang (nested) atau yang berisi salinan dirinya sendiri
dalam dirinya. Misalnya pengelolaan ekspressi aljabar, himpunan dari himpunan

2. Implementasi algoritma parsing, evaluasi dan backtracking
3. Digunakan oleh sistem operasi untuk memungkinkan prosedur yang nested
4. Digunakan untuk memungkinkan konversi program rekursif menjadi non rekursif
5. Untuk mendukung pushdown automata
6. Untuk mendukung kompiler mengkonversi infix menjadi postfix dan kemudian
mengevaluasi postfix menjadi atomik (assembly) command.
Perhatikan diagram berikut : misalkan terdapat deretan input : A, B, C
New stack Push A Push B Push C Pop C Pop B Pop A
top
C
top B
B B top
A top A A A A top
Gambar 5.2. Operasi Stack
Perhatikan implementasi algoritma berikut :

Const sentinel = #; Procedure pop(var item : char; var top :
Type stackpointer = ^stacknode; stackpointer);
Stacknode = Record Var temp : stackpointer;
Data : char; Begin
Next : stackpointer; If emptystack(top) then
End; Writeln(Stack kosong) else
Var top : stackpointer; Begin
Nextchar : char; Item := top^.data;
Top := top^.next;
Function emptystack(top : stackpointer) : End;
boolean; End;
Begin Begin { program utama }
Emptystack := top = nil Top := nil;
End; Readln(nextchar);
While nextchar = sentinel do
Procedure push(nextchar : char; var top : Begin
stackpointer); Push (nextchar);
Var temp : stackpointer; Readln(nextchar)
Begin End;
New(temp); While not emptystack (top) do
Temp^.data := nextchar; Begin
Temp^,next := top; Writeln(nextchar);
Top := temp; Pop(nextchar,top)
End; End
End.

V.4. QUEUE
Suatu queue (antrian) juga bagian dari linked list yang digunakan untuk
memodelkan sesuatu, seperti barisan tunggu pada suatu counter dengan model FIFO (first
in first out). Operasi-operasi yang digunakan oleh queue antara lain enqueue adalah untuk
memasukkan data dalam antrian sedangkan dequeue adalah untuk mengeluarkan data dari
queue.
Manfaat queue sebagai berikut :

1. Digunakan oleh sistem operasi untuk mengatur eksekusi task dalam suatu sistem
untuk mencapai perlakuan adil (waiting line)
2. Untuk mail box dalam komunikasi antar proses
3. Untuk buffer dalam mekanisme print spooler komunikasi data
4. Untuk simulasi dan modelling, misalnya simulasi sistem pengendali lalu lintas udara
dalam memprediksi performansi.
Untuk lebih jelasnya perhatikan diagram berikut :

front rear
Budi Johan Wardi
Ekonomi Komputer Teknik

(4)
2 1 1
temp
(2) Dulman
(1)
Fisika
Hapus list
Sisip list
2
(3)
Gambar 5.3. Diagram Antrian
Berikut akan disajikan bagaimana proses enqueue dan dequeue dalam queue seperti
diagram dibawah ini :
back
Emptyqueue()
Size = 0
Front
back
enqueue(a)
Size = 1 a
front
back
enqueue(b) a b
Size = 2
Front
Gambar 5.4. Proses enqueue

back
dequeue()
Size = 1 b
front
back
dequeue()
Size = 0
Front
Gambar 5.5. Proses dequeue
Berikut diberikan implementasi algoritma queue :
{untuk mencek apakah queue dalam

keadaan kosong atau tidak}
function emptyqueue(front : passpointer)
: boolean;
begin
emptyqueue := front = nil
end;
Procedure enqueue(newpass : passanger;
var front, rear : passpointer);
Var temp : passpointer;
Begin
New(temp);
temp^.passinfo := newpass;
rear^.next := temp;
temp^.next := nil;
rear := temp;
If emptyqueue(front) then front := rear
End;
Procedure dequeue(var nextpass :

passanger; var front, rear : passpointer);
Begin
If emptyqueue(front) then
writeln(Queue kosong) else
Begin
nextpass := front^.passinfo;
front := front^.link;
If emptyqueue(front) then
front := nil
End
End;

BAB VI
TREE
VI.1. PEMAHAMAN
Tree (pohon) didefenisikan sebagai set (himpunan) node-node atau simpul-simpul dengan edge
(penghubung node) secara langsung antara dua atau beberapa node. Proses tree tidak memiliki prinsip
non rekursif.
Root suatu tree memiliki sifat-sifat antara lain :

- Salah satu node sebagai root
- Setiap node kecuali root terhubung dengan satu edge terhadap rootnya
- Terdapat lintasan unik dari root terhadap node dan sejumlah edge harus dihubungkan
dengan panjang lintasan.
Perhatikan diagram di bawah ini yang menunjukkan bentuk pohon secara umum dengan
ketinggian (heigh) dan kedalaman (depth) tertentu sebagai berikut :
a Level 0
Level 1
b c d e
Level 2
h i j
f g
Level 3
k
Gambar 6.1. Bentuk umum tree
Terminologi-terminologi dalam tree sebagai berikut :

a. Root / parent adalah subtree yang paling atas pada sebuah pohon
b. Child adalah anak-anak dari suatu root, misalnya : b, c, d, e adalah child dari a dan
f, g adalah child dari b dan seterusnya
c. Sabling adalah node-node yang tergolong dari root yang sama (saudara kandung),
misalnya : c, d, e adalah sabling dari b dan seterusnya
d. Leaf adalah node-node yang tidak memiliki cabang lagi (tidak punya anak)
e. Ancestor adalah nenek moyang (ayah dari nenek/kakek), misalnya : a adalah ancestor
dari k
f. Descendand adalah keturunan/anak dari cucu, misalnya : k adalah descendand dari a
g. Depth adalah kedalaman suatu node (length) yang terhitung dari root, misalnya :
Depth f, g, h, I, j adalah 2 ; Depth k adalah 3
Depth b, d, c, e adalah 1 ; Depth a adalah 0
h. Heigh adalah ketinggian (level) dari suatu pohon yang terhitung dari root (path
terpanjang), misalnya heigh dari pohon diatas adalah 3
i. Satu node (single node) dapat juga disebut tree dengan heigh = 0 dan depth = 0
Dari pohon di atas dapat dibentuk sub-sub tree untuk membedakannya sebagai berikut :

Root
T1 T2 T3 ... Tn
Gambar 6.2. Pohon dengan pola rekursif
Pada tree secara otomatis termuat konsep linked list, dimana di antara setiap node
diasumsikan sebagai record / list. Perhatikan diagram berikut ini :
D H
C E G J
Gambar 6.3. Subtree dari tree
Dalam pohon dikenal istilah keseimbangan yaitu jika masing-masing node pada subtree
kiri dan subtree kanan memiliki perbedaan paling banyak satu.
Perhatikan implementasi algoritma berikut :

Type ref = ^node; Begin
Node = Record If n = 0 then tree := nil else
Key : integer; Begin
Left, right : ref; nl := n div 2;
End; nr := n nl 1;
Var n : integer; root : ref; read (x); new (newnode);
with newnode^ do
begin
key := x;
Function tree(n : integer) : ref; left := tree(nl);
Var newnode = ref; right := tree(nr)
x, nl, nr : integer; end;
tree := newnode Writeln(key);
end Printtree(right, h+1)
end; End;
End;
Procedure printtree(t: ref; h : integer);
Var I : integer; Begin
Begin Write(Masukkan banyak data : );
If t^ then Readln (n);
Begin Printtree(root, 0);
Printtree(left, h+1); End.
For i:= 1 to h do write( );
Berikut akan dibuat suatu fragmen program untuk membangun pohon :

(* deklarasi *) begin
Var i, n, nl, nr, x : integer; p := dmy;
Root, p, q, r, dmy : ref; repeat
s : array[1..30] of nl := n div 2; nr := n nl 1;
record n : integer; write(input banyak data:);
rf : ref; readln(x);
end; new(q); q^.key := x; {push}
Begin n := nl; p^.left := q; p := q;
Write(Masukkan banyak data : ); until n = 0;
Readln(n); q^.left := nil;
New(root); new(dmy); r.right := dmy^.left;
i:= 1; s[1].n := n; s[1].rf := root; end;
repeat until I = 0;
n := s[i].n; r:=s[i].rf ; i:=i-1; {pop} printtree(root^.right,0);
if (n=0) then r^.right := nil else end;
fragmen program untuk mencari data dari pohon sebagai berikut :

Var root : ref; end;
k : integer;
Procedure search(x : integer; var p : ref);
Procedure printtree (w : ref; l : integer); Begin
Var i : integer; If p = nil then
begin
if w <> nil then
with w^ do Begin
begin New(p);
printtree(left, l+1); With p^ do
for i:= 1 to l do Begin
write( ); key := x; count := 1;
writeln(key); Left := nil; right := nil
printtree(right, l+1) End
end End else

If x <p^.key then Root := nil;
search(x, p^.left) While not eof(input) do
else Begin
If x >p^.key then search(x, p^.right) Read (k); search(k, root)
Else p^.count := p^.count + 1 End;
end; Printtree(root,0)
Begin End.
fragmen program untuk menghapus data dari pohon sebagai berikut :

Type ref = ^data;
Data = Record
key : integer;
count : integer;
left, right : ref;
end;
Procedure delete(x : integer; var p : ref); Begin

Var p,q : ref; If p= nil then
Procedure del (var r : ref); writeln(Tidak temu) else
Begin If x < p^.key then delete(x,p^.left)
If r^.right <> nil then del(r^.right) else If x > p^.key then
else delete(x,p^.right)
Begin Begin
q^.key:=r^.key; If q^.right = nil then
q^.count:= r^.count; p := q^.left else
q := r; r := r^.left If q^.left = nil then
end p := q^.right else
end; Del(q^.left)
End
End;
VI.2. BINARY TREE

Dikatakan suatu binary tree apabila suatu pohon dengan masing-masing node maksimal memiliki dua
anak. Perhatikan diagram berikut :
SL = sabling kiri
SR = sabling kanan
SL SR A B
Gambar 6.4. Bentuk Binary tree
Traversal yang digunakan adalah inorder, preorder, dan postorder. Dari gambar 6.4 di atas diperoleh
informasi sebagai berikut :
Preorder : RAB (kunjungan root sebelum subtree)

Inorder : ARB
Postorder : ABR (kunjungan root sesudah subtree)
Contoh suatu ekspressi : inorder : a + b / c * d e * f menjadi

Preorder : * + a / b c d * e f menjadi
Postorder : a b c / + d e f * - *
Proses perubahan dari inorder ke preorder dan postorder ditunjukkan pada gambar berikut ini :
1 7 2
2 3 1 6 1 5
4 6 3 5 3 7
5 7 2 4 4 6
preorder postorder inorder
Gambar 6.5. Rute kunjungan dengan preorder, postorder, inorder
Sub klas binary tree :

- Full binary tree : setiap interval node tepat memiliki 2 cabang
- Perfect binary tree : semua node leaf berada pada level sama
- Complete binary tree :
1. Semua node leaf berada pada level terendah, merapat ke sebelah kiri atau membentuk perfect
binary tree
2. Jika tinggi = 0 berarti node tunggal
3. Jika tinggi = 1 berarti node hanya dianak kiri
4. Jika tinggi = h yaitu perfect tree adalah root yang memiliki subtree dari root dengan tinggi h-1
adalah perfect binary tree di sebelah kiri dan sebelah kanan
5. Subtree di sebelah kiri root adalah complete binary tree dengan tinggi h-1 dan sub tree dari root
adalah complete binary tree di kanan dengan tinggi h-2
- Extended binary tree : binary tree dengan penggambaran tree-tree kosong dengan label (legenda) node
yang lain.

Dibawah ini diberikan implementasi algoritma dengan bahasa pascal sebagai berikut :
Type ref = ^node; Procedure postorder (t : ref);
Node = Record Begin
Data : string; If t <> nil then
Left, right : ref; Begin
End; Postorder(t^.left);
Postorder(t^.right)
Procedure preorder (t : ref); Write(t^.data);
Begin End
End;
If t <> nil then
Begin Procedure inorder (t : ref);
Write(t^.data); Begin
Preorder(t^.left); If t <> nil then
Preorder(t^.right) Begin
End inorder(t^.left);
End; Write(t^.data);
inorder(t^.right)
End
End;
VI.3. BINARY SEARCH TREE

VI.3.1. KONSEP UMUM BST
Binary search tree(BST) adalah suatu tree yang setiap nodenya berisi key-key dalam BST tersebut
sebagai berikut :
a. Key dari root lebih besar dari key yang ada pada subtree kiri
b. Key dari root kanan lebih besar dari key yang ada pada subtree kiri.
Point a) dan b) juga berlaku pada node-node di subtree.
BST ini digunakan untuk menyusun data karena fleksibel (mudah digunakan) dan efisien
(memiliki probe log n) dan natural (memiliki sifat representasi alami). Probe adalah tempat yang harus
dilalui sampai ditemukan data yang diinginkan, perhatikan diagram berikut :
Jumlah probe = 4
B
Gambar 6.6. Probe dalam pohon

Bila jumlah data = jumlah level disebut perfect binary tree (pohon seimbang) dengan depth adalah log
N dan jika tidak seimbang depth = log N-1, dan untuk lebih jelas perhatikan diagram berikut :
B C
D E F G
Gambar 6.7. Pohon seimbang
Jika jumlah data = N maka jumlah level (L) : untuk batas bawah 2log n + 1 dan batas atas 2log
(n+1) .
Bila jumlah data untuk tiap level : root = level1 dan jumlah node pada tiap level
ke i = 1 .. 2i-1, lengkapnya perhatikan tabel berikut :
Tabel 6.1. Jumlah data tiap level

Level ke i Jumlah data
1 1 .. 1
2 1 .. 2
3 1 .. 4
4 1 .. 8
5 1 .. 16
6 1 .. 32
7 1 .. 64
Jika tiap level dari binary tree dengan L level penuh atau maksimum maka jumlah node juga maksimum
:
L-1
2 1-1
+2 2-1
+2 3-1
+ .. + 2 L-1 0 1 2
= 2 + 2 + 2 + .. + 2 L-1
= = 2
L
-12i
i=0
Perhatikan contoh berikut :

1. N=10 maka Lmin = 2log 10 + 1 = 3 + 1 = 4 atau Lmax = 2log (10+1) = 3.0. 4
2. N= 130 maka L = 8 atau Lmin = 2log 130 + 1 = 7 + 1 = 8

i
Misalkan sebuah pohon biner memiliki Llevel maka jumlah data adalah L .. 2 -1, dari contoh di atas untuk
L = 5 maka jumlah data = 5 .. 25-1 = 5 .. 31.
VI.3.2. REPRESENTASI BST DALAM ARRAY
Untuk mencek posisi-posisi data dipohon dalam bentuk implementasi array bahwa node root
berada pada posisi i, anak kiri menempati posisi 2*i dan anak kanannya menempati posisi 2*i+1 ; i
adalah level.
Perhatikan bentuk pohon sebagai berikut :
Level 0
2
3 i=1 4 Level 1
5 i=3 6 Level 2
i=2
7 i=7 8 Level 3
i=4 i=5 i=6
a. BST dalam pohon
Selanjutnya juga dalam bentuk implementasi array, perhatikan diagram berikut ini :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
2 3 4 - - 5 6 - - - - - - 7 8
b. BST dalam array

Item data Posisi
2 1
3 2*1=2
4 2*1+1=3
5 2*3=6
6 2*3+1=7
7 2*7=14
Gambar 6.8. Representasi BST dalam array

VI.3.3. OPERASI SISIP, HAPUS DALAM BST
A. Operasi SISIP
Dapat digambarkan untuk setiap keadaan sebagai berikut :
Q Root left right

Sisip(3,Q)
3
Q
Sisip(5,Q) 3 5
Q
Sisip(2,Q) 3 5
2
Q
Sisip(4,Q)
3
2 5
Gambar 6.9. Operasi sisip node dengan BST
B. Operasi HAPUS
Dapat digambarkan untuk setiap keadaan sebagai berikut :
a. Hapus node 2 dan node 4
2 5
b. Hapus node
3 5 3
Q := Q^.kiri
2 5 Dispose(Q^.kiri) 2 4
4 Q^.kiri

c.Hapus node 3
3
5 4 2
Terdapat 3
2 5 kemungkinan
2 4 2 5 5
hasilnya
4
4
Gambar 6.10. Operasi hapus node dengan BST
Berikut diberikan implementasi algoritma BST :

Type data = record
.. : .;
end;
BST = record
node : tipe_data;
left, right : ^BST;
end;
T = ^BST;
Function makenull(P : T) : T; Write(duplikat);

Begin End;
P := nil; makenull := p;
End; Function cari (x : tipe_data, p : T) : boolean;
Begin
Procedure sisip(x : tipe_data ; var p : T); If p=nil then cari := false else
Begin If x=p^.data.key then
If p = nil then cari := true else
Begin If x<p^.data.key then
New(p); cari := cari(x, p^.left) else
P^.data := x; p^.left := nil; Cari := cari(x^.right)
P^.right := nil; End;
End else
If x.key <p^.data.key then Function cek_kosong(p:T) : boolean;
sisip(x, p^left) else Begin
If x.key >p^.data.key then If p=nil then kosong := true else
sisip(x, p^right) else Kosong := false
End;
Procedure hapus(x : tipe_data; var p :T);
Function cari_min(a:T) : T; Begin
Begin If p <> nil then
If a^.left=nil then If x<p^.data.key then
begin Hapus(x, p^.left) else
cari_min := a^.node; If x>p^.data.key then
a := a^.right; Hapus(x, p^.right) else
end else If (p^.left=nil) and (p^.right=nil) then
cari_min := cari_min(a^.left); p := nil else
End; If p^.left=nil then p := p^.right else
If p^.right=nil then p := p^.left else
P^.node := cari_min(p^.right);
End;
VI.4. AVL-TREE
AVL (Adelson-Velski-Landis) tree adalah merupakan salah satu subset BST yang selalu
memperhatikan keseimbangan (balance) pohon. AVL tree sering disebut dengan balanced Binary tree.
Keseimbangan berguna untuk menjamin bahwa depth algoritmik dalam worst case atau perubahan-
perubahan yang relatif kecil.
Hal-hal yang perlu diperhatikan antara lain :

- Jika data yang disisip adalah acak maka akan menghasilkan Binary tree yang mendekati ideal
(mendekati O(log n))
- Jika data yang disusun terurut maka akan menghasilkan binary tree yang memiliki struktur linier
(mendekati O(log n) dan O(n))
Terminologi yang digunakan antara lain :

- Successor adalah penghapusan suatu node dimana posisi-posisi nilai node sesudahnya akan
dipindahkan ke rootnya
- Predecessor adalah melihat apakah ada nilai node (child) di sebelah kiri dimasukkan ke root dan di
sebelah kanan tetap
- Balanced value / vector adalah suatu proses penambahan node untuk melakukan keseimbangan.
Proses AVL tree dengan BST dimana setiap internal node (node dalam) adalah maksimum jumlah
record kiri (ketinggian sub tree) dan jumlah record kanan (ketinggian subtree kanan) berbeda
maksimum 1 (0, 1). Faktor kesetimbangan yang diterima (kiri, root, kanan) adalah (-1,0,1).
Faktor kesetimbangan dapat dilakukan dengan rotasi, yang pada dasarnya penyeimbangan kembali
dilakukan dengan merotasikan node-node tertentu dalam subtree tersebut berdasarkan harga-harga
faktor ketimbangan tingkat node-node atas dalam subtree.
Ada 4 jenis rotasi :

1. Rotasi kiri tunggal
Bila N adalah subtree dimana terjadi penyisipan ( atau N adalah node baru di sisipan itu sendiri) dan N
adalah ancestor paling bawah yang mendapatkan faktor keseimbangan menjadi 2, sementara P anak
kiri dari R yang mana N adalah anak kiri dari P dengan faktor kesetimbangan P=-1. Rotasi dilakukan
sehingga P menjadi ayah dari N dan R yang masing-masing anak kiri dan kanan dari P sementara jika
ada subtree kanan dari P dengan x sebagai root maka akan menjadi subtree kiri dari R. Faktor
kesetimbangan dari R dan P keduanya menjadi 0.
2. Rotasi kanan tunggal
Bila N adalah subtree dimana terjadi penyisipan ( atau N adalah node baru di sisipan itu sendiri) dan N
adalah ancestor paling bawah yang mendapatkan faktor keseimbangan menjadi +2, sementara P anak
kanan dari R yang mana N adalah anak kanan dari P dengan faktor kesetimbangan P=+1. Rotasi
dilakukan sehingga P menjadi ayah dari N dan R yang masing-masing anak kiri dan kanan dari P
sementara jika ada subtree kanan dari P dengan x sebagai root maka akan menjadi subtree kanan dari
R. Faktor kesetimbangan dari R dan P keduanya menjadi 0.
3. Rotasi kiri ganda
Bila N adalah subtree dimana terjadi penyisipan ( atau N adalah node baru di sisipan itu sendiri) dan R
adalah ancestor paling bawah yang mendapatkan faktor keseimbangan menjadi 2, sementara P anak
kiri dari R yang mana N adalah anak kanan dari P dengan faktor kesetimbangan P=-1. Rotasi
dilakukan 2 kali pertama dalam subtree P yang menghasilkan P sebagai anak kiri dari N. Jika N
memiliki subtree kanan maka subtree ini menjadi subtree kiri dari R dan juga jika N memiliki subtree
kiri maka subtree ini menjadi subtree kanan dari P. Faktor kesetimbangan menjadi 0. Faktor
kesetimbangan N dan R tergantung faktor kesetimbangan N semula. Jika faktor kesetimbangan N=0
maka faktor kesetimbangan P dan R keduanya menjadi 0. Jika faktor kesetimbangan =-1 maka faktor
kesetimbangan menjadi 0 dan R = +1. Jika faktor kesetimbangan N = +1 maka faktor kesetimbangan
P = -1 dan faktor kesetimbangan R = 0.
4. Rotasi kanan ganda
Bila N adalah subtree dimana terjadi penyisipan (atau N adalah node baru di sisipan itu sendiri) dan R
adalah ancestor paling bawah yang mendapatkan faktor keseimbangan menjadi +2, sementara P anak
kanan dari R yang mana N adalah anak kiri dari P dengan faktor kesetimbangan P=-1. Rotasi
dilakukan 2 kali pertama dalam subtree P yang menghasilkan P sebagai anak kanan dari N. Jika N
memiliki subtree kiri maka subtree ini menjadi subtree kanan dari R dan juga jika N memiliki subtree
kanan maka subtree ini menjadi subtree kiri dari P. Faktor kesetimbangan menjadi 0. Faktor
kesetimbangan N dan R tergantung faktor kesetimbangan N semula. Jika faktor kesetimbangan N=0
maka faktor kesetimbangan P dan R keduanya menjadi 0. Jika faktor kesetimbangan =-1 maka faktor
kesetimbangan menjadi 0 dan R = +1. Jika faktor kesetimbangan N = +1 maka faktor kesetimbangan
P = -1 dan faktor kesetimbangan R = 0.
Algoritma Menyeimbangkan kembali pada penyisisipan

- Jika faktor kesetimbangan P semula adalah 1 (atau +1) dan sekarang menjadi 0 maka proses selesai
- Jika faktor kesetimbangan semula adalah 0 dan sekarang menjadi +1 (atau 1) maka faktor
kesetimbangan (ayah dari P) berkurang 1 dan jika P anak kiri dari R atau faktor kesetimbangan (ayah
dari P) bertambah 1 jika P anak kanan dari R
- Bila faktor kesetimbangan R menjadi 0 maka selesai
- (Berarti faktor kesetimbangan R menjadi 1 atau +1) Periksa secara rekursif ayah dari R (jika ada)
sebagai R sekarang, R semula menjadi P, P semula menjadi N sampai dengan R = root atau selesai
akibat kasus-kasus point sebelumnya
- (Berarti faktor kesetimbangan R semula adalah +1 menjadi +2 atau semula 1 menjadi 2). Periksa
faktor kesetimbangan R dan P :
1. Kasus faktor kesetimbangan P = -1 atau 0 dan faktor kesetimbangan R = -2. Lakukan rotasi kiri
tunggal dan selesai
2. Kasus faktor kesetimbangan P = +1 dan faktor kesetimbangan R = -2. Lakukan rotasi kanan ganda
dan selesai
3. Kasus faktor kesetimbangan P = +1 atau 0 dan faktor kesetimbangan R = +2. Lakukan rotasi kiri
tunggal dan selesai

4. Kasus faktor kesetimbangan P = -1 dan faktor kesetimbangan R = +2. Lakukan rotasi kanan ganda
dan selesai
Algoritma Menyeimbangkan kembali pada penghapusan

- Tahap pertama penghapusan suatu node pada AVL tree adalah melakukan penghapusan sebagai yang
dilakukan BST dan dilanjutkan dengan menyeimbangkan kembali
- Misalkan suatu node yang dihapus adalah D, setiap ancestor R mulai dari ayah D ke atas dilakukan
pemeriksaan apakah terjadi perubahan faktor kesetimbangan
- Jika D adalah suatu anak (keturunan) kanan dari R dan faktor kesetimbangan R semula adalah 0 (yang
menjadi 1 maka subtree R tetap seimbang serta tidak terjadi pemendekan R sehingga proses selesai
- Jika D adalah suatu anak (keturunan) kiri dari R dan faktor kesetimbangan R semula adalah 0 (yang
menjadi +1 maka subtree R tetap seimbang serta tidak terjadi pemendekan R sehingga proses selesai
- Jika faktor keseimbangan R semula adalah +1 atau 1 dan menjadi 0 maka terjadi pemendekan subtree
R dan proses pemeriksaan dilanjutkan ke ayah dari R sebagai R sekarang
- Jika faktor keseimbangan R semula adalah 1 menjadi 2 (catatan : D adalah keturunan/anak kanan
dari R) maka dengan anak kiri R disebut P dari anak kanan R disebut N
1. Jika faktor keseimbangan P = 0 maka lakukan rotasi kanan tunggal dan selesai karena tidak terjadi
pemendekan subtree R
2. Jika faktor keseimbangan P = -1 maka lakukan rotasi kanan tunggal namun karena terjadi
pemendekan subtree R pemeriksaan untuk penyeimbangan kembali dilanjutkan pada ayah R
sebagai R sekarang
3. (Berarti faktor keseimbangan = +1) dilakukan rotasi kanan ganda dan karena terjadi pemendekan
R dan proses penyeimbangan kembali dilakukan pada ayah R sebagai R sekarang
- Faktor keseimbangan R semula adalah +1 dan menjadi +2 (catatan D adalah keturunan/anak kiri dari
R) maka anak kanan R disebut P dan anak kiri R disebut N :
1. Jika faktor keseimbangan P = 0 maka dilakukan rotasi kanan tunggal dan selesai karena tidak
terjadi pemendekan subtree R
2. Jika faktor keseimbangan P = +1 maka dilakukan rotasi kanan tunggal namun karena terjadi
pemendekan subtree R pemeriksaan untuk penyeimbangan kembali dilanjutkan pada ayah R
sebagai R sekarang
3. (Berarti faktor keseimbangan = -1) dilakukan rotasi kiri ganda dan karena terjadi pemendekan R
dan proses penyeimbangan kembali dilakukan pada ayah R sebagai R sekarang
Contoh 1:AVL tidak seimbang dengan rotasi tunggal sehingga AVL seimbang
10
7
12
10 7
5
5 9 11 15
3 6 9 12
14
3 6 8
8 11 15
14
Gambar 6.11. Rotasi tunggal pada AVL tidak seimbang

Contoh 2:
AVL tidak seimbang dengan rotasi ganda sehingga AVL seimbang
6
6
4 8
B: 11
A: 3
3 5
7 11
1 4 8 13
1 A
9 13
2 5 7 9 12 14
2
10 12 14
10
B
Gambar 6.12. Rotasi ganda pada AVL tidak seimbang
Contoh 3 : Diberikan data sebagai berikut : 35, 40, 10, 12, 16, 17
Bentuklah BST dan tahap-tahap AVL tree dari data ini.
36
40
10
12
16
17
Gambar 6.13. Pohon bentukan BST

Tahap-tahap pembentukan AVL tree :
Sisip 35 Sisip 40 Sisip 10

0 1
35 35 1
35
0
0 0
40 10 40
Sisip 12 Sisip 16 (tidak balance) menjadi
35 -1 35 -1 35 -1
1 0 2 0 0 0
10 40 10 40 12 40
0 1 0 0
12 12 10 16
0
12
Sisip 17 (tidak AVL), dilakukan rotasi sehingga :
35 -2 16 0
1 0 -1 0
12 40 12 35
0 1 0 0 0
10 16 10 17 40
0
17
Gambar 6.14. AVL tree
Berikut dibawah ini disajikan implementasi algoritma :

Algoritma sisip dapat diambil dari yang sebelumnya dengan melakukan search dan kemudian insert
sebagai berikut :

Type ref =^node; begin (double rotasi}

Node = Record p2 := p1^.right;
Key : integer; p1^.right := p2^.left
Count : integer; p2^.left := p1;
Left, right : ref; p^.left := p2^.right;
Bal : -1 .. 1 p2^.right := p;
End; if p2^.bal = -1 then
p^.bal := 1 else
Procedure search (x : integer; var p : ref; var p^.bal := 0;
h : boolean;
if p2^.bal := 1 then
Var p1, p2 : ref; { h := false }
p1^.bal := -1 else
Begin
p1^.bal :=0; p := p2;
If p = nil then
end;
Begin
p^.bal := 0; h:=false
New (p); h := true;
end
With P^ do begin
end;
Key := x; count :=1;
end else
left := nil; right := nil;
if x>p^.key then
Bal := 0
begin
End
search(x, p^.right, h);
End else
if h then
If x <p^.key then
Case p^.bal of
Begin
1 : begin
Search(x,p^.left,h);
p^.bal := 0; h:= false;
If h then
end;
Case p^.bal of
0 : p^.bal := 1;
1 : begin
-1 : begin {rebalanced}
p^.bal:=0; h:= false; end;
p1 := p^.right;
0 : p^.bal := -1;
if p1^.bal := 1 then
-1 : begin
begin
p1 := p^.left;
{single rotasi kanan }
if p1^.bal := -1 then
p^.right := p1^.left;
begin {single rotasi kiri }
p1^.left := p;
p^.left := p1^.right;
p^.bal := 0; p:=p1;
p1^.right := p;
end else
p^.bal := 0; p:=p1;
begin (double rotasi}
end else
p2 := p1^.left;
p1^.left := p2^.right p^.right := p1.left;
p2^.right := p1; p1.left:= p;
p^.right := p2^.left; if b1 = 0 then
p2^.left := p; begin
if p2^.bal = 1 then p^.bal := 1;
p^.bal := -1 else p1^.bal := -1; h:=false
p^.bal := 0; end else
if p2^.bal := -1 then begin
p1^.bal := 1 else p^.bal := 0; p1^.bal :=0;
p1^.bal :=0; p := p2; end;
end; p := p1;
p^.bal := 0; h:=false end else
end begin{ rotasi ganda }
end else p2 := p1^.left;
begin b2 := p2^.bal;
p^.count := p^.count + 1; p1^.left := p2^.right;
h:=false p2^.right := p1;
end p^.right := p2^.left;
end; p2^.left := p;
if b2 = 1 then p^.bal := -1
Procedure delete(x : integer; var p : ref; var h else p^.bal := 0;
: boolean);
if b2 = -1 then
Var q, ref; {h := false}
p1^.bal := +1
Procedure balance1(var p : ref; var h :
else p1^.bal := 0;
boolean);
p := p2; p2^.bal := 0;
Var p1, p2 : ref;
end;
b1,b2 :-1..1;
end;
begin
end;
case p^.bal of
end;
-1 : p^.bal := 0;
0 : begin
Procedure balance2(var p : ref; var h :
p^.bal := 1; h := false;
boolean);
end;
Var p1, p2 : ref;
1 : begin
B1, b2 : -1 .. 1;
p1 := p1^right;
Begin
b1 := p1^.bal;
Case p^.bal of
if b1 >=0 then
1 : p^.bal := 0;
begin { single rotasi kiri }
0 : begin p^.bal := -1; h:=fasle; end;

-1 : begin { rebalance } Del(r^.right, h);
p1 := p^.left; b1 := p1^.bal; If h then balance2(r,h)
if b1 <= 0 then End else
begin ( single rotasi kiri } Begin
p^.left := p1^right; q^.key := r^.key;
p1^.right := p; q^.count := r^.count;
if b1 = 0 then r := r^.left; h:= true
begin end
p^.bal := -1; p1^.bal := 1; end;
h:= false
end else Begin { Utama }
begin If p = nil then
p^.bal := 0; p1^.bal := 0 Begin
end; Writeln(Key tidak ada dalam tree);
p := p1 H:= false
end else End else
begin{ double rotasi } If p^.key then
p2 := p1^.right; Begin
b2 := p2^.bal; Delete(x, p^.left, h);
p1^.right := p2^.left; If h then balance1(p,h)
p2^.left := p1; End else
p^.left := p2^.right; If x > p^.key then
p2^.right := p; Begin
if b2 = -1 then p^.bal := 1 else Delete(x,p^.right,h);
p^.bal := 0; If h then balance2(p,h)
if b2 = 1 then p1^.bal := -1 End else
else p1^.bal := 0; Begin
p := p2; p2^.bal:= 0; q := p;
end; if q^.right = nil then
end; begin
end; p := q^.left; h:= true
end; end else
if q^.left = nil then
Procedure del (var r : ref; begin
var h : boolean); p := q^.right; h:= true
Begin { h := false } end else
If r^.right <> nil then begin
Begin del(q^.left, h);
if h then balance1(p,h) end
end end;
VI.5. B-TREE
B-Tree adalah struktur data yang sangat populer untuk pencarian disk bound. Sifat-sifat B-Tree
adalah :
1. Item data disimpan pada leaves
2. Node-node non leaf data sampai ke key M-1 yang merujuk pencarian key I yang merepresentasi key
yang paling kecil dalam subtree i+1
3. Root adalah juga suatu leaf atau yang memiliki anak antara 2 sampai dengan M
4. Semua node non leaf (kecuali root) memiliki anak antara M/2 dan M
5. Semua leaves dengan depth yang sama memiliki anak anatara L/2 dan L untuk setiap L
Perhatikan diagram berikut :
P0 K1 P1K2 . Pm-1Km-1PmKm
Gambar 6.14. B-Tree dengan M key
Misalnya dibawah ini ditunjukkan suatu B-Tree dengan order 2 dan 3 level, semua frame berisi 2, 3
atau 4 kecuali root diijinkan item tunggal.
25
10 20 30 40
2 5 7 8 13 14 15 18 22 24 26 27 28 32 35 38 41 42 45 46
Gambar 6.15. B-Tree untuk Order 2
Jika pencarian tidak berhasil kita berada dalam salah satu situasi berikut :
1. Ki < X < Ki+1 untuk 1 <= i < m lanjutkan pencarian pada frame pi selanjutnya
2. Km < X Pencarian berlanjut pada frame Pm selanjutnya
3. X < K1 Pencarian berlanjut pada frame P0 selanjutnya
Perhatikan proses penyisipan data baru pada sebuan B-Tree berikut :

Sisip key 22 dalam B-Tree di order 2, ikuti langkah berikut :
1. Key 22 tidak ada dalam frame, sisip di frame C, ini tidak memungkinkan sebab frame C penuh
2. Frame C dipecah menjadi 2 frame, misalnya frame baru D dialokasi
3. Key m+1 adalah sama diletakkan pada C dan D key tengah pindah ke atas 1 level kedalam ancestor
frame A.
Untuk melihat keadaan penyisipan, perhatikan diagram berikut :
A 20
7 10 15 18 26 30 35 40
B C
Menjadi :
A 20 30
7 10 15 18 22 26 35 40
B C D
Gambar 6.16. B-Tree dengan sisipan data
Contoh 1:
Buatlah B-Tree dengan sikuensi data sebagai berikut :
20; 40 10 30 15 ; 35 7 26 18 22 ; 5 ; 42 13 46 27 8 32 ; 38 24 45 25 ;
Catatan : tanda ; adalah batas frame.
a. Sisip 20 20
b. Sisip 40 10 30 15 20
10 15 30 40
c. Sisip 35 7 26 18 22 20 30
e. Sisip 42 13 46 27 8 32
10 20 30 40
5 7 8 13 15 18 22 26 27 32 35 42 46
f. Sisip 38 24 45 25
25
10 20 30 40
5 7 8 13 15 18 22 24 26 27 32 35 38 42 45 46
Gambar 6.17. Keadaan B-Tree setelah proses penyisipan data
Contoh 2:
Buatlah B-Tree dengan sikuensi data yang akan dihapus sebagai berikut :
25; 45 24 ; 38 32 ; 8 27 46 13 42 ; 5 22 18 26 ; 7 35 15 ;
a. Hapus 25 sebagai root

25
10 20 30 40
5 7 8 13 15 18 22 24 26 27 32 35 38 42 45 46
Hapus 45 24
10 20 30 40
5 7 8 13 15 18 22 24 26 27 32 35 38 42 45 46

b. Hapus 38 32
10 22 30 40
5 7 8 13 15 18 20 26 27 32 35 38 42 46
c. Hapus 8 27 46 13 42
10 22 30
5 7 8 13 15 18 20 26 27 35 40 42 46
d. Hapus 5 22 18 26
10 22
5 7 8 15 18 20 26 30 35 40
e. Hapus 7 35 15
15
7 10 20 30 35 40
f. Data terakhir 10 20 30 40
Gambar 6.18. Keadaan B-Tree setelah penghapusan data

Berikut perhatikan implementasi algoritma dengan bahasa pemrograman Pascal :
Const n = 2; if r = n then v := n else
nn = 4; { page size } begin
type ref = ^frame; v := e[n];
item = record for i:=n downto r+2 do
key : integer; e[i] := e[i-1];
p : ref; e[r+1] := u;
count : integer end else
end;
frame = record begin
m : 0 .. nn; r := r-n; v:=e[n+1];
po : ref; for i:= 1 to r-1 do
e : array[1..nn] of item b^.e[i] := a^.e[i+n+1];
end; b^.e[i] := u;
var root, q : ref; for i:= r+1 to n do
x : integer; b^.e[i] := a^.e[i+n];
h : boolean; end;
u : item; m := n; b^.m := n;
b^.p0 := v.p; v.p := b;
Procedure search(x : integer; a : ref; var h : end;
boolean; var v : item);
end;
Var k,l, r : integer; q : ref; u: item;
end;
Procedure insert;
Var I : integer; b: ref;
begin { search }
Begin
if a = nil then
With a^ do
begin
Begin
h := true;
If n < nn then
with v do
Begin
begin
Inc(m); h:=false;
key := x;
For i:= m downto r+2 do
count := 1;
e[i]:=e[i-1];
p:= nil
e[r+1] := u
end else
end else
with a^ do
begin
begin
new(b);
l := 1; r:= m;
if r<=n then
repeat k := (l+r) div 2;
begin
if x<e[k].key then r := k-1;
if x >= e[k].key then l := k+1; b^.m := mb; a^.m := n-1+k;
until r < l ; h:= false;
if l-r > 1 then end else
begin begin
e[k].count := e[k].count + 1; for i:= 1 to n do
h:= false a^.e[i+n] := b^.e[i];
end else for i:= s to mc-1 do
begin c^.e[i] := c^.e[i+1];
if r=0 then q:=p0 a^.m := nn; c^.m := mc 1;
else q := e[r].p; h := c^.m < n
search(x,q,h,u); end
If h then insert end else
End begin
End; if s=1 then b:= c^.p0
End; else b:=c^.e[s-1].p;
mb := b^.m + 1; k := (mb-n) div 2;
Procedure delete (x : integer; a : ref; var h : if k>0 then
boolean);
Begin
Var i, k, l, r : integer; q : ref;
For i:= n-1 downto 1 do
Procedure underflow (c,a : ref; s : integer; var
a^.e[i+k] := a^.e[i];
h : boolean);
a^.e[k] := c^.e[s];
Var b : ref; i, k, mb, mc : integer;
a^.e[k].p := a^.p0; mb := mb k;
Begin
For i:= k-1 downto 1 do
mc := c^.m;
a^.e[i] := b^.e[i+mb];
if s < mc then
a^.p0 := b^.e[mb].p;
begin
c^.e[s] := b^.e[mb];
s := s+1; b:= c^.e[s].p;
c^.e[s].p := a; b^.m := mb-1;
mb := b^.m ; k:= (mb-n+1) div 2;
a^.m := n-1+k; h:= false
a^.e[n] := c^.e[s];
end else
a^.e[n].p := b^.p0;
begin
if k>0 then
b^.e[mb] := c^.e[s];
begin
b^.e[mb].p a^.p0;
for i:= 1 to k-1 do
for i:= 1 to n-1 do
a^.e[i+n] := b^.e[i];
b^.e[i+mb] := a^.e[i];
c^.e[s] := b^.e[k]; c^.e[s].p := b;
b^.m := nn; c^.m := me-1;
b^.p0 := b^.e[k].p; mb:=mb k;
h:= c^.m <n
for i:= 1 to mb do
end
b^.e[i] := b^.e[i+k];
end
end; begin
dec(m); h:= m<n;
procedure del(p: ref; var h : boolean); for i:= k to m do
var a: ref; e[i] := e[i+1]
begin end else
with p6 do begin
begin del(q,h);
q := e[m].p; if h then underflow(a,q,r,h)
if q <> nil then end
begin end else
del (q,h); begin
if h then underflow(p.q.m,h) delete(x,q,h);
end else if h then underflow(a,q,r,h)
begin end
p^.e[m].p := a^.e[k].p; end;
a^.e[k] := p^.e[m]; end;
m := m-1; h:= m<n;
end Procedure printtree(p : ref; l : integer);
end Var I : integer;
end Begin
If p<> nil then
begin With p^ do
if a = nil then Begin
begin For i:= 1 to l do write( );
writeln(key tidak ada dalam tree) For i:= 1 to m do
end else write(a[i].key:4);
with a^ do Writeln;
begin Printtree(p0,l+1);
l := 1; r := m; For i:= 1 to m do
repeat Printtree(e[i].p, l+1);
k := (l+r) div 2; End;
if x <= e[k].key then r := k-1; End;
if x >= e[k].key then l := k+1;
until l > r; Begin
if r = 0 then q:= p0 else q:= e[r].p; Root := nil;
if l-r > 1 then While x <> 0 do
begin Begin
if q = nil then Writeln(Cari key,x);
Search(x,root,h,u); end
If h then end;
Begin printtree(root,1);
q := root; new(root); read(x)
with root^ do end
begin End.
m := 1; p0 := q; e[1] := u
VI.6. BINARY B-TREE

Binary B-Tree (BB-Tree) adalah B-Tree khusus dimana order pertama B-Tree (n=1) yang
mengaproksimasi setengah frame-frame hanya akan berisi item tunggal untuk disimpan (store) yang
berada pada satu level.
B-Tree berisi node-node (frame) dengan 1 atau 2 item lainnya, kemudian 1 page / frame berisi 2
atau 3 pointer (terhadap sabling) yang akan mengindikasikan 2 sampai dengan 3 tahap pohon.
Berdasarkan B-Tree bahwa semua node/frame leaf berada pada level yang sama, dan semua frame
(keturunan) non leaf yang kedua 2 atau ketiga termasuk root. Alternatif dari suatu alokasi linked yang
masing-masing berisi masing-masing node terdapat linked list dengan panjang item 1 atau 2. Perhatikan
diagram di bawah ini untuk lebih memperjelas pemahaman akan BB-Tree sebagai berikut :
a b a b c
Gambar 6.19. Representasi node dalam BB-Tree
Proses pencarian pohon menjamin panjang path maksimum P = 2 log N
Saat melakukan penyisipan ada 4 kemungkinan yang perlu diperhatikan antara lain :
1. Pada saat subtree kanan dibuat dan A merupakan key pada frame tersebut, kemudian keturunan B
menjadi sabling (saudara) A, misalnya pointer vertikal menjadi horijontal pointer
A A B
a B a b c
b c

2. Tentukan frame berikut dengan 3 node dengan memecah dan merotasinya.
A B
A B C B
a b
C a b c d
A C
c d
a b c d
3. Bila subtree B diproses pada ketinggian tertentu maka pointer A akan merepresentasi keturunan,
kemudian keturunan subtree A diijinkan menjadi saudara B. Dengan demikian frame mempunyai
anggota 3 node sebagai berikut :
B
A B
A C
c
A a b c
a b c
a b
4. Dengan adanya pemotongan tanpa memperhatikan seperti langkah kedua, maka akan
diperoleh sebagai berikut :
B C A B C B
c d a b c d
A A C
a b a b c d
Gambar 6.20. Penyisipan node dalam BB-Tree
Pencarian dengan cara seperti diatas menunjukkan perbedaan (tidak efektif) apakah proses sepanjang
horijontal dan vertikal (kasus langkah ketiga). Untuk menangani hal tersebut subtree kiri dan kanan
diselesaikan secara intuisi yaitu fisky dengan membuang yang asimetris, sehingga dinamakan
Symetric Binary B-Tree (SBB-Tree).

Pencarian yang lebih efektif, untuk mencapai rata-rata, tetapi proses sisip dan hapus akan lebih
kompleks dimana masing-masing nodc butuh 2 bit (variabel boolean lh dan rh) untuk mengindikasi 2
pointer secara alami.
Berikut dibawah ini terdapat 4 kasus penyisipan dalam SBB-Tree, semuanya akan merepleksikan
kejadian frame yang overflow dan pemisahan sub sikuensi frame.
(LL)
B C A B C B
A A C
A C A B C B
(LR)
B A C
A B A B C B
(RR) B A C
A B A B C B
B A C
(RL)
Gambar 6.21. Penyisipan node dalam SBB-Tre
Contoh :
Deretan data (; adalah tanda pemisah frame (sanpshot)) dimana semua node tersebut berada dalam 1
level disebut hedge.
(1) 1 2 ; 3 ; 4 5 6 ; 7 ;
(2) 5 4 ; 3 ; 1 2 7 6 ;
(3) 6 2 ; 4 ; 1 7 3 5 ;
(4) 4 2 6 ; 1 7 ; 3 5 ;

(1)
1 2 2 2 4 4
1 3 1 3 5 6 1 3
3 5 3 5
4 5 4 2 4 6
(2)
3 5 1 3 5 7
2 6 4 4
(3) 2 3 5 6 7
3 5 1
2 4 6 2 6 2 6
1 4 7 1 3 4 5 7
(4)
Gambar 6.22. Pengembangan Hedge Tree pada proses sisip
Hal-hal yang perlu diperhatikan sebagai berikut :

1. Jika h=0 maka subtree P tidak meminta pertukaran struktur pohon
2. Jika h=1 maka node P mempunyai sabling (saudara tertentu)
3. Jika h=2 maka subtree P memiliki pertambahan dalam ketinggian.

Implementasi algoritma dengan bahasa pemrograman pascal sebagai berikut :
Procedure search(x : integer; var p : ref; var h p^.left:= p2^.right;

: integer);
p2^.right := p; p:=p2;
Var p1, p2 : ref;
end
Begin
end else
If p = nil then
begin
Begin
h:= h-1;
New(p); h := 2;
if h<> 0 then
With p^ do
p^.lh :=true
Begin
end;
Key := x; count := 1;
end else
Left := nil; right := nil;
If x < p^.key then
Lh := false; rh := false
Begin
End
Search(x, p^.right, h);
End else
If h <> 0 then
If x < p^.key then
If p^.rh then
Begin
Begin
Search(x, p^.left, h);
P1 := p^.left ;
If h <> 0 then
h:=2;
If p^.lh then
p^.rh := false;
Begin
If p1^.rh then
P1 := p^.left ;
Begin
h:=2;
P^.right := p1^.left;
p^.lh := false;
P1^.left := p;
If p1^.lh then
p1^.rh := false;
Begin
p:= p1
P^.left := p1^.right;
End else
P1^.right := p;
If p1^.lh then
p1^.lh := false;
begin
p:= p1
P2 := p1^.left;
End else
p1^.lh := false;
If p1^.rh then
P1^.left := p2^.right;
begin
p2^.right := p1;
P2 := p1^.right;
p^.right:= p2^.left;
p1^.rh := false;
p2^.left := p;
P1^.right := p2^.left;
p:=p2;
p2^.left := p1;
end
end else
begin
h:= h-1;
if h<> 0 then
p^.rh :=true
end;
end else
begin
p^.count := p^.count+1 ;
h:= 0;
end
end;

BAB VII
HASHING DAN KOMPRESI
VII.1. KONSEP HASH
Tabel hashing digunakan untuk mengimplementasikan kamus dalam waktu
konstan per operasi. Tabel hash mendukung pemanggilan dan penghapusan pada
beberapa item yang telah dinamai sebelumnya.
Untuk mengimplementasikan hash dapat mempergunakan array, dimana array
tersebut akan diinisialisasi dengan indeks-indeks tertentu untuk melaksanakan proses
penyisipan data dengan memetakan item-item ke dalam indeks dikenal fungsi.
Fungsi hash digunakan untuk mengkonversi suatu item yang bernilai integer
dengan indeks array dimana item tersimpan. Jika fungsi hash satu ke satu, kita dapat
mengakses item dengan indeks arraynya sendiri sedangkan yang lainnya sebagian item
mengambil beberapa indeks yang sama dan akan mengakibatkan tabrakan (collision).
Misalnya suatu fungsi polinomial : A3x3 + A2x2 + A1x1 + A0x0 dapat dievaluasi
sebagai (((A3)x + A2)x + A1)x + A0
Metode pemilihan key adalah :

1. Metode pembagian modulus (mod) yaitu menggunakan sisa dari setiap item data,
dimana f(key) = h(key) = k mod b ; dimana k adalah key dan b adalah jumlah blok
yang tersedia (biasanya bilangan prima).
2. Metode midsquare yaitu masing-masing item-item data yang akan disimpan
dikwadratkan, kemudian memilih blok (bucket) penampung sesuai dengan nilai digit
yang di tengah dari hasil data yang dikuadratkan tersebut.
Misalnya jumlah blok (bucket) = 13
K 3 13 23 15 16 26 27 37 47 50
K2 9 169 529 225 256 676 729 1369 2209 2500
F(K) 4 0 5 4 9 0 1 4 12 4
collision
collision
Gambar 7.1. Metode midsquare
3. Metode penjumlahan digit yaitu setiap digit dari suatu bilangan dijumlah dan kemudian data tersebut
disimpan pada blok yang sesuai
Contoh :
169 529 225 256
f(K)= 1+6+9 5+2+9 2+2+5 2+5+6
= 16 16 9 13
Collision
Jenis-jenis hashing :
1. Open hashing (hashing terbuka)
Open hash (external hash) adalah suatu table dimana proses pertukaran item data
dengan pointer masing-masing (tidak terpisahkan) tidak terbatas
2. Close hashing (hashing tertutup)
Proses pemetaan data dalam tabel dengan indeks masing-masing, dimana
kelemahannya sering terjadi collision.
Untuk mengatasi collision terdapat beberapa cara :

1. Metode separate chaining
Bahwa tabel hash T[0], T[1], T[2], , T[n] akan berisi header list yang merujuk list
dengan nilai f(K). Setiap lokasi berisi header list pada elemen data f(key) = i. Metode
ini membutuhkan temporary space (tempat tambahan)
2. Metode closed chaining
Merupakan modifikasi separate chaining dimana setiap item data ditambahkan link[i]
yang merujuk item data selanjutnya. Proses ini akan selalu mencari tempat yang
kosong untuk memetakan data, sedang pencarian biasanya dilakukan mulai dari posisi
N sampai dengan posisi 1 dengan catatan tidak ditemukan collision.
3. Linier probing dan quadratic probing (open addressing)
Merupakan metode chaining yang secara sekuensial yang tidak menggunakan space
untuk link item data.
Probe adalah suatu proses perbandingan nilai data pertama dengan data lain. Probe
minimum (terbaik) = 1 berarti kompleksitasnya O(N) = 1 dan probe maksimum
(terburuk) = N berarti kompleksitasnya O(N) = N (terurut) dan probe rata-rata = (1 + n)/2
berarti kompleksitasnya O(1+N)/2 = (1 + N)/2 dan probe kegagalan adalah O(N) = 0.
Perhatikan contoh berikut :

Diberikan deretan data adalah : 3, 13, 23, 15, 16, 26, 27, 37, 47, 50 data-data ini akan
dipetakan ke dalam 13 blok (bucket) untuk menyimpan item-item data sebagai berikut :
- f(3) = 3 mod 13 = 3
- f(13) = 13 mod 13 = 0
- f(23) = 23 mod 13 = 10 Collision
- f(15) = 15 mod 13 = 2
Collision
- f(16) = 16 mod 13 = 3
- f(23) = 26 mod 13 = 0
- f(27) = 27 mod 13 = 1
- f(37) = 37 mod 13 = 11
- f(47) = 47 mod 13 = 8 Collision
- f(50) = 50 mod 13 = 11

VII.2. LINIER PROBING
Merupakan pencarian secara sekuensial dalam array, pencarian dilakukan nulai
dari posisi awal sampai dengan akhir tabel. Jika collision pada suatu alamat maka akan
dicari alamat kosong kemudian kembali ke awal pengalamatan.
Data : 3 13 23 15 16 26 27 37 47 50
F(key) : 3 0 10 2 3 0 1 11 8 11
Maka :
0 1 2 3 4 5 6 7 8 9 10 11 12 ( 13 blok/bucket )
13 15 3 23 Langkah 1 .. 4
f(16)=3 terjadi collision (ada data dalam blok tersebut sebelumnya

maka dilakukan dengan linier probing dengan
fI(key) = (fI-1(key))+1) mod b
f(16) = (3+1) mod 13 = 4
0 1 2 3 4 5 6 7 8 9 10 11 12 ( 13 blok/bucket
13 15 3 16 23 Langkah 1 .. 5
F(26)=0 terjadi collision maka f(26)=0+1 mod 13 = 1
0 1 2 3 4 5 6 7 8 9 10 11 12 ( 13 blok/bucket
13 26 15 3 16 23 Langkah 1 .. 6
F(27) = 1 terjadi collision maka

= 1+1 mod 13 = 2 (collision)
= 4+1 mod 13 = 5
0 1 2 3 4 5 6 7 8 9 10 11 12 ( 13 blok/bucket
13 26 15 3 16 27 47 23 37 Langkah 1 .. 9
F(50)=11 terjadi collision maka

= 11+1 mod 13 = 12
0 1 2 3 4 5 6 7 8 9 10 11 12 ( 13 blok/bucket
13 26 15 3 16 27 47 23 37 50
Gambar 7.2. Proses linier probing

Jadi melihat proses pemetaan data ke dalam array maka dapat kita lihat berapa kali proses
probing, seperti diperlihatkan pada tabel berikut di bawah ini :
Tabel 7.1. Proses probing

Key Fungsi Probe (kali)
3 f(3)=3 1 Jumlah probe
Rata-rata probe = -----------------
13 f(13)=0 1 Jumlah data
23 f(23)=10 1 = 17/10 = 1,7
15 f(15)=2 1 2 kali
16 f(16)=3 1
f(16)=4 1
26 f(26)=0 1
f(26)=1 1
27 f(27)=1 1
f(27)=2 1
f(27)=3 1
f(27)=4 1
f(27)=5 1
37 f(37)=11 1
47 f(47)=8 1
50 f(50)=11 1
f(50)=12 1
Total 17
VII.3. QUADRATIC PROBING

Proses mengkwadratkan posisi-posisi elemen data, kemudian membagi (mod)
setiap elemen data, misalnya x = 5 bila B = 100 maka alamat hash (x) = 52 mod 100 = 25
untuk menghindari collision digunakan quadratic probing.
Misalnya h(x) = y maka h2(x) = (y2 + y) mod B atau hi(x) = (hi-1(x) + P) mod B ; dimana
p = 1,2,3
Hash function mengevaluasi H kemudian mencoba H2+12 ; H2+22 ;H2+32; ; H2+n2 ;
dengan qwadratic probing dapat diselesaikan dilakukan dengan 2 cara :
Cara I :
0 1 2 3 4 5 6 7 8 9
Terdapat 10 blok/bucket
2 3 5 7 11 13 17 19 23 29 Primer 7 blok/bucket
Averflow 3 blok/bucket
Maka h(x) x mod 7 dengan demikian :
h(2) = 2 mod 7 = 2 7 0
h(3) = 3 mod 7 = 3 29 1 Langsung home address
SINAR
h(5) SINURAT,
= 5 mod 7 ST
=5 2 2 STMIK BUDIDARMA
collision
h(7) = 7 mod 7 = 0 3 3
h(11) = 11 mod 7 = 4 collision 11 4
collision 5 5
h(13) = 13 mod 7 = 6 13 6
h(17) = 17 mod 7 = 3
Berarti :
Key : 2 3 5 7 11 13 17 19 23 29
Probe (kali) : 1 1 1 1 1 1 2 3 4 1 Total probe = 16 kali
Rata-rata probe = 16/10 = 1,6 2 kali
Collision terjadi sebanyak 6 kali
Cara II :
0 1 2 3 4 5 6 7 8 9
2 3 5 7 11 13 17 19 23 29 Terdapat 10 blok/bucket
Tabel 7.2. Proses infinitive probing

Indeks Key Modulo Address Probe Collision
1 H(2) 2 %10 2 1
2 H(3) 2 %10 3 1
3 H(5) 5 %10 5 1
4 H(7) 7 %10 7 1
5 H(11) 11 %10 1 1
6 H(13) 13 %10 3 1 1
H(13) (13+12) %10 4 1
7 H(17) 17 % 10 7 1 1
H(17) (17 + 12) %10 8 1
8 H(19) 19 % 10 9 1
9 H(23) 23 % 10 3 1 1
2
H(23) (23+1 )%10 4 1 1
H(23) (23+22)%10 7 1 1
2
H(23) (23+3 )%10 2 1 1
.. .
Sehingga untuk sikuensi data diatas apabila diselesaikan dengan quadratic probing akan
terjadi collision yang tidak terbatas (infinity) seperti pada item data 23 (tabel 7.2)
0 1 2 3 4 5 6 7 8 9
11 2 3 13 5 7 17 19
Gambar 7. 4. Infinitive Probing
Kasus :
Selesaikan dengan quadratic probing kasus berikut :
Diberikan key-key yang akan diinput dalam tabel hash satu, dua, tiga, empat,
lima, enam, tujuh, delapan, sembilan, sepuluh.

Spesifikasi :
- Jumlah blok/bucket (ukuran hash) = 17 (indeks 0 sampai dengan 16)
- Fungsi hash H(x) berdasarkan metode perkalian dengan A = 0.618
- Fungsi ordinal () total bilangan alpabetik dari huruf-huruf pada key (a=1, b=2,
c=3, ..., z=26)
- Coallision dipecahkan dengan cara rehashing dengan fungsi h2(x,i)=-i *
((ord*(x)%5)+1) sehingga penempatan probing ke i adalah hi(x) = h1(x) + h2(x)
dengan i =1,2,3,
Tunjukkan urutan penempatan key-key tersebut dalam tabel dan berapa jumlah collision
yang terjadi pada masing-masing penempatan key.
Jawab :
Tabel 7.3. Konversi alpabetik dengan fungsi ordinal

Ord() Ordinal * A Fractional (AK)
Ord(satu) = 19+1+20+21 = 61 61 * 0.618 = 32,698 0.698
Ord(dua) = 4 + 21 + 1 = 26 26 * 0.618 = 16.068 0.068
Ord(tiga) = 20 + 9 + 7 + 1 = 37 22.866 0.866
Ord(empat) = 5 + 13 + 16 + 1 + 20 = 55 33.990 0.990
Ord(lima) = 12 + 9 + 13 + 1 = 35 22.630 0.630
Ord(enam) = 5 + 14 + 1 + 13 = 33 20.394 0.394
Ord(tujuh) = 20 + 21 + 10 + 21 + 8 = 80 49.440 0.440
Ord(delapan) = 4+5+12+1+16+1+14=53 32.754 0.754
Ord(sembilan) = 19+5+13+2+9+12+1+14=75 46.350 0.350
Ord(sepuluh) = 19+5+16+21+12+21+8=102 63.036 0.036
Sebelum melakukan fungsi rehashing terhadap keseluruhan hasil ordinal huruf-huruf dari
masing-masing item data diatas maka dapat dilakukan dengan fungsi floor (pendekatan
pembulatan nilai ke bawah) pada fungsi hash H(x), seperti pada tabel berikut :
Tabel 7.4. Fungsi rehashing

Fungsi hash Rehashing
H(x) = m.frac(AK) H2(x,i) = -i * ((ord(x) % 5) + 1)
H(satu) = 17 * 0.698 = 11 H2(x,1) = -1 * (61 % 5 + 1) = -2
H(dua) = 17 * 0.068 = 1 H2(x,2) = -1 * (26 % 5 + 1) = -4
H(tiga) = 17 * 0.866 = 14 H2(x,3) = -1 * (37 % 5 + 1) = -9
H(empat) = 17 * 0.990 = 16 H2(x,4) = -1 * (55 % 5 + 1) = -4
H(lima) = 17 * 0.630 = 10 H2(x,5) = -1 * (35 % 5 + 1) = -5
H(enam) = 17 * 0.394 = 6 H2(x,6) = -1 * (33 % 5 + 1) = -24
H(tujuh) = 17 * 0.440 = 7 H2(x,7) = -1 * (80 % 5 + 1) = -7
H(delapan) = 17 * 0.754 = 12 H2(x,8) = -1 * (53 % 5 + 1) = -32
H(sembilan) = 17 * 0.350 = 5 H2(x,9) = -1 * (75 % 5 + 1) = -9
H(sepuluh) = 17 * 0.036 = 0 H2(x,10) = -1 * (102 % 5 + 1) = -30
Tabel ini tidak menunjukkan adanya collision.

Tabel 7.5. Penempatan probing
i Key H(x) H2(x) Penempatan probing
H(x) = H(x) + H2*(x,i)
1 Satu 11 -2 11
2 Dua 2 -4 1
3 Tiga 14 -9 14
4 Empat 16 -4 16
5 Lima 10 -5 10
6 Enam 6 -24 6
7 Tujuh 7 -7 7
8 Delapan 12 -32 12
9 Sembilan 5 -9 5
10 Sepuluh 0 -30 0
0 Sepuluh
1 Dua
2
3
4
5 Sembilan
6 Enam
7 Tujuh
8
9
10 Lima
11 Saturday
12 Delapan
13
14 Tiga
15
16 empat Gambar 7.5. Rehashing
Implementasi algoritma dengan bahasa pemrograman Pascal sebagai berikut :

const bucket = 100; count := nhash[x];
type paket = ^data; head := nhash[count]
data = record new(nhash[count]);
item : byte; nhash[count]^.item := x;
next : paket; nhash[count]^.next := head;
end; end;
var hash : array[1..99] of data;
count : byte; function member(x : byte; var nhash :
head,current : paket; hash): boolean;
before, bil : hash; begin
count := x mod bucket;
{prosedur untuk memasukkan data if (count = bucket-1) then
dalam hash} member := -1 else
procedure insert(x : byte; var nhash : if nhash[count] = x then
hash); member := true else
begin member := member(count+1);

end; before := nhash[count];
current := nhash[count]^.next;
{prosedur untuk mencari data dalam while (before^.lagi <> nil ) and
hash} (not selesai) do
procedure search(x : byte; var nhash : begin
hash); if current^.isi = x then
begin begin
count := 0; before^.lagi := current^.lagi;
if not member(x,bil) then dispose(current);
writeln(data tidak ada dalam hash) selesai := true
else end else
writeln(data pada posisi : , count); begin
end; before := current;
{ prosedur menghapus data dari hash } current := current^.next
procedure delete(x : byte; var nhash : end
hash); end
var selesai : boolean; end
begin end;
selesai := true;
count := nhash(x); procedure hapus(x : byte; nhash : hash);
if nhash[count]^.isi = x then begin
begin if member(x, bil) then
current := nhash[count]; begin
nhash[count] := delete(x, bil);
nhash[count]^.next; writeln(data telah dihapus)
dispose(current) end else
end else writeln(data telah dihapus);
begin end;
VII.4. KOMPRESI
Kompresi adalah suatu metode penghematan penyimpanan file dalam suatu media
simpan. Dalam mengkompresi suatu file ada banyak metode-metode yang dapat
digunakan dan salah satu yang akan dibahas adalah Algoritma Huffman.
Algoritma Huffman dipakai untuk mengkonstruksi kode prefix yang optimal,
yang memiliki proses penggabungan yang berulang-ulang terhadap bobot dua item data
yang terendah. Misalnya w1 dan w2 dua buah data yang berbobot paling kecil diantara
w1, w2, w3, , wn maka akan dibentuk tree w1+w2, w3, w4, , wn sehingga w1+w2
akan membentuk subtree sebagai berikut :
W1 W2
Gambar 7.6. Pembentukan subtree pohon Huffman

Dengan cara yang sama untuk semua data dapat dibentuk sub-sub tree sampai akhirnya
membentuk sebuah pohon Huffman.
Contoh :
Tabel 7.6. Data pohon Huffman

Karakter Frekwensi
Total Bit
a 10 30
e 15 30
i 12 24
s 3 15
t 4 16
sp 13 26
nl 1 5
Langkah-langkah pembentukan pohon Huffman sebagai berikut :

1)
10 15 12 3 4 13 1
a e i s t sp nl
2) dipilih 2 buah elemen data yang terkecil yaitu s dan nl dengan jumlah 4 dengan
membentuk subtree T1
4
T1
10 15 12 4 13 3 1
a e i t sp s nl
3) Kemudian dua buah elemen data lainnya dibandingkan untuk membentuk subtree
berikutnya yaitu T1 dan t
8
T2
4 4
T1 t
10 15 12 13 3 1
a e i sp s nl

4) Demikian seterusnya sampai terbentuk pohon Huffman yang komplit
18
T3
8 10
T2 a
4 4
T1 t
15 12 13 3 1
e i sp s nl
5) Perhatikan bahwa e=15, I=12, sp=13, dan t3=18 maka yang digabung adalah I dan sp
18
T3
8 10
T2 a
4 4
25
T1 t
T4
15 12 13 3 1
e i sp s nl
6) Menggabung e dengan T3 sebagai berikut :

33
T5
15
18
T3 e
8 10
T2 a
4 4
25
T1 t
T4
12 13 3 1
i sp s nl

7) Akhirnya diperoleh bentuk komplit pohon Huffman sebagai berikut :
58
T4
0 1
33 25
T5 T4
0 1 0 1
15 12 13
18
T3 e i sp
0 1
8 10
T2 a
0 1
4 4
T1 t
0 1
3 1
s nl
Gambar 7.7. Proses pembentukan pohon Huffman
Syarat pemberian nilai digit pada cabang kiri bernilai 0 dan cabang kanan bernilai 1
Berdasarkan pohon Huffman yang terbentuk (Gambar 7.7) maka dapat dicatat coding
untuk masing-masing karakter, sebagai berikut :
Tabel 7.7. Kode Karakter

Karakter Code
a 001
e 01
i 10
s 00000
t 0001
sp 11
nl 00001
Kemudian fase untuk decoding dapat dibentuk seperti diperlihatkan pada tabel berikut ini
Tabel 7.8. Proses Decoding

indeks Parent
Char Bobot (ayah) Tipe
anak
0 a 10 9 1
1 e 15 11 1
2 i 12 10 0
3 s 3 7 0
4 t 4 8 1
5 sp 13 10 1
6 nl 1 7 1
7 T1 4 8 0
8 T2 8 9 0

9 T3 18 11 0
10 T4 25 12 1
11 T5 33 12 0
12 T6 58 0 -
Berikut implementasi algoritma dengan bahasa pemrograman pascal :

uses crt, printer, dos; begin
const N = 4096; F = 18; outbufptr := bufsize;
limit = 2; printfile;
nul = N; outbufptr := 0
bufsize =1024; end
inbufptr : word = bufsize; end;
inbufsize : word = bufsize;
outbufsize : word = 0; (* prosedur inisialisasi BST *)
outbufsize : word = 0; procedure inittree;
var infile, outfile : file; var i : word;
height, posmatch, lengthmatch, lengthend : begin
word; i := N +1;
textbuf : array [0..n + F 2] of byte; repeat
left, mom : array[0..n] of word; right[i] := nul;
right : array[0..n+256] of word; inc(i);
codebuf : array[0..16] of byte; until (i>N+256);
beof, press : boolean; i := 0;
h1, h2, m1, m2, s1, s2, c1, c2 : word; repeat
mom[i] := nul;
(* fungsi untuk membaca karakter *) inc(i);
function readchar : byte; until (i=n)
begin end;
readchar := 0;
if inbufptr >= inbufsize then (* prosedur menggeser posisi node keatas *)
begin prosedur shifted(me : word);
blockread(infile, inbuf, bufsize, inbufsize); var ancestor, grdmtr, mother, child, brother :
inbufptr := 0 word;
end; bexit : boolean;
if inbufsize = 0 then beof := true else begin
begin bexit := false;
beof := false; repeat
readchar := inbuf[inbufptr]; mother := mom[me];
inc(inbufptr); (* jika ibu bukan spesial node *)
end if mother <= nul then
end; begin
grdmtr := mom[mother];
(* prosedur menulis buffer ke file output *) (* jika ibu bukan spesial node *)
procedure printfile; if grdmtr <= nul then
var actual : word; begin
begin ancestor := mom[grdmtr];
blockwrite(outfile, outbuf, outbufptr, actual) (* jika aku anak kiri dari ibu *)
end; if left[mother] = me then
begin
(* prosedur menulis karakter ke buffer output *) (* jika ibu anak kiri dari nenek *)
procedure printchar(nchar : byte); if left[grdmtr] = mother then
begin begin
outbuf[outbufptr] := nchar; brother := right[mother];
inc(outbufptr); left[grdmtr] := brother;
if outbufptr >= bufsize then mom[brother] := grdmtr;
child := right[me]; end else
left[mother] := child; (* jika nenek spesial node *)
mom[child] := mother; begin
right[mother] := grdmtr; (* apakah aku merupakan anak kiri *)
right[me] := mother; if left[mother] = me then
mom[grdmtr] := mother; begin
mom[mother] := me child := right[me];
end else left[mother] := child;
(* ibu anak kanan dari nenek *) right[me] := mother
begin end else
child := left[me]; begin
right[grdmtr] := child; child := left[me];
mom[child] := grdmtr; right[mother] := child;
child := right[me]; left[me] := mother
left[mother] := child; end;
mom[child] := mother; right[grdmtr] := me;
left[me] := grdmtr; mom[child] := mother;
right[me] := mother; mom[me] := grdmtr;
mom[mother] := me; mom[mother] := child;
mom[grdmtr] := me bexit := true
end end
end else end else
(* aku anak kanan dari ibu *) bexit := true;
begin until bexit;
(* ibu anak kiri dari nenek *) end;
if left[grdmtr] = mother then
begin (* prosedur untuk menambah node baru *)
child := right[me]; procedure addnode(position : word0;
left[grdmtr] := child; var preposition, templen, child : word;
mom[child] := grdmtr; trigg : integer;
child := left[me]; bexit : boolean;
right[mother] := child; begin
mom[child] := mother; trigg := 1;
right[me] := grdmtr; lengthmatch := 0;
left[me] := mother; height := 0;
mom[mother] := me; preposition := textbuf[position] + n + 1;
mom[grdmtr] := me right[position] := nul;
end else left[position] := nul;
(* ibu anak kanan dari nenek *) bexit := false;
begin repeat
brother := left[mother]; inc(height);
right[grdmtr] := brother; if trigg > 0 then
mom[brother] := grdmtr; (* untuk node dikanan *)
child := left[me]; begin
right[mother] := child; if right[preposition] = nul then
mom[child] := mother; (* ditambah jika node sebelum kosong *)
left[mother] := grdmtr; begin
left[me] := mother; right[preposition] := position;
mom[mother] := me; mom[position] := preposition;
mom[grdmtr] := mother bexit := true
end end else
end; preposition := right[preposition]
if (ancestor > nul) or end else
(right[ancestor] = grdmtr) then (* tambah node di kiri *)
right[ancestor] := me begin
else left[ancestor] := me; if left[preposition] = nul then
mom[me] := ancestor (* tambah, jika node sebelumnya null *)

begin begin
left[preposition] := position; while right[descend] <> nul do
mom[position] := preposition; descend := right[descend];
bexit := true right[mom[descend]] :=
end else left[descend];
preposition := left[preposition] mom[left[descend]] :=
end; mom[descend];
if not bexit then left[descend] := left[me];
begin mom[left[me]] := descend;
templen := 1; child := descend
repeat end;
trigg := textbuf[position + templen] right[child] := right[me];
textbuf[preposition + templen]; mom[right[me]] := child
if trigg = 0 then inc(templen) end else child := right[me];
until (trigg <> 0) or (templen >= F); end else child := left[me];
if templen > lengthmatch then mom[child] := mother;
begin if right[mother] = me then
posmatch := preposition; right[mother] = child
lengthmatch := templen; else left[mother] := child;
if templen .= f then mom[me] := nul
begin end
mom[position] := mom[preposition]; end;
child := left[preposition];
left[position] := child; (* prosedur untuk mengkoding file *)
mom[child] := position; procedure encode;
child := right[preposition]; var temp, ptrcodebuf, cycleencode.
right[position] := child; Nchar, totread : byte;
mom[child] := position; ptrinsert, ptrencode : word;
(* jika preposisi anak kanan ibunya *) bexit : boolean;
if right[mom[preposition]] = begin
preposition then inittree; temp := 0;
right[mom[preposition]] := position codebuf[0] := 0; ptrcodebuf := 1;
else cycleencode := 1; ptrinsert := 0;
left[mom[preposition]] := position; ptrencode := N F; bexit := false;
mom[preposition] := nul; repeat
bexit := true nchar := readchar;
end; if not beof then
end; begin
end; textbuf[ptrencode + temp] := nchar;
until bexit; inc(temp)
if height >=30 then shifted(position) end;
end; until (temp >= f) or (beof);
if temp > 0 then
(* prosedur untuk menghapus node *) begin
procedure erasenode(me : word); totread := temp;
var mother, child, descend : word; addnode(ptrencode);
begin repeat
mother := mom[me]; if lengthmatch > totread then
if mother <> nul then lengthmatch := totread;
begin if lengthmatch <= limit then
if right[me] <> nul then begin
begin lengthmatch := 1;
child := left[me]; codebuf[0] := codebuf[0] or
if left[me] <> nul then cycleencode;
begin codebuf[ptrcodebuf] :=
descend := right[child]; textbuf[ptrencode];
if descend <> nul then inc(ptrcodebuf]

end else inc(temp)
begin until temp >= ptrcodebuf
codebuf[ptrcodebuf] := posmatch and end;
255; bexit := true
inc(ptrcodebuf) end
codebuf[ptrcodebuf] := until bexit
(posmatch and 65280) shr 4 + end
lengthmatch (limit + 1); end;
inc(ptrcodebuf)
end; (* prosedur mendekoding *)
cycleencode := cycleencode shl 1; procedure decode;
if cycleencode = 0 then var temp, headerbyte, nchar, cycledecode,
begin prefixbit : byte;
temp := 0; ptrtextbuf : word; bexit : boolean;
repeat begin
printchar(codebuf[temp]); cycledecode := 0; ptrtextbuf := N - F;
inc(temp) bexit := false;
until temp >= ptrcodebuf; repeat
ptrcodebuf := 1; cycleencode := 1; cycledecode := cycledecode shr 1;
codebuf[ 0] := 0 if cycledecode = then then
end; begin
temp := 0; lengthakhit := lengthmatch; nchar := readchar;
repeat if beof then
nchar := readchar; bexit := true else
if not beof then begin
begin cycledecode := 255;
erasenode(ptrinsert); headerbyte := nchar
textbuf[ptrinsert] := nchar; end
if ptrinsert < (F-1) then end
textbuf[ptrinsert + N] := nchar; if not bexit then
inc(ptrinsert); begin
ptrinsert := ptrinsert and (N-1); prefixbit := headerbyte and 1;
inc(ptrencode); headerbyte := headerbyte shr 1;
ptrencode := ptrencode and (N-1); if prefixbit = 1 then
addnode(ptrencode); begin
inc(temp) nchar := readchar;
end if beof then bexit := true else
until (temp >= lengthend) or (beof); begin
while temp < lengthend do textbuf[ptrtextbuf] := nchar;
begin inc(ptrtextbuf);
inc(temp); ptrtextbuf := ptrtextbuf and (N-1);
erasenode(ptrinsert); printchar(nchar)
inc(ptrinsert); end
ptrinsert := ptrinsert and (N-1); end else
inc(ptrencode); begin
ptrencode := ptrencode and (N-1); nchar := readchar;
dec(totread); if beof() then bexit := true else
if totread > 0 then begin
addnode(ptrencode0 temp := nchar;
end; nchar := readchar;
if totread <= 0 then if beof then bexit := true else
begin begin
if ptrcodebuf >= 1 then posmatch := nchar shr 4;
begin posmatch := (posmatch shl 8 )
temp := 0; or temp;
repeat lengthmatch := nchar and 15) +
printchar(codebuf[temp]); limit = 1;

repeat writeln(Waktu proses =
posmatch := posmatch and ,processtime,Detik);
(N-1); end;
nchar := texbuf[posmatch];
textbuf [ptrtextbuf] := nchar; (* program utama *)
inc(ptrtextbuf); begin
ptrtextbuf := ptrtextbuf and clrscr;
(N-1); if (paramcount < 2) or (paramcount > 4) then
printchar(nchar); begin
inc(posmatch); writeln( Sintak : , paramstr(0),
dec(lengthmatch); Input file outfile[dekompresi]);
until lengthmatch = 0 halt;
end end;
end if paramstr(1) = paramstr(2) then
end begin
end writeln(Nama file harus beda);
until bexit halt
end; end;
assign(infile, paramstr(1));
procedure kompresi; {$I--}
begin reset(infile, 1);
inbufptr := bufsize; inbufsize := bufsize; if ioresult <> 0 then
outbufptr := 0; height := 0; begin
posmatch := 0; lengthmatch := 0; writeln(Salah input file ,paramstr(1));
lengthend := 0; halt
fillchar(textbuf, sizeof(textbuf),0); end;
fillchar(left, sizeof(left),0); assign(outfile, paramstr(2));
fillchar(mom, sizeof(mom),0); rewrite(outfile, 1);
fillchar(right, sizeof(right),0); {$I+}
fillchar(codebuf, sizeof(codebuf),0); if ioresult <> 0 then
encode; begin
printfile writeln(Salah output file ,paramstr(2));
end; halt
end;
procedure dekompresi; gettime(h1, m1, s1, c10;
begin if paramcount <> 3 then
inbufptr := bufsize; inbufsize := bufsize; begin
outbufptr := 0; press := true;
fillchar(textbuf, sizeof(textbuf),0); kompresi
decode; end else
printfile begin
end; press := false;
dekompresi
procedure statistik; end;
var cprocess : string[10]; gettime(h2, m2, s2, c2);
processtime : word; statistik;
begin close(outfile);
processtime := (h2 * 3600 + m2 * 60 + s2) close(infile);
(h1 * 3600 + m1 * 60 + s1); readln;
if press then end.
cprocess := Kompresi
else cprocess := Dekompresi;
writeln(Proses = , cprocess);
writeln(Input : , paramstr(1):11, :10,
filesize(infile));
writeln(output : , paramstr(2):11, :10,
filesize(outfile));

BAB VIII
GRAPH
VIII.1. DEFENISI GRAPH
Suatu graph G=(V,E) berisi suatu himpunan vertex dan himpunan edge E, masing-
masing edge adalah sepasang (v,w) dimana v,w V. Vertex sering disebut dengan node dan
edge disebut dengan arc.
Beberapa himpunan vertex yang terhubung dengan himpunan edge akan membentuk
graph. Jika sepasang edge diorder dan graph itu disebut dengan graph directed (digraph).
Dalam digraph bahwa vertex w adalah adjacent (bersinggungan) terhadap vertex v jika dan
hanya jika (iff) (v,w) E. Kadang-kadang edge memiliki komponen ketiga disebut weight
(bobot) atau cost (ongkos).
Misalkan V = { v0, v1, v2, v3, v4, v5, v6 } dengan 12 edge diperoleh :
(v0, v1, 2), (v0, v3, 1), (v0, v1, 3), (v1, v4, 10)
E = (v3, v4, 2), (v3, v6, 4), (v3, v5, 8), (v3, v2, 2)
(v2, v0, 4), (v3, v4, 2),(v4, v6, 6), (v6, v5, 1)
Sehingga diperoleh graph terhubung (digraph) sebagai berikut :

V0
2 V1
10
4 1 3 Indegree v3 = 2 ={v0, v1}
2 2
Outdegree v3 = 4
V2 V3 V4 = {v2, v4, v5, v6}
8 4
5 6
V5 V6
1
Gambar 8.1. Graph berarah
Berdasarkan gambar diatas bahwa vertex yang adjacent terhadap v3 adalah v2, v4, v5,
v6 dan |V| = 7 dan |E| = 12 dan |S| merepresentasikan size himpunan S
Suatu path dalam graph adalah sikuensi dari vertex-vertex : w1, w2, , wn
sedemikian sehingga (wi, wi+1) E untuk 1<= i < n
Length (panjang) dari suatu path adalah sejumlah node pada suatu path yaitu n-1, dan
sering disebut dengan unweigted path length yaitu sejumlah biaya pada edge dalam path.
Misalnya :
Path v0 sampai v5 adalah v0, v3, v5. Panjang path adalah 2 edge dan weighted path
length adalah 9 yang kebetulan path terpendek antara v0 dan v5.
Simple path (path sederhana) adalah path yang mana semua vertex-vertex jelas,
kecuali awal dan akhir boleh sama.
Cycle dalam suatu digraph adalah suatu path dengan panjang paling sedikit 1
sedemikian sehingga w1 = wn; Suatu directed acycle graph (DAG) kadang-kadang
didasarkan pada suatu penggabungan, dengan asumsi bahwa dalam directed graph (digraph
= graph berarah) tidak boleh ada cycle.

VIII.2. SHORTEST PATH PROBLEM

Shortest path problem (SPP) merupakan proses menemukan path terpendek (diukur
dari banyaknya edge) dari vertex ditandai dengan S terhadap semua vertex.
Contoh 1: 581
A
215
A B C D E
307 353
A - 215 581 307 353 C 420 B
B 215 - 420 181 413 921
C 581 420 - 162 921 162 413
D 307 181 162 - 161 D
181
E
E 353 413 921 161 - 161
Gambar 8.2. Graph berarah SPP
SPP dapat diselesaikan dengan Algoritma Djikstra pada graph adjacent diats dari C ke E
(undirected = tidak berarah).
{C} : {A, B, D, E } C A = 581

C B = 420 Minimum {C,D} = 162
C D = 162
C E = 921
{C,D} : {A, B, C}
A = min {CA, CDA} = {581, 469}
B = min {CB, CDB} = {420, 343} Minimum {C,D,E} = 323
C = min {CE, CDE} = {921, 323}
Maka path terpendek dengan Algoritma Djikstra adalah {C,D.E} = 323 (total jarak}
Contoh 2 :
30
B C
50 200
40 5
A 75 D G
20 80
100
40
E F
60
Gambar 8.3. Graph berarah SPP lain
Cari SPP dari satu vertex ke seluruh vertex lain dengan Algoritma Djikstra,
A : inisialisasi A=0 yang lain ke n

B : semula n
dari A : 0 + 50 = 50 ; berarti terpendek ke AB = 50 path terpendek
E : semula n
adalah AB
dari A : 0 = 100 ; berarti terpendek ke AE = 100
C : semula n
dari B : 50 + 30 = 80 ; berari terpendek ke ABC = 80
D : semula n
path terpendek
dari B : 50 + 40 = 90 ; berarti terpendek ke ABD = 90
adalah ABC
F : semula n
dari E : 100+60 = 160; berarti terpendek ke AEF=160
D : semula 90 dari B
dari C = 80 + 5 = 85
F : semula 160 dari E tetap melalui E
dari D : 85 + 80 = 165 yaitu AEF = 160
G : semula n
dari C = 80 + 200 = 280 melalui F
dari F = 160 + 40 = 200 yaitu AEFG = 200
jadi jalur terpendek dari :
A B = 50 AB
A C = 80 ABC
A D = 85 ABCD
A E = 100 AE
A F = 160 AEF
A G = 200 AEFG
VIII.3. ALGORITMA MINIMAL SPANNING TREE

Minimal spanning tree (MST) sering digunakan untuk menyelesaikan suatu proyek,
dimana pada algoritma ini mengenal dua metode yaitu PRIMS dan Kruskal.
PRIMS adalah proses pengunjungan semua vertex yang dimulai dari salah satu
vertex, dimana kunjungan hanya boleh dilakukan sekali terhadap satu node, sedangkan
KRUSKAL adalah proses kunjungan dengan prims, hanya syaratnya tidak boleh siklus,
dengan memulai dari edge terpendek kemudian dilanjutkan ke edge terpendek kedua dan
seterusnya sampai semua vertex/node terkunjungi.
Contoh :
K L M N P
K - 215 581 307 353
L 215 - 420 181 413
M 581 420 - 162 921
N 307 181 162 - 161
P 353 413 921 161 -

a. PRIMS :
K kunjungi = true; evaluasi K L = 215
K M = 581
Minimum = 215
K N = 307
K P = 353
L kunjungi = true; evaluasi K M = 581
K N = 307
K P = 353
L N = 181 Minimum = 181
L P = 413
L M = 420
N kunjungi = true; evaluasi K M = 581
K N = 307
K P = 353
N M = 162 Minimum = 161
N P = 161
L P = 413
L M = 420
P kunjungi = true; evaluasi K M = 581
K N = 307
K P = 353
L P = 413 Minimum = 162
L M = 420
N M = 162
P M = 921
M kunjungi = true; evaluasi Stop karena semua vertex sudah dikunjungi (true)
maka total MST PRIMS = 215 + 181 + 161 + 162 = 719
dan Himpunan pencarian adalah = {(K,L), (L,N), (N,P), (N,M)}
maka bentuk tree dan graph dari proses MST ini sebagai berikut :
K
420
215
M M
L 581 413
181 921
M
N 353 162
307
M M
161
P M
a. bentuk pohon PRIMS b. Graph PRIMS
Gambar 8.4. Algoritma MST PRIMS

b. KRUSKAL
Dari gambar 8.4.b. menunjukkan bahwa : K - L L K
(N P) = 161 { (N,P) }
(N M) = 162 { (N,P), (N,M) }
(N L) = 181 { (N,P), (N,M), (N,L) }
(L K) = 215 { (N,P), (N,M), (N,L), (L,K) }
Iterasi stop, karena setiap penambahan edge akan mengakibatkan proses penelusuran
(trace) membentuk suatu siklus (cycle).
Jadi total MST Kruskal = (N,P) + (N,M) + (N,L) + (L,K)

= 161 + 162 + 181 + 215 = 719
Tree yang terbentuk sebagai berikut :
N N N
Gambar 8.5. Algoritma MST Kruskal

KEPUSTAKAAN
1. Data structures and problem solving using java; Mark Allen Weiss ; Addison Wesley ;
1998
2. An Introduction to Data Structures and Algorithm with Java; Gleen Rowe; Prentice
Hall International Edition ; 1998
3. Data Structures and Program Design ; Robert L. Kruse ; Prentice Hall of India Privated
Limited ; 1991
4. Data Structures, Algorithms and Program Style Using C ; James F. Korst; Leonard J.
Garrett ; PWS-Kent Publishing Company ; 1988
5. Data structures, Theory and Problem ; Seymour Lipschutz ; McGraw Hill Book
Company ; 1986
6. Algorithms + Data Structures = Program ; Niklaus Wirth ; Prentice Hall of India
Private Limited; 1991
7. Computer Algorithms, Introduction to Design and Analysis, Second Edition, Sara
Baase ; Addition Wesley Publishing Company ; 1988
8. Problem Solving and Structured Programming in Pascal, Second Edition, Iliot B.
Koffman ; Addition Wesley Publishing Company ; 1985
9. Turbo Pascal , Reference Manual; Scotts Valley ; Borland International ; 1985
10. Turbo Pascal , Jilid 1; Jogianto H.M. ; Andi Offset Yogyakarta ; 1989
11. Turbo Pascal , Jilid 2; Jogianto H.M. ; Andi Offset Yogyakarta ; 1989
12. Dasar-Dasar Pemrograman Pascal, Teori dan Program Terapan ; Insap P. Santoso, Ir,
M.Sc ; Andi Offset Yogyakarta ; 1987
13. Belajar Sendiri Pemrograman Dengan Turbo Pascal 7.0 ; Ediman Lukito ; Elex Media
Komputindo ; 1993
14. Struktur Data (transparansi) ; Universitas Bina Nusantara ; Jakarta ; 2001

Struktur Data Materi Dimas PDF

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Struktur Data Materi Dimas PDF

Diunggah oleh

Hak Cipta:

Format Tersedia

Diktat : KBMI3305 - Struktur Data Hal : 16

Model data dapat dipandang dengan 2 cara yaitu :

Struktur data dibagi atas 3 tingkatan struktur yaitu :

Struktur data abstrak dibagi menjadi beberapa bagian yaitu :

Struktur data non abstrak dikelompokkan dalam beberapa bagian yaitu :

Tipe data abstrak (TDA)

SINAR SINURAT, ST STMIK BUDIDARMA

TDA dapat dibagi menjadi :

I.2. KONSEP ARRAY

SINAR SINURAT, ST STMIK BUDIDARMA

Gambar 1.1. Bentuk list

Jenis-jenis linked list antara lain :

2. List yang mencatat dari elemen pertama sampai terakhir

4. Double linked list

tail prev prev tail

5. Binary list head head

6. Multiple linked list

Gambar 1.2. Jenis-jenis linked list

SINAR SINURAT, ST STMIK BUDIDARMA

NIM Nama Alamat Umur Jurusan Hobby

Gambar 1.3. Bentuk pohon

I.5. KONSEP STACK

Gambar 1.4. Bentuk Tumpukan

I.6. KONSEP QUEUE

SINAR SINURAT, ST STMIK BUDIDARMA

Gambar 1.5. Bentuk Antrian

1.7. KONSEP GRAPH

SINAR SINURAT, ST STMIK BUDIDARMA

II.1. FUNGSI DAN NOTASI MATEMATIKA

FUNGSI FLOOR DAN CEILING

FLOOR X ( X ) adalah pembulatan nilai X ke bawah dan diambil desimal terbesar.

FUNGSI SISA (MODULUS)

FUNGSI INTEGER dan ABSOLUTE

SINAR SINURAT, ST STMIK BUDIDARMA

b (a,b) terdapat 6 buah pasangan n = 3 dan r = 2 maka

II.2. TIPE DATA

Jenis-jenis tipe data sebagai berikut :

Tabel 2.1. Tipe data integer

Tabel 2.2. Tipe data real

II.3. NOTASI ALGORITMA

Assign ekspressi adalah = atau := atau

Assign kondisi adalah == atau =

Pembanding adalah case of atau if then [else] .

If (a == b) then ekspressi atau if (a ==b) then ekspressi1 else ekspressi 2

Operator adalah + atau - atau / atau *

a*b atau a / b atau a + b atau a-b

for ( a < b) do ekspressi atau while (a < b) do ekspressi

SINAR SINURAT, ST STMIK BUDIDARMA

Tipe Array Array [ Tipe Indeks ] of Tipe

Tipe indeks Tipe Ordinal

Gambar 3.1. Diagram proses Array

Pencapaian / akses data dibagi 2 :

Akses berdasarkan indeks dibedakan :

Parameter array adalah berdasarkan :

SINAR SINURAT, ST STMIK BUDIDARMA

Gambar 3.2. Konsep Array dalam memory

ARRAY MAPPING FUNCTION (AMF)

Rumus dalam AMF :

Rumus perhitungan besarnya penggunaan memory (M) :

Contoh deklarasi program pascal:

Jika diketahui : B = 500, L = 2

SINAR SINURAT, ST STMIK BUDIDARMA

Besarnya memory yang dibutuhkan adalah :