Struktur Data

Struktur Data
Yuda Syahidin,ST
[email:yudasy@yahoo.com]
[http://www.yudasy.web.id] Page 1 of 42
MATERI 1
PENGANTAR STRUKTUR DATA
Tujuan :
• Mengetahui dan memahami tentang Struktur Data
• Memahami mengenai tipe data standard
LATAR BELAKANG
Untuk menyelesaikan suatu permasalahan dengan program komputer, banyak
tahapan yang harus dilalui. Tahapan dimulai dari penentuan dan spesifikasi
masalah, perancangan solusi, implementasi, testing, dokumentasi dan evaluasi.
Umtuk melakukan perancangan solusi yang baik, perancang harus melakukan :
- Perancangan Struktur Data
- Perancangan Algoritma
Kedua perancangan di atas akan memudahkan pelaksanaan tahapan-tahapan
selanjutnya pada penyelesaian masalah dengan komputer tersebut.
Struktur data menjadi dasar dalam langkah awal perancangan program
Algoritma + Struktur Data = Program
MANFAAT
Pemakaian struktur data yang tepat di dalam proses pemrograman akan
menghasilkan :
Algoritma yang lebih jelas dan tepat, sehingga menjadikan program secara
keseluruhan lebih efisien dan sederhana.
Membuat program lebih ringkas, lebih bersih, lebih elegan, lebih mudah dan
lebih mampu berkinerja tinggi (karena efisien dalam penggunaan memori
dan waktu)
Program berjalan membutuhkan waktu beberapa detik, di mana struktur
yang lain mungkin akan membutuhkan ribuan detik.
PENGERTIAN
Struktur data adalah cara menyimpan atau merepresentasikan data di dalam
komputer agar bisa dipakai secara efisien
Data adalah representasi dari fakta dunia nyata
Fakta atau keterangan tentang kenyataan yang disimpan, direkam atau
direpresentasikan dalam bentuk tulisan, suara, gambar, sinyal atau simbol
TIPE DATA STANDAR
Tipe data standar merupakan tipe data yang tersedia pada kebanyakan
komputer sebagai built-in features.
Tipe data standar yaitu :
- Integer
- Real

Struktur Data
Yuda Syahidin,ST
- Boolean
- Char
BAHASAN STRUKTUR DATA
Struktur Data, meliputi :
a. Struktur data dasar/sederhana, yaitu array, record/struct dan himpunan
b. Struktur data lanjut/majemuk, yang terdiri dari :
- Linier : Stack, Queue, serta List dan Multilist
- Non Linier : Pohon Biner dan Graph
RECORD
Record adalah kumpulan data, Record terdiri dari elemen yang memiliki tipe data
yang berbeda dengan yang lain.
Bentuk umum deklarasi record adalah:
Type pengenal_variabel = record
Elemen1 : tipedata1
Elemen2 : tipedata2
.
.
.
Elemenn : tipedatan
STRING
Salah satu tipe data yang merupakan representasi array 1 dimensi adalah
String.
Jumlah karakter yang dapat ditampung oleh data bertipe string adalah antara 1
sampai dengan 255.
Pendeklarasian string :
Type
Teks =string [20];
Var
Kalimat : Teks;
Operasi String :
Operator – operator yang digunakan dalam operasi string adalah :
- Operator + , operator ini bertuuan untuk penggabungan suatu string
dengan string lain sehingga membentuk suatu string baru.
- Operator =, <>, <, >, <=, >= , operator – operator ini bertujuan untuk
membandingkan suatu string dengan string lainnya. Hasil pembandingan
berupa nilai boolean True atau false.
Prosedur untuk operasi string :
1. Delete
Bentuk deklarasi : Delete (Var st : string; n : integer; jum : integer)
Tujuan : untuk menghapus karakter yang ada pada string st, dimulai dari posisi
ke

Struktur Data
Yuda Syahidin,ST
– n, sebanyak jum karakter.
2. Insert
Bentuk deklarasi : Insert (obyek : string; Var Target : string; n : integer);
Tujuan : untuk menyisipkan string obyek ke string Target. Posisi penyisipan
yaitu pada indeks ke- n dari string Target.
3. Str
Bentuk deklarasi : STR (x [ : m [ : n ] ]; Var st : string)
Tujuan : prosedur ini digunakan untuk mengkonversi nilai x (bertipe real atau
integer) menjadi string. String hasil diletakkan pada st.
Fungsi untuk operasi string :
1. Copy
Bentuk deklarasi : Copy (st : string; n : integer; jum : integer) : string.
Tujuan : hasilnya berupa deretan karakter sebanyak jum, mulai karakter ke – n
dari string st.
2. Concat
Bentuk deklarasi : Concat ( s1[ , s2, s3, …, sn] ) : string.
Tujuan : fungsi ini menghasilkan keluaran berupa string yang merupakan
gabungan dari semua string argumennya.
3. Length
Bentuk deklarasi : Length ( st : string ) : integer.
Tujuan : fungsi ini menghasilkan panjang dari string st.
4. UpCase
Bentuk deklarasi : Upcase (ch : char ) : char;
Tujuan : fungsi ini menghasilkan huruf kapital dari ch.

Struktur Data
Yuda Syahidin,ST
MATERI 2
ARRAY
Tujuan:
• Mengetahui dan memahami struktur data statis
• Memahami operasi-operasi array
Array adalah sekumpulan memori untuk suatu nama yang memiliki elemen-
elemen data yang sejenis. Sifat-sifat array adalah sebagai berikut :
- Mengacu sekumpulan elemen melalui indeks.
- Elemen bertipe sama.
- Disimpan secara berurutan di memori.
- Ukuran tetap, harus dipesan terlebih dahulu.
Representasi array dibagi menjadi dua, yaitu :
1. Representasi array 1 dimensi, contoh : string.
A[1] A[2] ………………………… A[N]
2. Representasi array 2 dimensi, contoh : matriks.
A[1,1] A[1,2] A[1,N]
A[1,1] A[1,N]
A[2,1] A[2,N]
A[N,1] A[N,N]
Pendeklarasian array di Pascal :
- Untuk array 1 dimensi :
Const
IdxAwal = 1;
IdxAkhir = 100;
{Pendeklarasian pada bagian type}
Type
TipeInfo = …;
TabInfo = Array [IdxAwal .. IdxAkhir] of TipeInfo;
{Pendeklarasian pada bagian variabel}
Var
<identifikasi_variabel> : TabInfo;
Kategori operasi-operasi dasar terhadap tabel array :
1. Traversal
2. Searching
3. Sorting

Struktur Data
Yuda Syahidin,ST
Operasi Traversal terhadap tabel array :
Tabel integer didefinisikan seperti dibawah ini :
Const
IdxMin = 1; {batas bawah}
IdxMax = 10; {batas atas}
Type
TipeElm = Integer; {type terdefinisi,misal integer}
TabInt = Array [IdxMin .. IdxMax] of TipeElm;
Var
TInt = TabInt; {tabel integer}
Skema traversal :
Pemrosesan traversal yaitu mengolah seluruh elemen tabel secara
sistematik.
Skema :
Procedure ProsesTraversal (Var TI:TabInt);
Var
i:integer;
Begin
Inisialisasi; {prosedur persiapan sebelum pemrosesan}
For i:=IdxMin to IdxMax do
Begin
Proses ( TI [ i ] ); {proses terhadap elemen saat itu}
End;
Terminasi; {prosedur aksi setelah pemrosesan selesai}
End;
Contoh penggunaan skema :
- Prosedur memasukkan nilai seluruh elemen tabel.
Procedure InputTabInt (Var TI : TabInt);
Var
i : Integer;
Begin
For i := IdxMin to IdxMax do
Begin
Write (‘Elemen ke-‘,i);
Readln ( TI[ i ] );
End;
End;
- Prosedur menuliskan seluruh nilai elemen tabel ke layar.
Procedure OutputTabInt ( TI : TabInt);
Var
i: Integer;
Begin
For i := IdxMin to IdxMax do
Begin
Write (‘Elemen ke-‘,i,’ = ‘);
Writeln ( TI [ i ] );
End;

Struktur Data
Yuda Syahidin,ST
End;
MATRIKS
Merupakan array 2 dimensi, setiap elemen Matriks diidentifikasi oleh nama, indeks
baris dan indeks kolom.
1
2
↓
N1
1 2 → N2
Pendeklarasian Matriks (array 2 dimensi) :
Const
Idxawal = 1;
Idxakhir = 100;
Type
TipeInfo = …;
TabInfo = Array [ Idxawal .. Idxakhir, Idxawal .. Idxakhir] of TipeInfo;
Var
<identifikasi_variabel> : TabInfo;
Proses – proses/operasi terhadap Matriks :
1. Pengisian elemen matriks dari fil
2. Pengisian elemen matriks khusus dengan assignment
3. Penulisan elemen matriks
4. Penjumlahan matriks
5. Perkalian matriks
Algoritma-algoritma Operasi Matriks :
1. Pengisian elemen matriks dari fil
Read N1, N2 {N1 : jumlah baris, N2 : jumlah kolom}
I ← 1
While I <= N1 do
J ← 1
While J <= N2 do
Read M [I,J]
J ← J+1
EndWhile
I ← I+1
EndWhile
2. Pengisian elemen matriks khusus dengan assignment
a. Matriks N1 x N2 yang semua elemennya 1 :
I ← 1
While I <= N1 do
J ← 1
While J <= N2 do

Struktur Data
Yuda Syahidin,ST
M [I,J] ← 1
J ← J+1
EndWhile
I ← I+1
EndWhile
b. Matriks identitas ordo N
Read N
I ← 1
While I <= N do
J ← 1
While J <= N do
If I = J then
M[I,J] ← 1
Else
M[I,J] ← 0
Endif
J ← J+1
EndWhile
I ← I+1
EndWhile
3. Penulisan elemen matriks
I ← 1
While I <= N1 do
J ← 1
While J <= N2 do
Write M[I,J]
J ← J+1
EndWhile
I ← I+1
EndWhile
4. Penjumlahan matriks
I ← 1
While I <= N1 do
J ← 1
While J <= N2 do
C[I,J] ← A[I,J] + B[I,J]
J ← J+1
EndWhile
I ← I+1
EndWhile
5. Perkalian matriks
I ← 1
While I <= N1 do {N1 = baris Matriks A}
J ← 1
While J <= N2 do {N2 = baris Matriks B}
C[I,J] ← 0
K ← 1

Struktur Data
Yuda Syahidin,ST
While K <= N do {N = kolom matriks A = baris matriks B}
C[I,J] ← C[(I,J] + A[I,K] * B[K,J]
K ← K + 1
EndWhile
J ← J+1
EndWhile
I ← I + 1
EndWhile
Latihan :
1. Buat Algoritma dengan menggunakan Struktur Data Array untuk Matrik
dalam pencarian elemen tertentu didalam matrik!
Algoritma Global:
- Misalkan elemen x yang akan dicari
- Bila x ditemukan, maka keluaran yang diinginkan adalah indeks baris dan
indeks kolomnya. Bila x tidak ditemukan di dalam matriks, maka indeks
baris dan indeks kolom yang dihasilkan masing-masing bernilai -1
2. Buat Algoritma dengan menggunakan Struktur Data Array untuk Matrik untuk
membuat Matrik Transpose!
3. Buat Algoritma dengan menggunakan Struktur Data Array untuk Matrik
dalam mencetak elemen diagonal matrik!

Struktur Data
Yuda Syahidin,ST
MATERI 3
STRUKTUR DATA DINAMIS ( POINTER )
Tujuan:
• Mengetahui dan memahami struktur data dinamis
• Memahami operasi-operasi dasar dari Linked List
Pointer adalah variabel yang berisi alamat dari suatu lokasi struktur data.
Pointer digunakan untuk menyatakan secara eksplisit alamat tersebut pada waktu
dilakukan pengoperasiannya. Manipulasi dapat dilakukan pada alamat maupun
struktur data tersebut.
Pada implementasinya, pernyataan eksplisit ini diperlukan karena struktur
data itu belum tentu terletak pada segmen data yang sama dengan program yang
akan dieksekusi.
List Berkait / Linked list
List diawali dari Kepala, yang merupakan kepala dari list. Kepala berisi
alamat dari elemen pertama. Elemen list berisi 2 jenis field, yaitu Info dan Berikut.
Info adalah harga yang disimpan/dioperasikan, sedangkan Berikut adalah pointer
yang berisi alamat berikutnya.
List diakhiri dengan suatu elemen terakhir yang memiliki harga Berikut yang
tidak menunjuk kemanapun. Harga Berikut ini disebut Nil.
Jika Kepala = Nil, menunjukkan list dalam keadaan kosong.
Notasi :
Jika P adalah suatu variabel yang berjenis pointer :
P^. Info : Mengakses data pada elemen yang beralamat di P
P^. Berikut : Mengakses alamat elemen sesudah P
Pendefinisian dalam Pascal adalah sebagai berikut :
Type
Info_Type = Integer;
List = ^ElmList;
ElmList = Record
Info : Info_Type;
Berikut : List;
End;

Struktur Data
Yuda Syahidin,ST
Operasi – operasi Dasar Pada Linked List
Operasi-operasi dasar : Inisialisasi List, Penelusuran List (Explore),
Pencarian List (Searching), Penyisipan List (Insertion), Penghapusan List (Deletion).
Pada bagian ini diasumsikan List Berkait diimplementasikan pada jenis data
dinamis.
Rutin-rutin yang digunakan :
NEW (P) : Membuat node baru dari memori komputer lalu menyimpan
alamat di P.
RELEASE (P) atau
DISPOSE (P) : Membebaskan memori komputer dari suatu node yang alamatnya
ditunjuk oleh P.
Inisialisasi List
Inisialisasi adalah pemberian nilai awal terhadap variabel list (pointer).
Procedure Inisialisasi (Var Kepala : List);
Begin
Kepala := Nil; {tidak menunjuk kemanapun}
End;
Penelusuran List / Explore
Explorasi adalah penjelajahan untuk mengunjungi semua elemen.
Tujuan : Pencetakan, Pemeriksaan, pengubahan data, dll.
Procedure PenelusuranList (Var Kepala : List);
Var
P : List;
Begin
P := Kepala; {alamat elemen yang akan dikunjungi}
While P <> Nil Do
Begin
Proses (P); {realisasinya : pemrosesan terhadap P}
P := P^. Berikut;
End;
{P = Nil, semua elemen sudah dikunjungi, atau list kosong }
End;

Struktur Data
Yuda Syahidin,ST
Pencarian List / Searching
Searching adalah pencarian suatu elemen pada list, dengan kriteria tertentu
a. Pencarian elemen list yang berharga Y
Function PencarianList (Var Kepala : List; Y : Info_Type) : Boolean;
Var
P : List;
Ketemu : Boolean;
Begin
P := Kepala;
Ketemu := False;
While (P <> Nil) And (Not Ketemu) Do
Begin
If P^. Info = Y Then
Ketemu := True
Else
P := P^. Berikut;
End;
PencarianList := Ketemu;
End;
{Jika tidak ketemu P = Nil dan PencarianList bernilai False}
b. Pencarian elemen terakhir
Procedure PencElemenAkhir (Var Kepala, P : List) ;
Begin
P := Head
If P <> Nil Then
Begin
While (P^. Berikut <> Nil) Do
P := P^. Berikut;
End;
End;
Penyisipan List / Insertion
Insertion adalah penyisipan suatu elemen list pada Linked List.
a. Penyisipan sebagai elemen pertama
Procedure SisipAwal (Var Kepala : List; P :List)
Begin
P^. Berikut := Kepala;
Kepala := P;
End;
b. Penyisipan sebagai elemen terakhir
Procedure SisipAkhir (Var Kepala : List; P : List);
Var
Akhir : List;
Begin
New (P)
If Kepala = Nil Then SisipAwal (Kepala, P); {Bila masih kosong}

Struktur Data
Yuda Syahidin,ST
Else
Begin
Akhir := Kepala;
While (Akhir <> Nil) Do
Akhir := Akhir^. Berikut;
P^. Berikut := Nil;
Akhir^. Berikut := P;
End;
End;
c. Penyisipan sesudah elemen P
Procedure SisipSesudah (Var Prec : List; P : List);
Begin
Prec^. Berikut := P^. Berikut;
P^. Berikut := Prec;
End;
Penghapusan List / Deletion
Deletion adalah proses penghapusan list yang dianggap tidak diperlukan
lagi.
Penghapusan dilakukan dengan tahapan :
- Lepaskan elemen dari rantai Linked-List.
- Bebaskan memori yang digunakan dengan DISPOSE atau RELEASE.
a. Penghapusan elemen pertama
Procedure HapusElemenPertama (Var Kepala : List);
Begin
If Kepala <> Nil Then
Begin
P := Kepala;
Kepala := Kepala^. Berikut; {Kepala maju untuk menuju
Dispose (P); elemen berikutnya}
End;
End;
b. Penghapusan elemen terakhir
Procedure HapusElemenAkhir (Var Kepala : List; P : List);
Var
Akhir, PreAkhir : List;
Begin
Begin
Akhir := Kepala;
PrecAkhir := Nil;
While (Akhir ^. Berikut <> Nil) Do
Begin
PrecAkhir := Akhir;
Akhir := Akhir^. Berikut;
End;
P:= Akhir;

Struktur Data
Yuda Syahidin,ST
If PrecAkhir = Nil Then {Elemen List hanya satu}
Kepala := Nil
Else
PrecAkhir^. Berikut := Nil;
If P <> Nil Then Dispose (P);
End;
End;
c. Penghapusan elemen sesudah P
Procedure HapusElemenSesudah (Var P : List);
{List Tidak Boleh Kosong !!}
Var
Prec : List;
Begin
If P^. Berikut <> Nil Then
Begin
Prec := P^. Berikut;
P^. Berikut := Prec^. Berikut; {Alamat P yangberikutnya}
Dispose (Prec);
End;
End;

Struktur Data
Yuda Syahidin,ST
MATERI 4
OPERASI – OPERASI DASAR II PADA LINKED LIST
Tujuan:
• Memahami mengenai operasi khusus dari list berkait
• Memahami algoritma dan operasi khusus list berkait
Operasi – operasi dasar yang akan dibahas pada modul ini adalah operasi
penggabungan, operasi-operasi khusus pada varian Linked list.
Penggabungan List
Dua linked list yang terpisah dapat digabungkan menjadi list tunggal dengan
algoritma merging. Untuk penggabungan 2 list, dimana elemen pertama list II
adalah elemen berikutnya dari elemen terakhir list I, algoritmanya :
Kepala 1
List Pertama : a b c d
Kepala 2
List Kedua :
x y z
Hasil Gabungan :
Kepala 1
a b c d x y z
Procedure GabungListAkhir (var Kepala1, Kepala2 : List);
Begin
PencElemenAkhir (Kepala1, P);
If P <> Nil then
P^. Berikut := Kepala2
Else
Kepala1 := Kepala2;
End;

Struktur Data
Yuda Syahidin,ST
Varian Linked List
Varian Linked List adalah Linked List yang tidak sesederhana representasi di
atas.
1. List Berkait dengan kepala dan ekor.
Kepala = Ekor = Nil → untuk List Kosong
Kepala = Ekor <> Nil → List beranggotakan 1 elemen
Kepala Ekor
2. List Sirkuler.
3. List dengan pointer ganda (Double Linked List).
4. List beranak bertingkat (menggunakan field pointer tambahan untuk kepala ke
list anak).
Kepala
Anak-anak
Cucu
5. List kombinasi dari varian-varian tersebut.

Struktur Data
Yuda Syahidin,ST
Operasi-operasi pada List Sirkuler
a. Kunjungan pada tiap elemen
Procedure PlrListSirkuler (var Kepala : List);
Begin
If (Kepala <> Nil) then
Begin
P:= Kepala;
Repeat
Proses (P);
P:= P^. Berikut;
Until P = Kepala;
End;
End;
b. Sisipkan elemen baru
Sebagai elemen pertama :
Procedure SisipPtmSirkuler (var Kepala : List);
Var
Q : List;
Begin
If (Kepala = Nil) then
Begin
Kepala := P;
P^. Berikut := Kepala ; {menunjuk dirinya sendiri}
End
Else
Begin
Q := Kepala;
While (Q^. Berikut <> Kepala) Do {menunjuk kepala / link
Q := Q^.Berikut; sirkulernya}
Q^. Berikut := P;
Kepala := P;
End;
End;
Sebagai elemen terakhir :
Procedure SisipAkrSirkuler (var Kepala : List; P : List);
Var
Q : List;
Begin
If (Kepala = Nil) Then
Kepala := P
Else
Begin
Q := Kepala;
While (Q ^. Berikut <> Kepala) do {menunjuk Kepala / Link
Q := Q^. Berikut; sirkulernya}
Q^. Berikut := P;

Struktur Data
Yuda Syahidin,ST
End;
End;
c. Penghapusan Elemen List Sirkuler
Penghapusan Elemen Pertama List Sirkuler :
Procedure HapusElmPertamaListSirkuler (Var Kepala : List);
Var
P : List;
Begin
Begin
If Kepala^. Berikut = Kepala Then
Begin
Dispose (Kepala);
Kepala := Nil;
End
Else {If Kepala^. Berikut <> Kepala Then}
Begin
P := Kepala;
Kepala := Kepala^. Berikut;
While Kepala^. Berikut <> P do
End;
Kepala^. Berikut := P^. Berikut;
Dispose (P);
End;
End;
End;
Penghapusan Elemen Terakhir List Sirkuler :
Procedure HapusElmAkhirListSirkuler (Var Kepala : List);
Var
PreAkhir, P : List;
Begin
Begin
If Kepala^. Berikut = Kepala Then
Begin
Dispose (Kepala);
Kepala := Nil;
End
Else
Begin
P := Kepala;
While P^. Berikut <> Kepala do
Begin
PreAkhir := P;
P:= P^. Berikut;
End;
PreAkhir^. Berikut := Kepala;
Dispose (P);

Struktur Data
Yuda Syahidin,ST
End;
End;
End;
Operasi – operasi pada List berpointer Ganda
Pendeklarasian pada program pascal :
Type
Info_Type = integer;
List = ^ElmList;
ElmList = Record
Info : Info_Type;
Sebelum, Berikut : List;
End;
a. Kunjungan pada setiap elemen :
- Pointer Sebelum tidak digunakan.
- Algoritma sama dengan Linked List pointer tunggal
b. Penyisipan sebagai elemen pertama
Procedure SisipAwListGanda (var Kepala : List; P : List);
Begin
Kepala^. Sebelum := P;
Kepala := P;
P^. Sebelum := Nil;
End;
c. Penyisipan sebagai elemen terakhir :
Procedure SisipAkListGanda (Var Kepala : List; P : List);
Begin
PencElemenAkhir (Kepala, Q); {Pemanggilan Prosedur PencElemen Akhir}
P^. Berikut := Nil;
P^. Sebelum := Q; {Q : Alamat elemen terakhir atau Nil}
If (Q <> Nil) then
Q^. Berikut := P;
End;
d. Penyisipan sebagai suksesor dari Q
Procedure SisipSesudahListGanda (var P : List; Q : List);
Begin
P^. Berikut := Q^. Berikut;
P^. Sebelum := Q;
If (Q^. Berikut <> Nil) Then
Q^. Berikut^. Sebelum := P;
Q^. Berikut := P;

Struktur Data
Yuda Syahidin,ST
End;
e. Penghapusan elemen pertama
Procedure HapusElmPtmListGanda (var Kepala : List; P : List);
Begin
Begin
P:= Kepala;
Dispose (P);
If (Kepala <> Nil) Then {sisa tidak kosong}
Kepala^. Sebelum := Nil;
End;
End;
f. Penghapusan elemen terakhir
Procedure HapusElmAkhListGanda (var Kepala : List; P : List);
Ver
Q : List;
Begin
Begin
If (Kepala^. Berikut = Nil) then
Begin
Dispose (Kepala);
Kepala := Nil;
End
Else
Begin
PencElemenAkhir(Kepala, Q);
P := Q^. Sebelum;
Dispose (Q);
P^. Berikut := Nil;
End;
End;
End;

Struktur Data
Yuda Syahidin,ST
A
B
C
D
E
F
TOP
BOTTOM
MATERI 5
STACK DAN QUEUE
Tujuan:
- Dapat memahami stack dan queue
- Dapat mengetahui algoritma stack dan queue
- Dapat memahami operasi polish notation untuk stack
- Dapat mengimplementasikan algoritma stack dan queue kedalam bahasa
pemrograman.
1. Stack
Stack merupakan koleksi atau kumpulan data secara bertumpuk (seolah-olah
bertumpuk) dimana data yang akan disisipkan atau akan diambil(dihapus) dilakukan
pada ujung yang sama yang dikenal dengan sebutan top dari tumpukan (top of
stack).
Deskripsinya sebagai berikut:
1.1 Representasi Stack
Representasi stack dapat dibuat dengan struktur data Array maupun List berkait.
Dalam modul ini akan direpresentasikan dengan menggunakan struktur data Array.
Deklarasi untuk stack:
const maxstack = 100;
type stack = record
item:array[1..maxstack] of char;
top:0...maxstack
end;
var s:stack;
1.2 Operasi-operasi dalam stack
1.2.1 Operasi Penyisipan (PUSH)
Operasi ini dilakukan untuk menyisipkan data pada stack yang dikenal
dengan operasi PUSH. Berikut procedure untuk operasi stack:
procedure push(var s:stack; x:integer);
begin
if s.top=maxstack then error(‘stack overflow’)
else
begin
s.top:=s.top+1;
s.item[s.top]:=x;

Struktur Data
Yuda Syahidin,ST
end;
end;
1.2.2 Operasi POP
Operasi ini dilakukan untuk mengambil atau menghapus data pada stack yang
dikenal dengan operasi POP. Berikut procedure untuk operasi stack:
function pop(var s:stack):integer;
begin
if empty(s) then error(‘stack underflow’)
else
begin
pop:=s.item[s.top];
s.top:=s.top-1;
end;
end;
empty(s) merupakan function untuk mengetahui kosong atau tidaknya
didalam stack. Berikut function untuk empty(s).
function empty(s:stack):boolean;
begin
if s.top=0 then
empty:=true {stack adalah kosong}
else
empty:=false; {stack adalah tidak kosong}
end;
1.2.3 Implementasi Stack.
Salahsatu pemanfaatan tumpukan adalah untuk menulis ungkapan
menggunakan notasi tertentu atau dikenal dengan penulisan ungkapan numeris.
Seperti dalam menggunakan tanda kurung untuk mengelompokan bagian mana yang
harus dikerjakan terlebih dahulu.
Infix Posfix
A+B-C AB+C-
(A+B)*(C-D) AB+CD-*
A-B/(C*D^E) ABCD^*/-
Berikut ini procedure dan function untuk operasi polish notation.
function valensi(op:char):integer;
begin
case op of
‘^’:valensi:=3;{pangkat}
‘*’,’/’:valensi:=2;{kali dan bagi}
‘+’,’-’:valensi:=1;{tambah dan minus }
‘(’:valensi:=0;{kurung buka}
end;
end;
procedure infix_posfix(infix:string);
var i:integer;
operator:set of char;
temp, kar:char;
s:Stack;

Struktur Data
Yuda Syahidin,ST
A B C D
Front
Rear
Test:boolean
begin
{*himpunan operator yang diijinkan*}
operator:=[‘^’]+[‘*’]+[‘/’]+[‘+’]+[‘-’];
{*melakukan konversi*}
for i:=1 to length(infix) do
begin
kar:=infix[i];
{*kurung buka. Push kedalam tumpukan*}
if kar=’(’ then push(s,kar)
{*kurung tutup. Pop semua elem tumpukan*
*dan cetak, sampai elemen atas tumpukan*
*adalah kurung buka. Pop juga elemen ini *
*tetapi tidak perlu ditulis. *}
else
if kar=’)’ then
begin
while s.item[s.top]<>’(’ do
write(pop(s));
temp:=pop(s);
end
{*operator. Test valensinya terhadap valensi elemen atas tumpukan. jika*
valensinya lebih kecil, pop elemen atas tumpukan sampai valensi elemen
atas tumpukan lebih kecil. Push operator ini.}
else
if kar in operator then
begin
while (s.top<>0) and (valensi(kar) <=valensi(s.item[s.top])) do
write(pop(s))
push(s,kar)
end
else
if kar<>’ ’ then write(kar)
end;
s.top<>0 then
{*tumpukan masih isi. Pop semua elemen*
*yang masih ada dalam tumpukan *}
repeat
write(pop(s))
until s.top=0;
end;
2. QUEUE
Queue adalah suatu kumpulan data yang mana penambahan (insert) elemen
hanya bisa dilakukan pada satu ujung(disebut dengan sisi belakang atau rear), dan
penghapusan (pengambilan elemen) dilakukan lewat ujung lain(disebut dengan sisi
depan atau front). Berikut ilustrasi dari queue:

Struktur Data
Yuda Syahidin,ST
2.1 Representasi Queue
Representasi Queue dapat menggunakan struktur data Array maupun list
berkait. Dalam modul ini akan direpresentasikan menggunakan struktur data list
berkait. Berikut deklarasi queue:
type
Pqueue = ↑queue;
queue = record
items: integer;
next:pqueue;
end;
var
front,rear:Pqueue;
procedure init_queue(var front,rear:pqueue);
begin
front:=nil;
rear:=nil;
end;
2.2 Operasi-operasi queue
2.2.1 Operasi Insert
Operasi ini digunakan untuk menyisipkan elemen dalam queue, yang
dilakukan pada sisi belakang (rear). Berikut procedure untuk operasi insert:
procedure insert(var front,rear:pqueue; x:integer);
var p:pqueue;
begin
new(p);
p↑.items:=x;
if empty(front) then
begin
p↑.next:=front;
front:=p
rear:=p;
end
else
begin
rear↑.next:=p;
p↑.next:=nil;
rear:=p;
end;
end;
2.2.2 Operasi Remove
Operasi ini digunakan untuk mengambil atau melayani elemen yang ada
dalam antrian(queue). Berikut ini procedure untuk remove queue:
procedure remove(var front,rear:pqueue);
var p:pqueue;
begin

Struktur Data
Yuda Syahidin,ST
if empty(front) then error(‘queue underflow’)
else
begin
p:=front;
front:=front↑.next;
if front=nil then rear:=nil;
dispose(p);
end;
end;
empy(q) merupakan fungsi untuk mengetahui bahwa antrian kosong atau
tidak. Berikut ini fungsi untuk empty(q):
function empty(q:pqueue):boolean;
begin
if front=nil then
empty:=true {queue adalah kosong}
else
empty:=false; {queue adalah tidak kosong}
end;
Latihan.
1. Buatlah program untuk mengkonversikan dari notasi infix ke postfix. gunakanlah
procedure dan function yang telah dibuat!
2. Buatlah program berdasarkan proses-proses dibawah ini untuk
mengimplementasikan queue, gunakanlah procedure dan function yang telah
dibuat!
insert(front,rear,A);
insert(front,rear,B);
insert(front,rear,C);
insert(front,rear,D)
remove(front,rear);
remove(front,rear)
insert(front,rear,E);
insert(front,rear,F);
remove(front,rear);
kemudian tampilkan hasil akhir dari proses tersebut!
Tugas.
1. Buatlah program untuk menghitung nilai dari notasi posfik yang sudah ada
sebelumnya (tinggal menambahkan algoritma untuk menghitung nilai postfix
tersebut ).
2. Buatlah program untuk mengimplementasikan prioritas queue ,dengan struktur
data sebagai berikut:
type antri =↑listantrian;
listantrian=record
info:char;
prioritas:integer;

Struktur Data
Yuda Syahidin,ST
next:antri;
end;
dalam hal ini berlaku dua ketentuan, yaitu:
1. Elemen-elemen yang mempunyai prioritas lebih tinggi akan diproses lebih
dulu.
2. Dua elemen yang mempunyai prioritas sama akan dikerjakan sesuai dengan
urutan ada saat kedua elemen ini masuk dalam antrian.

Struktur Data
Yuda Syahidin,ST
MATERI 6
PENGURUTAN DATA
Tujuan:
Memahami algoritma Pengurutan Data
Dapat memahami metoda-metoda pengurutan Data
Salah satu pemanfaatan struktur data array terpenting adalah pengurutan data.
Pengurutan dibedakan 2 macam:
a. Pengurutan Internal, yaitu pengurutan terhadap sekumpulan data yang
disimpan dalam media internal komputer yang dapat diakses setiap
elemennya secara langsung maka dapat dikatakan sebagai pengurutan tabel.
b. Pengurutan eksternal, yaitu pengurutan data yang disimpan dalam memori
sekunder, biasanya dapat bervolume besar sehingga tidak mampu untuk
dimuat semuanya dalam memori.
METODA PENGURUTAN DATA
1. Bubble/Exchange Sort
2. Insertion Sort
3. Selection Sort
BUBBLE/EXCHANGE SORT
Bubble/Exchange Sort merupakan metode pengurutan data secara langsung.
Algoritma Global
Untuk Setiap Pass i=1,2,...,N-1, lakukan
Mulai dari Elemen j=N,N-1,...,i+1 lakukan:
1.1. Bandingkan A[J] dengan L[J-1]
1.2. Pertukarkan A[J] dengan A[J-1] Jika A[J] < A[J-1]
Algoritma Detail
{N:Banyaknya elemen Array}
I:=1
While J<N Do
J:=N
While J>I Do
If A[J] < A[J-1] then
Swap := A[J]
A[J] :=A[J-1]
A[J-1]:=Swap
endif
j:=j-1
Endwhile
i:=i+1
endwhile

Struktur Data
Yuda Syahidin,ST
Latihan :
Diberikan array bertipe integer dengan N=6 buah elemen dibawah ini yang
belum terurut, lakukanlah pengurutan berdasarkan metode Bubble Sort!
25 27 10 8 76 21
1 2 3 4 5 6
INSERTION SORT
Insertion Sort merupakan metoda pengurutan data secara menyisipkan
langsung.
Dasarnya : Ambil/tinjau sebuah nilai, lalu tempatkan/sisipkan dilokasi yang
sesuai/tepat (mirip dengan cara mengurutkan kartu)
Algoritma Global
Untuk setiap pass i=2,...,N lakukan:
1. X := A[i]
2. sisipkan y pada tempat yang sesuai antara A[1]...a[i]
Algoritma Detail
I:=2
while I ≤ N do
X:=A[i]
{sisipkan X diposisi yang tetap diantara A[1],…,A[N]}
J:=i-1
While x ≤ A[j] Do
A[J+1]:=A[J]
J:=J-1
Endwhile
A[J+1]:=X
I:=I+1
Endwhile
Latihan :
belum terurut, lakukanlah pengurutan berdasarkan metode Insertion Sort!
25 27 10 8 76 21
1 2 3 4 5 6
SELECTION SORT
Selection Sort merupakan metoda pengurutan data secara pemilihan langsung.
Dasarnya : cari nilai paling tinggi/rendah lalu tempatkan dibagian ujung array
Ada dua jenis algoritma pemgurutan seleksi ditinjau dari pemilihan elemen
maksimum/minimum, yaitu:

Struktur Data
Yuda Syahidin,ST
1. Algoritma pengurutan seleksi-maksimum, yaitu memilih elemen maksimum
sebagai basis pengurutan.
2. Algoritma pengurutan seleksi-minimum, yaitu memilih elemen minimum
sebagai basis pengurutan.
1. Pengurutan Seleksi-Maksimum
Algoritma Global
1. JumlahPass = n-1
2. Untuk setiap pass i=1,2,....,JumlahPass lakukan:
cari elemen terbesar (maks) mulai dari elemen ke-1 sampai elemen ke-n;
pertukarkan maks dengan elemen ke-n;
kurangi n satu (karena elemen ke-n sudah terurut).
Algoritma Detail
I:=N
while I ≥ 2 do
{cari elemen maksimum pada elemen A[1..N]}
imaks :=1 {elemen pertama diasumsikan elemen maks sementara}
J:=2
while J ≤ I do
if A[J] > A[imaks] then
imaks:=j
endif
J := J+1
endwhile
{pertukarkan A[imaks] dengan A[i]}
swap := A[i]
A[i] := A[imaks]
A[imaks] := swap
I:=I-1
Endwhile
Latihan :
belum terurut, lakukanlah pengurutan berdasarkan metode Selection Sort
maksimum!
25 27 10 8 76 21
1 2 3 4 5 6

Struktur Data
Yuda Syahidin,ST
2. Pengurutan Seleksi-Minimum
Algoritma Global
Untuk setiap pass i =1,2,..., n-1 lakukan:
1. Cari elemen terkecil (min) mulai dari elemen ke-1 sampai elemen ke-n;
2. pertukarkan min dengan elemen ke-i;
Algoritma Detail
I:=1
while I < N do
{cari elemen minimum pada elemen A[1..N]}
imin :=1 {elemen pertama diasumsikan elemen min sementara}
J:=i+1
while J ≤ N do
if A[J] < A[imin] then
imin:=j
endif
J := J+1
endwhile
{pertukarkan A[imaks] dengan A[i]}
swap := A[i]
A[i] := A[imin]
A[imin] := swap
I:=I+1
Endwhile
Latihan :
belum terurut, lakukanlah pengurutan berdasarkan metode Selection Sort
minimum!
25 27 10 8 76 21
1 2 3 4 5 6

Struktur Data
Yuda Syahidin,ST
MATERI 7
PENCARIAN (SEARCHING)
DEFINISI
Pencarian adalah menemukan nilai (data) tertentu di dalam sekumpulan
nilai yang bertipe sama (tipe dasar atau bentukan).
Mengapa dibutuhkan?
Untuk mengubah atau menghapus nilai tertentu harus dicari apakah
ada nilai tersebut di dalam kumpulan tersebut
Penyisipan data ke dalam kumpulan juga kadang-kadang dimulai
dengan pencarian apakah data tersebut telah ada sehingga terhindar
dari duplikasi data
Algoritma Pencarian Mendasar adalah
Pencarian Beruntun (Sequential Search)
Pencarian Bagi dua (Binary Search)
PENCARIAN BERUNTUN (SEQUENTIAL SEARCH)
Adalah proses membandingkan setiap elemen larik (array) satu persatu secara
beruntun, mulai dari elemen pertama, sampai elemen yang dicari ditemukan, atau
seluruh elemen sudah diperiksa.
ALGORITMA
Procedure SeqSearch(input L:LarikInt, input N:Integer, input X:integer, output
ketemu : boolean)
{Mencari keberadaan nilai X didalam larik[1…N]}
{K.Awal:X dan larik L[1..N] sudah terdefinisi nilainya}
{K.Akhir:ketemu bernilai true jika X ditemukan, ketemu bernilai false jika X tidak
ditemukan.}
DEKLARASI
k:integer {indeks larik}
ketemu :boolean {flag apabila X ketemu}
DESKRIPSI
k 0
while ((k<N) and (L[k]!=X)) Do
K k+1
endwhile
if (L[k]=x) then
ketemu true
else
ketemu false

Struktur Data
Yuda Syahidin,ST
endif
CONTOH PENCARIAN BERUNTUN
13 16 14 21 76 15
0 1 2 3 4 5
Misalkan nilai yang dicari adalah X=21
Elemen yang dibandingkan : 13,16,14,21 (ditemukan)
Indeks Array yang dikembalikan:IDX = 3
Misalkan nilai yang dicari adalah X =13;
Elemen yang dibandingkan:13 (ditemukan)
Indeks Array yang dikembalikan:IDX=0
Misalkan nilai yang dicari adalah X=17;
Elemen yang dibandingkan:13,16,14,21,76,15 (tidak ditemukan)
Indeks array yang dikembalikan : IDX = -1
PENCARIAN BAGI DUA (BINARY SEARCH)
Adalah proses mencari data dengan membagi data atas dua bagian secara terus
menerus sampai elemen yang dicari ditemukan, atau indeks kiri lebih besar dari
indeks kanan.
Metoda ini lebih efisien dari metoda pencarian beruntun apabila data telah terurut.
ALGORITMA
Function BinSearch(input L:LarikInt, input N:Integer, input X:integer) integer
{Mencari keberadaan nilai X didalam larik[1…N]}
{K.Awal:X dan larik L[1..N] sudah terdefinisi nilainya}
{K.Akhir:ketemu bernilai true jika X ditemukan, ketemu bernilai false jika X tidak
ditemukan.}
DEKLARASI
i,j :integer
k :integer {indeks larik}
ketemu :boolean {flag apabila X ketemu}
DESKRIPSI
i 1
j N
ketemu false
while ((not ketemu) and (i<=j)) Do
k (i+j) div 2
if (L[k]=X) then
ketemu true
else
if (L[k]<X) then
i k+1 {batas kiri diubah}
else

Struktur Data
Yuda Syahidin,ST
j k-1 {batas kanan diubah}
endif
endif
endwhile
if (ketemu) then
retun k
else
return -1
endif
CONTOH PENCARIAN BAGI DUA
7 10 13 16 18 21 76 81
1 2 3 4 5 6 7 8
Misalkan nilai yand dicari adalah X=21
i=1 j=8
k=(i+j) div 2=(1+8) div 2 = 4
L[4]=21? Tidak! Harus diputuskan apakah pencarian dilakukan di bagian kiri
atau bagian kanan
L[4] < 21? Ya! Lakukan pencarian di sebelah kanan
i=k+1 = 4+1=5
j=8
k=(i+j) div 2=(5+8) div 2=6
L[6]=21? Ya, Proses pencarian selesai.

Struktur Data
Yuda Syahidin,ST
A
CB
D
I
E
J K
F G H
L M
N O
MATERI 8
STRUKTUR POHON
Tujuan:
- Dapat memahami struktur pohon
- Dapat mengetahui representasi struktur pohon
- Dapat memahami dan mengetahui operasi-operasi dasar pre-order, in-order,
post-order
- Dapat memahami dan mengimplementasi algoritma struktur pohon dalam
bentuk program
Secara sederhana struktur pohon bisa didefinisikan sebagai kumpulan elemen
yang salah satu elemennya disebut dengan akar(root), dan sisa elemen yang
lain(yang disebut simpul) terpecah menjadi sejumlah himpunan yang saling tidak
berhubungan satu sama lain, yang disebut dengan subpohon (subtree), atau disebut
dengan cabang.
Istilah dalam struktur pohon:
- Derajat(degree) adalah banyaknya anak atau turunan dari simpul tersebut.
- Daun(leaf) adalah semua simpul yang berderajad nol.
- Tinggi(height) atau kedalaman(depth) dari suatu pohon adalah tingkat
maksimum dari simpul dalam pohon tersebut dikurangi dengan 1.
- Hutan(forest) adalah kumpulan sejumlah pohon yang tidak saling berhubungan
Contoh struktur pohon
1. Pohon Biner
Pohon biner(binary tree) bisa didefinisikan sebagai suatu kumpulan simpul yang
mungkin kosong atau mempunyai akar dan dua subpohon yang saling terpisah yang
disebut dengan subpohon kiri (left subtree), dan subpohon kanan (right subtree)

Struktur Data
Yuda Syahidin,ST
Contoh pohon biner
2. Deklarasi Pada Pohon Biner
Representasi pada pohon biner akan dideklarasikan dengan menggunakan struktur
data list berkait (linked-list)
Type nodeptr=↑nodetype
nodetype=record
info:integer;
left:nodeptr;
right:nodeptr;
father:nodeptr;
end;
Berikut ini akan diberikan fungsi atau procedure yang terlibat untuk
merepresentasikan pohon biner:
{*fungsi ini digunakan untuk membuat/mengalokasikan node dan men-set dalam
root dalam single node binary tree*}
function maketree(x:integer):nodeptr;
var p:nodeptr;
begin{function maketree}
new(p);
p↑.info:=x;
p↑.left:=nil;
p↑.right:=nil;
p↑.father:=nil;
maketree:=p;
end;
procedure setleft(p:nodeptr;x:integer);
var q:nodeptr;
begin {procedure setleft}
if p=nil then error(‘void insertion’)
else if p↑.left<>nil then error(‘invalid insertion’)
else begin
q:=maketree(x);
A
CB
D
I
E
J K
F H
L M
N O

Struktur Data
Yuda Syahidin,ST
p↑.left:=q;
q↑.father:=p;
end;{else begin}
end;
procedure setright(p:nodeptr;x:integer);
var q:nodeptr;
begin {procedure setright}
if p=nil then error(‘void insertion’)
else if p↑.right<>nil then error(‘invalid insertion’)
else begin
q:=maketree(x);
p↑.right:=q;
q↑.father:=p;
end;{else begin}
end;
procedure DuplicateNode(p:nodeptr;number:integer)
var tree, q:nodeptr;
begin
tree:=maketree(number);
p:=tree;
q:=tree;
while (number<>p↑.info) and (q<>nil) do
begin
p:=q;
if number<p↑.info then
q:=p↑.left
else
q:=p↑.right;
end;
if number=p↑.info then
writeln(number,‘is a duplicate’)
else if number < p↑.info then
setleft(p,number)
else setright(p,number)
end;
operasi-operasi lain yang terlibat dalam pohon biner adalah operasi
penelusuran(traverse):
Kunjungan secara pre-order, yang juga sering disebut dengan depth first order,
menggunakan urutan:
- cetak isi simpul yang dikunjungi.
- Kunjungi cabang kiri.
- Kunjungi cabang kanan.
{*procedure yang digunakan menggunakan procedure secara recursive*}
procedure preorder(tree:nodeptr);
begin

Struktur Data
Yuda Syahidin,ST
if tree <>nil then
with tree↑ do
begin
writeln(info);{kunjungi dan cetak info}
preorder(left);{kunjungi left subtree}
preorder(right);{kunjungi right subtree}
end;{with begin}
end;
Kunjungan secara in-order, juga sering disebut dengan symetric-order,
menggunakan urutan:
- kunjungi cabang kiri.
- Cetak isi simpul yang dikunjungi.
- Kunjungi cabang kanan.
procedure inorder(tree:nodeptr);
begin
if tree <>nil then
with tree↑ do
begin
inorder(left);{kunjungi left subtree}
inorder(right);{kunjungi right subtree}
end;{with begin}
end;
Kunjungan secara post-order menggunkan urutan:
- kunjungan cabang kiri
- kunjungi cabang kanan.
- Cetak isi simpul yang dikunjungi.
procedure inorder(tree:nodeptr);
begin
if tree <>nil then
with tree↑ do
begin
postorder(left);{kunjungi left subtree}
postorder(right);{kunjungi right subtree}
end;{with begin}
end;
3. Binary Search Tree
Binary search tree merupakan algoritma yang digunakan untuk mencari suatu nilai
kunci(key) yang berada dalam suatu tree/subtree.
Berikut ini akan diberikan suatu function untuk binary search tree:
function searchtree(key:integer):nodeptr;
var found:boolean;
tree, p:nodeptr;
begin

Struktur Data
Yuda Syahidin,ST
found:=false
p:=tree;
while (p<>nil) and (not found) do
begin
if key=p↑.info then
found:=true
else
if key<p↑.info then
p:=p↑.left
else
p:=p↑.right;
end;
if found then
searchtree:=p
else
searchtree:=nil;
end;
Latihan:
Implementasikan procedure dan function untuk operasi pohon biner (binary tree)
kedalam bahasa pemrograman!
Inputan:
Menu
1. create pohon biner
2. operasi pre-order
3. operasi in-order
4. operasi post-order
5. selesai
Tugas:
Buatlah program untuk mengimplementasikan binary search tree meliputi operasi:
1. pencarian nilai di pohon biner (binary search tree)
2. penyisipan nilai baru di pohon biner.
3. Penghapusan nilai di pohon biner.

Struktur Data
Yuda Syahidin,ST
A
B
C
D
F
E G
H
MATERI 9
STRUKTUR GRAPH
Tujuan:
- Dapat memahami struktur graph
- Dapat memahami algoritma dari representasi graph
- Dapat meng-implementasikan algoritma struktur graph kedalam program
Graph merupakan kumpulan dari titik (node atau vertices) dan garis (arcs atau
edges). garis selalu diawali pada suatu titik dan diakhiri pada titik yang lain, maka
garis bisa dituliskan sebagai pasangan antara dua titik. Dalam notasi graph, garis
ditulis sebagai:
e=[u,v], yang berarti bahwa garis e berawal pada titik u dan berakhir pada titik v.
nodes={A,B,C,D,E,F,G,H}
edge = {(A,B),(A,C),(A,D),(C,D),(C,F),(E,G),(A,A)}
Graph yang akan dibahas dimodul ini adalah graph berarah yang sudah dijelaskan
diatas.
1. Representasi Graph
Representasi graph dapat menggunakan Array atau linked-list. Representasi graph
misalnya untuk menentukan matrik tetangga (adjacent matrix).
{*representasi ini menggunakan array*}
const maxnodes = 50;
type nodeptr = 1..maxnodes;
adjmatrix=array[nodeptr,nodeptr] of boolean;
var adj:adjmatrix;
procedure join(var adj:adjmatrix;node1,node2:nodeptr);
begin
adj[node1,node2]:=true;
end;
procedure remv(var adj:adjmatrix;node1,node2:nodeptr);
begin
adj[node1,node2]:=false;
end;

Struktur Data
Yuda Syahidin,ST
function adjacent(adj:adjmatrix;node1,node2:nodeptr):boolean
begin
if adj[node1,node2] then
adjacent:=true
else
adjacent:=false;
end;
contoh:
2. Penelusuran Graph (Graph Traversal)
Penelusuran Graph dibagi menjadi 2 metoda:
Sebelumnya kita deklarasikan terlebih dahulu struktur datanya:
const maxvertex=50;
type
nodeptr=0…maxvertex;
queue = record
front,rear:nodeptr;
entry:array[nodeptr] of nodeptr;
end;
2.1 Algoritma Depth-First
Teknik ini menggunakan rountine dftraverse(s) yang digunakan untuk
mengunjungi semua nodes yang dapat diraih oleh variabel s. Berikut algoritma-
algoritma penunjang untuk depth-first:
procedure DepthFirst(var s:nodeptr;procedure visit(var v:nodeptr));
var
nd:integer;
visited=array[nodeptr] of boolean;
begin
for nd:=0 to maxvertex do visited[nd]:=false;
s:=a;
while s <> 0{nil} do
begin
dftraverse(s);
s:=select;
end;
end;
procedure dftraverse(var s:nodeptr;procedure visit(s:nodeptr));
var yptr:nodeptr;
1 2
4 3
Adjacent sets
vertex Set
1
2
3
4
{2,3}
{3,4}
0
{1,2,3}
Adjacent Table
1 2 3 4
1
2
3
4
0 1 1 0
0 0 1 1
0 0 0 0
1 1 1 0

Struktur Data
Yuda Syahidin,ST
begin
visited[s]:=true;
visit(s);
first( s, yptr,nd);
while(yptr<>0){nil} do
begin
if not visited(nd) then dftraverse(nd);
nextsucc(s,yptr,nd);
end;
end;
function select:nodeptr;
var i,last : integer;
found:boolean;
begin
{diinisialisasikan last=0}
i:=last+1;
found:=false;
while (not found) and (i<=maxvertex) do
begin
if visited(i) then
i:=i+1
else
found:=true;
end;
last:=i;
if found then
select:=i
else
select:=0;
end;
procedure first(var x:nodeptr;var yptr:nodeptr;ynode:nodeptr);
begin
nextsucc(x,0,ynode);
yptr:=ynode;
end;
procedure nextsucc(var x:nodeptr;var yptr:nodeptr,ynode:nodeptr)
var i:integer;
finished:boolean;
begin
i:=yptr;
finished:=false;
repeat
i:=i+1;
if i > maxvertex then
begin
finished:=true;
yptr:=0;
ynode:=0;
end
else
if adj(x,i) then

Struktur Data
Yuda Syahidin,ST
begin
finished:=true;
yptr:=i;
ynode:=I;
end;
until finished;
end;
function adj(p,q:nodeptr):boolean;
var r:nodeptr;
found:boolean;
begin
r:=node[p].point;
found:=false;
while (r<>0) and (not found) do
begin
if node[r].point:=q then
found:=true
else
r:=node[r].next;
end;
adj:=found;
end;
2.2 Algoritma Breadth-First
Algoritma breath-first adalah algoritma yang melakukan proses penelusuran
terhadap semua suksesor dalam hal ini node yang akan dikunjungi sebelum
dikunjungi oleh suksesor-suksesor yang lain. Berikut procedure bftraverse(s).
Catatan : untuk procedure maupun function seperti
init(ndqueue),insert(ndqueue,s), dan remove(ndqueue,s) sudah dijelaskan di modul
3 STACK dan QUEUE
procedure bftraverse(var s:nodeptr;procedure visit(var v:nodeptr));
var ndqueue:entry;
begin
init(ndqueue);
while s <> 0 do
begin
visit(s);
insert(ndqueue,s);
while not empty(ndqueue) do
begin
x:=remove(ndqueue);
first(x,yptr,nd);
while (nd<>0) do
begin
if not visited(nd) then
begin
visit(nd);
insert(ndqueue,nd);
end;
nextsucc(x,yptr,nd)
end;
end;

Struktur Data
Yuda Syahidin,ST
s:=select;
end;
end;
2.3 Algoritma Greedy untuk mencari lintasan terpendek(shortest Path)
Shortest path adalah mencari lintasan terpendek yang menghubungkan 2
buah node dalam graph. Berikut ini procedure untuk mencari shortest path:
const maxnodes=…;
type nodeptr = 1..maxnodes;
weightmatrix=array[nodeptr,nodeptr] of integer;
nodeset=set of nodeptr;
nodearray=array[nodeptr] of nodeptr;
procedure shortpath(var weight:weightmatrix;s,t:nodeptr;
var d:integer;var precede:nodearray);
var distance : array[nodeptr] of integer;
current, i,k:nodeptr;
perm:nodeset;
smalldist, newdist,dc,d:integer;
begin
{inisialisasi}
perm:=[s];
for i:=1 to maxnodes do distance[i]:=maxint;
distance[s]:=0;
current :=s;
while (current <>t) do
begin
smalldist:=maxint;
dc:=distance[current];
for i:=1 to maxnodes do
begin
if not (I in perm) then
begin
newdist:=dc+weight[current,i];
if newdist<distance[i] then
begin
distance[i]:=newdist;
precede[i]:=current;
end;
if distance[i]<smalldist then
begin
smalldist:=distance[i];
k:=i;
end;
end;
end;
current:=k;
perm:=perm+[current]
end;
d:=distance[t];
end;

Struktur Data

Recommended

Recommended

More Related Content

What's hot

What's hot (11)

Viewers also liked

Viewers also liked (20)

Similar to Struktur Data

Similar to Struktur Data (20)

Recently uploaded

Recently uploaded (12)

Struktur Data