Struktur Data materi dimas (1)
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 :
5. Pointer, dan lain-lain
Tipe data abstrak (TDA) Dapat dipadang sebagai model matematika dan sekumpulan operasi yang didefenisikan terhadap suatu model.
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 : A 1 ,A 2 ,A 3 , ..., A n 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 (U 1 =U 2 ), 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] = C 0 +C 1 x (i x (i-1)) + C 2 x j, dimana C 0 = B, C 1 = L/2 , C 2 =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
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
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 :
FUNGSI SISA (MODULUS) Misalkan X adalah nilai integer dan M adalah positif integer maka nilainya adalah sisa pembagian. Bentuknya adalah X (mod) M. Contoh :
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 :
abs |-15| = 15
abs |-3.33| = 3.33
abs|4.44| = 4.44
FUNGSI SUM ( Σ) Proses berdasarkan sikuensi a 1 ,a 2 ,a 3 , ... , a n maka a 1 +a 2 +a 3 + ... + a n maka bentuknya adalah :
Sum ( Σ) = Σ a i
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 :
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)
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
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
Digit Single
(byte)
7–8 Double
4 1.5 x 10E-45 … 3.4 x 10E38
15 – 16 Extended
8 5.0 x 10E-324 … 1.7 x 10E308
19 – 20 Comp
10 1.9 x 10E-4951 … 1.1 x 10E4932
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 X ←2
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 Ordinal
Tipe indeks
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 (I k ) dan Lower bound (U k )
I k adalah nilai indeks yang terkecil sedangkan U k adalah nilai indeks yang terbesar. Contoh : int s[10]; maka I k =0,L k =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 C 0 (lokas dari komponen dengan indeks 0) dalam AMF.
Rumus dalam AMF :
Address (S[I 1 ][I 2 ] … [I d ]) = C 0 + C 1 xI 1 + C 2 xI 2 + …+C n xi d ;
dimana C d =L
C t-1 = (U t – I t + 1) x C d x C t ; dan i<t ≤d;
C 0 = B – (C 1 xI 1 ) - … - (C d xI d )
Rumus perhitungan besarnya penggunaan memory (M) :
M=Lx(U 1 –I 1 + 1) x … x (C d –I d + 1)
Contoh deklarasi program pascal: Var a : array [0..4] of integer;
atau int S[5];
Jika diketahui : B = 500, L = 2 Maka I 1 = 0, U 1 =4
C 1 = L=2
C 0 = B + (C 1 xI 1 )
= 500 + (2 x 0) = 500 Catatan : dalam bahasa C bahwa indek selalu dimulai dari 0, maka C 0 = B sedangkan dalam bahasa Pascal dideklarasikan sendiri oleh programmer-nya. jadi address dalam pemrograman bahasa C:
S[I] = C 0 +C 1 xI 1 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=Lx(U 1 –I 1 + 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 : elemen 1 , elemen 2 , ...., elemen n .
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.
Perhatikan diagram berikut pada gambar 4.1.
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 :
Agus
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
Agus 2 Budi
Gambar 4.4. Deskripsi linked list
Misalkan statement r:=q ; p:=q; q:=r maka bentuk linked listnya adalah :
Agus 3 Budi 5
Sehingga : R Agus 3 P
Budi
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
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
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 Cerry 4
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
Diktat : KBMI3305 - Struktur Data
// 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
Ptr = ptr^.next
IV.2.2. ALGORITMA SISIP DATA DALAM LINKED LIST
Head
Type node = ^data Data = record New(P) P
New(Q)
New(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
New (Q)
Head
Read (q^.nilai) ……………(3) Q^.next = nil
(2) P = Head
New (Q ) P
If p = nil then
else
Tail = Q
(3) Read (Q^.data Q^.Next = P ………. (1) P = Q …………….. (2)
a. Sisip list baru di awal linked list
Diktat : KBMI3305 - Struktur Data
B. SISIP TENGAH
Head
New (Q)
Read (Q^.nilai) , Q^.next = nil
D E P = Head While (p<> nil)
(2) New (Q
If p^.nilai = ‘B’ then
C Q^.Next = P^.Next ……. (1)
(3) Read (Q^.data P^.Next = Q ………….. (2)
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) New (Q ) P
Endwhile P = 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
Q = P …………………. (1) (2)
P = Q^.Next ………….. (2) Dispose (Q)
a. Hapus list awal dari linked list Endif
B. HAPUS LIST TENGAH
P = Head Q = P^.Next ………………. (1)
Head
P^.Next = P^.Next^.Next ……(2) Q^.next = nil
Dispose (Q)
Catatan :
Untuk menentukan posisi data yang akan dihapus
b. Hapus list awal dari linked list
maka dapat dibuat suatu pembanding
Diktat : KBMI3305 - Struktur Data
C. HAPUS LIST AKHIR
P = Head
If (P^.next = nil) then
Head
Last = P
P = Nil While (Last^.next <> Nil) do
P = Last
Last = Last^.Next
b. Hapus list awal dari linked list
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’];
Diktat : KBMI3305 - Struktur Data
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)
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
Diktat : KBMI3305 - Struktur Data
Procedure baca_list;
Cacah := 0;
Var bantu : simpul;
Head := nil;
i : integer;
Tail := nil;
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’
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
Diktat : KBMI3305 - Struktur Data 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
Diktat : KBMI3305 - Struktur Data
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.
Tail
Head
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. Perhatikan diagram berikut pada gambar 4.14.
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
Diktat : KBMI3305 - Struktur Data
Demikian juga proses penyisipan node baru pada posisi tertentu dalam linked list 2 arah. Perhatikan urutan proses pada gambar 4.16. berikut :
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;
Diktat : KBMI3305 - Struktur Data
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
Diktat : KBMI3305 - Struktur Data
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)
6 * , / , div , mod
Ekponensial / pemangkatan
5 + , - (binary)
Perkalian, pembagian, sisa bagi
Penjumlahan, Pengurangan
Sama dengan, tidak sama dengan, lebih kecil,
3 lebih besar, Lebih kecil atau sama dengan, Lebih besar atau sama dengan
Dan, Atau
Sama dengan
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
Diktat : KBMI3305 - Struktur Data
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
yang discan
Stack Ekspresi postfix Keterangan
( (+ (+( (+( (+(* (+(* (+(- (+(-( (+(-( (+(-(/ (+(-(/ (+(-(/^ (+(-(/^ (+(- (+(-* (+(-* (+ (+* (+*
AB AB ABC ABC* ABC* ABC*D ABC*D ABC*DE ABC*DE ABC*DEF ABC*DEF^/ ABC*DEF^/ ABC*DEF^/G ABC*DEF^/G*- ABC*DEF^/G*- ABC*DEF^/G*-H ABC*DEF^/G*-H*+
Baris 13 : Tanda ^ dipop karena sudah ketemu pasangan ( dan )
Baris 16 : Pasangan ( dan ) sudah ketemu maka dipop semua operator yang ada diantara ( dan ) Baris 19 : sudah ketemu pasangan ( 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.
Diktat : KBMI3305 - Struktur Data
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 !
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 :
Diktat : KBMI3305 - Struktur Data
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
Diktat : KBMI3305 - Struktur Data
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
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
If emptystack(top) then End;
Next : stackpointer;
Writeln(‘Stack kosong’) else Var top : stackpointer;
Begin
Nextchar : char; Item := top^.data; Top := top^.next;
Function emptystack(top : stackpointer) :
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.
Diktat : KBMI3305 - Struktur Data
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
Hapus list
Sisip list
(3) Gambar 5.3. Diagram Antrian Berikut akan disajikan bagaimana proses enqueue dan dequeue dalam queue seperti
diagram dibawah ini :
Emptyqueue() back Size = 0
Front back
enqueue(a)
Size = 1
front
back enqueue(b)
Size = 2
Front Gambar 5.4. Proses enqueue
Diktat : KBMI3305 - Struktur Data
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;
Diktat : KBMI3305 - Struktur Data
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 :
Level 0
b Level 1 c d e
h Level 2 i j
Level 3
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 :
Diktat : KBMI3305 - Struktur Data
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 :
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;
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;
Diktat : KBMI3305 - Struktur Data
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:‘);
readln(x); end;
rf : ref;
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
Diktat : KBMI3305 - Struktur Data
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)
Diktat : KBMI3305 - Struktur Data
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 :
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.
Diktat : KBMI3305 - Struktur Data
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
Gambar 6.6. Probe dalam pohon
Diktat : KBMI3305 - Struktur Data