Cara pendeklarasian dari record adalah sbb:

• Mendefinisikan tipe dari record (jumlah field, jenis tipe data yang dipakai),
• Mendefinisikan variabel untuk dilakukan operasi.
Notasi Penulisan (sintaks):
type
nama_record = record
identifier_1 : tipe_data_1;
identifier_n : tipe_data_n;
end;
var
variabel : nama_record;
Contoh:
type
Data_mahasiswa = record
Nama : string;
Usia : integer;
Kota : String;
Kodepos : integer;
end;
Var
x: Data_mahasiswa;
Pengaksesan Elemen Record
Cara mengacu pada tiap field pada record untuk contoh sebelumnya adalah
sebagai berikut:
x.Nama
x.Usia
x.Kota
x.Kodepos

a. Deklarasi Record

1
 KETERANGAN :
“Nmahasiswa” adalahnamavariabeluntuk record pada program.
“NIM: integer”,
“NilMahasiswa”: string,
“MatKul: string”, adalah contoh isi dari record yang tipe datanya disesuaikan
dengan data yang akan diisi.

b. Contoh Record (Input/Output)

c. Contoh Record

Program contoh_rekaman;
uses crt;
type mhs = record
nim: string[8];
nama: string[30];
usia: byte;
jml_saudara: 0..20;

2
 end;
var siswa : array[1..20] of mhs;
i, n : integer;
begin
clrscr;
write(‘Banyak data yang akan dimasukkan : ‘); readln(n);

{langkah pemasukan data}

for i:= 1 to n do
begin
clrscr;
writeln(‘Data ke : ‘,i);
with siswa[i] do
begin write(‘ NIM : ‘);readln(nim);
write(‘NAMA : ‘);readln(nama);
write(‘USIA : ‘);readln(usia);
write(‘SAUDARA : ‘);readln(jml_saudara);
end;
end;  

{penampilan data}
clrscr;
writeln(‘DATA YANG ANDA MASUKKAN ‘);
writeln;
for i:= 1 to n do
begin
write(siswa[i].nim:11);
write(siswa[i].nama:23);
write(siswa[i].usia:5);
write(siswa[i].jml_saudara:5);
writeln;
end;
readln;
end.

Statemen Pernyataan WITH … DO

3
 Bentuk pernyataan with...do adalah sebagai berikut :

WITH Nama_record DO
Statemen;

Penggunaan statemen with...do mengakibatkan field-field yang terletak pada

bagian statemen dapat dituliskan tanpa perlu menyertakan lagi nama record dan
tanda titik.

Berikut Contoh penggunaan statemen with ... do pada program diatas:

Program Data_Mahasiswa;
Uses crt;
Type mhs = record
NPM : String[15];
Nama : String[20];
End;
Var data :mhs;
Begin
With data do
Begin
Write('NIM : ');Readln(NIM);
Write('Nama : ');Readln(Nama);
End;

Writeln('NPM : ',data.NPM);
Writeln('Nama : ',data.Nama);
Readln;
end.

C. Array
a. Pengertian Array

Suatu larik (array) adalah tipe terstruktur yang terdiri dari sejumlah
komponen-komponen yang mempunyai tipe sama. Suatu larik mempunyai
jumlah komponen yang banyaknya tetap. Banyaknya komponen dalam suatu
larik ditunjukkan oleh suatu indeks yang disebut tipe indeks. Tipe indeks ini

4
 berbentuk ungkapan tipe ordinal (tipe data yang berurutan). Tiap-Tiap komponen
pada larik dapat diakses dengan menunjukkan nilai indeksnya. Array merupakan
struktur data yang statis, yaitu jumlah elemen yang ada harus ditentukan terlebih
dahulu dan tak bisa di ubah saat program berjalan. Untuk menyatakan array
dalam PASCAL kita harus terlebih dahulu:
 Mendefinisikan jumlah elemen array,
 Mendefinisikan tipe data dari elemen array

b. Deklarasi Array
Pendefinisian array secara umum adalah sebagai berikut: jika kita ingin
membuat beberapa array dengan tipe/jenis yang sama, kita lebih baik jika
mendeklarasikan dengan type selanjutnya dengan deklarasi var.
type
nama_array = ARRAY[bawah..atas] of tipe_data;
var
variabel_array : nama_array; atau dengan menggunakan statement var :
var
variabel_array : ARRAY[bawah..atas] of tipe_data;
Penjelasan: Bawah dan Atas menyatakan batas untuk array. tipe_data
adalah
merupakan tipe variabel yang dipunyai array (mis. Integer, char,real, dsb)
Contoh:
Var
x: array[1..100] of integer;
Larik x telah dideklarasikam sebagai larik tipe integer dengan jumlah elemen
maksimum sebanyak 100 elemen. Nilai-nilai elemen larik ini harus berisi nilai-
nilai integer. Misalnya elemen-elemen (anggota) dari larik x adalah:
X[1]:=25;
X[2]:=55;
X[3]:=65;
X[4]:=75;
X[5]:=95;
c. Operasi Array (Input/Output)

5
d. Contoh Kode Program Array

Pada contoh diatas, saya membuat variabel ‘nilai’ sebagai array yang berisi
10 element integer. Di dalam variabel ‘nilai’ ini, index array dimulai dari 0
hingga 9, karena saya menulisnya dengan array[0..9] of integer. Jika anda ingin
membuat 100 element array, bisa menulisnya sebagai array[0..99] of integer.
Selain itu, kita juga tidak harus mengisinya secara berurutan. Kita bisa mengisi
element-element array ini secara acak, selama masih dalam batas yang
ditetapkan. Berikut
contohnya:

6
1. Stack
a. Pengertian Stack

Stack atau Tumpukan adalah suatu struktur data yang terbentuk dari barisan
hingga yang terurut dari satuan data. Pada Stack, penambahan dan penghapusan
elemennya hanya dapat dilakukan pada satu posisi, yaitu posisi akhir stack.
Posisi ini disebut Puncak atau Top dari stack. Tumpukan merupakan kumpulan
data yang sifat dinamis artinya kita bisa menambah dan mengambil data darinya.
Contoh:
Kasusnya, saya mempunyai buku-buku pelajaran yang terdiri dari buku
Matematika, Fisika, Biologi, Kimia dan Bahasa Indonesia. Untuk menghemat
ruang, kemudian saya menyimpan buku-buku tersebut ke dalam kotak yang saya
miliki. Saya memasukkan buku dengan urutan sebagai berikut:
Fisika 2. Kimia 3. Matematika 4. Bahasa Indonesia 5. Biologi.
Karena besok jadwalnya Matematika dan saya harus belajar, maka untuk
mengambil buku
Matematika saya harus mengeluarkan dulu buku Biologi dan Bahasa Indonesia.
Sehingga buku Matematika dapat saya ambil dan yang tersisa pada kotak saat ini
adalah buku Fisika dan Kimia.

7
OPERASI STACK
Pengertian
Operasi-operasi yang biasanya tredapat pada Stack yaitu:
1. Push : digunakan untuk menambah item pada stack pada tumpukan paling atas
2. Pop : digunakan untuk mengambil item pada stack pada tumpukan paling atas
3. IsEmpty : fungsi yang digunakan untuk mengecek apakah stack sudah kosong
4. IsFull : fungsi yang digunakan untuk mengecek apakah stack sudah penuh
DEKLARASI STACK:
Const Nmax = 100;
Type Stack = record
isi: array[1..Nmax] of integer;
top: integer;
End;

8
Var
a,b,c,x,i : integer;
S: Stack;

OPERASI ISEMPTY:
Function IsEmpty(S : Stack) : boolean;
{mengecek stack kosong}
Var
empty : boolean;
Begin
If S.top = 0 then
empty := true
else
empty := false;
IsEmpty:=empty
end.;

OPERASI ISFULL:
Function IsFull(S : Stack) : boolean;
{mengecek stack penuh}
Var
full : boolean;
Begin
if S.top = Nmax then
full := true
Else
full := false;
IsFull := full;
End;

OPERASI PUSH:
Procedure PUSH (var S : Stack; X :
integer); {fungsi push untuk
memasukan}
Begin
if IsFull(S) = false then
Begin

9
 S.top := S.Top + 1;
S.isi[S.Top] := X;
End;
End;

OPERASI POP:
Procedure POP (var S : Stack; var X :
integer); {fungsi pop untuk
mengambil/dilayani}
Begin
if IsEmpty(S) = false then
Begin
X := S.isi[S.top];
S.top := S.top – 1;
End;
writeln(‘Hasil POP ‘,X);
End;

2. Pointer
a. Pengertian Tipe Data Pointer

Tipe data pointer adalah tipe data yang berisi alamat memory dari sebuah
variabel. Pointer sering disebut juga dengan istilah link atau referensi adalah
suatu variabel yang berisi alamat dari suatu variabel yang lain.

Ketika kita mendeklarasikan sebuah variabel (misalkan variabel ‘angka’),

pascal akan menyiapkan sebuah tempat di memory komputer. Tempat ini
memiliki alamat, yang berfungsi untuk menandai lokasi variabel tersebut.

Untuk dapat memahami ini, bayangkan memory komputer sebagai sebuah

lemari besar. Variabel disimpan di dalam setiap laci lemari. Setiap laci tentunya
memiliki nomor agar mudah diakses. Nomor laci inilah yang akan disimpan
sebagai pointer.

Sebagai contoh, variabel ‘angka’ bisa ditempatkan di alamat 10023 pada

memory komputer. Variabel lain, misalnya ‘huruf’, akan disimpan di alamat
19920, variabel ‘i’ bisa disimpan di alamat 10033, dst. Alamat memory inilah
yang disimpan ke dalam tipe data pointer.

10
b. Variabel Statis dan Dinamis

Variabel statis adalah variabel yang dideklarasikan dan dinamai pada saat

penulisan program. Memori yang dipakai oleh variabel ini akan tetap ada
(dianggap terpakai) selama program dimana variabel tersebut dideklarasikan
sedang dijalankan.
Variabel dinamis adalah variabel yang dibuat (dan mungkin juga
dihapus/dirusak) selama eksekusi progam. Karena variabel dinamis belum nyata
ada pada saat program dikompilasi (ia nyata-nyata ada pada saat dibuat yaitu
pada saat program dieksekusi), maka variabel seperti ini tidak dapat dinamai
pada saat program dibuat/ditulis.
Satu-satunya cara untuk mengakses variabel dinamis adalah dengan
menggunakan pointer. Saat suatu variabel dinamis dibuat, ia belum berisi data
dan harus memiliki suatu tipe tertentu seperti halnya variabel biasa.
Sebaliknya variabel statis tidak dapat dibuat ataupun dihapus pada saat
eksekusi program dan variabel pointer tidak dapat digunakan untuk menunjuk
kepada variabel statis. Variabel statis dapat diakses hanya dengan menggunakan
namanya dan bila kita ingin menunjuk pada suatu posisi dalam array maka kita
dapat melakukannya dengan menggunakan indeks/variable yang bertipe indeks
dari array.
c. Cara Mendeklarasikan Tipe Data Pointer

Bentuk umum deklarasi pointer adalah sebagai berikut:

Type pengenal = ^simpul;
simpul = tipe;
 Dengan pengenal: nama pengenal yang menyatakan data bertipe pointer.
Simpul : nama simpul.
Tipe : tipe dari simpul.
Tanda ^ didepan nama simpul harus ditulis apa adanya dan menunjukkan bahwa
pengenal adalah suatu tipe data pointer. Tipe data simpul yang dinyatakan dalam
tipe bisa berupa sembarang tipe data, misainya char, integer, real, rekaman
(record) dan sebagainya.

11
 d. Cara Alokasi Tempat / Memori (Membuat Simpul Baru)

Untuk mengalokasi simpul dalam pengingat, statement yang digunakan adalah

statement new, yang mempunyai bentuk umum.
New(Perubah);
Dengan variabel adalah perubah bertipe pointer.
e. Operasi Pada Pointer

Secara Umum ada dua operasi dasar yang bisa kita lakukan menggunakan
operasi bertipe pointer, yaitu:
1) Operasi mengkopi pointer, sehingga sebuah simpul akan ditunjuk oleh
lebih dari sebuah pointer. Bentuk umum : P2 := P1
2) Operasi mengkopi isi simpul, sehingga dua atau lebih simpul yang
ditunjuk oleh pointer yang berbeda mempunyai isi yang sama. Bentuk
umum : P2^ := P1^

Syarat yang harus dipenuhi untuk kedua operasi ini adalah bahwa pointer-pointer
yang dioperasikan harus mempunyai deklarasi yang sama.
f. Menghapus Pointer

Statement untuk menghapus pointer adalah dispose, yang mempunyai bentuk

umum: Dispose(perubah)
Sebagai contoh pada deklarasi pointer sebelumnya, untuk menghapus pointer P2,
maka: Dispose(P2)

3. Senarai Berantai (linked List)

Senarai Berantai/Bertaut (Linked List) merupakan sebuah struktur data yang

digunakan untuk menyimpan sejumlah objek data biasanya secara terurut sehingga
penambahan, pengurangan, dan pencarian elemen data yang tersimpan dilakukan
secara lebih efektif.

12
 Pada praktiknya sebuah struktur data memiliki elemen yang digunakan untuk
saling menyimpan rujukan antara satu dengan lainnya sehingga membentuk sebuah
senarai abstrak, tiap-tiap elemen yang terdapat pada senarai abstrak ini seringkali
disebut sebagai node. karena mekanisme rujukan yang saling terkait inilah disebut
sebagai senarai berantai.
Linked List atau dikenal juga dengan sebutan senarai berantai adalah struktur
data yang terdiri dari urutan record data dimana setiap record memiliki field yang
menyimpan alamat/referensi dari record selanjutnya (dalam urutan). Elemen data
yang dihubungkan dengan link pada Linked List disebut Node.
Biasanya didalam suatu linked list, terdapat istilah head dan tail. 
 Head adalah elemen yang berada pada posisi pertama dalam suatu linked list
 Tail adalah elemen yang berada pada posisi terakhir dalam suatu linked list

A. Deklarasi Variabel

Type Simpul = ^Tali ;

Tali = record
Info : char;
Berikut : Simpul
end;
Var elemen : char ;
Awal, Akhir, Baru : Simpul;
Cacah : integer;

B. Prosedur Tambah Data

1) Pada Data Awal

procedure TAMBAH_AWAL (N : integer);

var
baru : simpul;
begin
if N <> 0 then
begin
writeln('MENAMBAH SIMPUL BARU DI AWAL SENARAI
BERANTAI');
end;
writeln;

13
 baru := SIMPUL_BARU;
if awal=nil then
akhir:= baru
else
baru^.berikut := awal;
awal := baru;
end;

2) Pada Data Tengah

procedure TAMBAH_TENGAH;
var baru,bantu : simpul;
posisi,i : integer;
begin
writeln ('MENAMBAH SIMPUL BARU DI TENGAH SENARAI
BERANTAI');
writeln(garis); writeln;
writeln('SENARAI BERANTAI BERISI:',cacah:2,' SIMPUL');
repeat
write(' ');
write('SIMPUL BARU AKAN DITEMPATKAN SEBAGAI SIMPUL
NOMOR: ');
readln(posisi)
until posisi in [1..cacah+1];
if posisi=1 then
TAMBAH_AWAL(0)
else if
posisi=cacah+1 then TAMBAH_AKHIR(0)
else
begin
writeln;
baru := SIMPUL_BARU;
bantu:= awal;
for i:=1 to posisi-2 do
bantu := bantu^.berikut;
baru^.berikut := bantu^.berikut;
bantu^.berikut := baru;

14
 end;
end;

3) Pada Data Akhir

procedure TAMBAH_AKHIR (N : integer);

var
baru : simpul;
begin
if N <> 0 then
begin
writeln('MENAMBAH SIMPUL BARU DI AKHIR SENARAI
BERANTAI');
end;
writeln;
baru := SIMPUL_BARU;
if awal=nil then
awal := baru
else
akhir^.berikut := baru;
akhir := baru;
end;

C. Prosedur Hapus Data

1) Pada Data Awal

procedure HAPUS_PERTAMA;
begin
if awal <> nil then
begin
awal := awal^.berikut;
writeln('SIMPUL PERTAMA TELAH TERHAPUS');
end
else
writeln(pesan);

15
 writeln; writeln('TEKAN <RETURN> UNTUK KEMBALI KE MENU
UTAMA');
repeat until keypressed
end;

2) Pada Data Tengah

procedure HAPUS_TENGAH;
var posisi,i : integer;
bantu,bantu1 : simpul;
begin
if cacah=0 then
begin
writeln(pesan); writeln;
writeln('TEKAN <RETURN> UNTUK KEMBALI KE MENU UTAMA');
repeat until keypressed
end;
else
begin
writeln('MENGHAPUS SIMPUL YANG ADA DI TENGAH');
writeln;
writeln('SENARAI BERANTAI SEKARANG BERISI :',cacah:2,' SIMPUL');
repeat
gotoxy(37,5);
gotoxy(1,5); write('Akan menghapus simpul nomor berapa: ');
readln(posisi);
until posisi in [1..cacah];
if posisi=1 then HAPUS_PERTAMA
else if posisi=cacah then HAPUS_TERAKHIR
else
begin
bantu := awal;
for i:=1 to posisi-2 do
bantu:= bantu^.berikut;
bantu1 := bantu^.berikut;
bantu^.berikut := bantu1^.berikut;
bantu1^.berikut := nil;

16
 dispose(bantu1);
end;
end;
end

3) Pada Data Akhir

procedure HAPUS_TERAKHIR;
var bantu : simpul;
H: integer;
begin
if awal=nil then
begin
writeln(pesan);
H := 0;
end
else if awal=akhir then
begin
awal := nil;
akhir:= nil;
H := 1;
end
else
begin
bantu := awal;
while bantu^.berikut <> akhir do
bantu := bantu^.berikut;
akhir := bantu;
akhir^.berikut := nil;
H := 1;
end;
if H=1 then
writeln('SIMPUL TERAKHIR TELAH TERHAPUS'); writeln;
writeln('TEKAN <RETURN> UNTUK KEMBALI KE MENU UTAMA');
repeat until keypressed
end;

17
D. Prosedur Tampil Data

procedure MENAMPILKAN_SENARAI;
var bantu : simpul; i : integer;
begin
i := 1;
writeln('MENAMPILKAN ISI SENARAI BERANTAI');
writeln('TEKAN <RETURN> UNTUK KEMBALI KE MENU UTAMA');
writeln;
bantu := awal;
if bantu=nil then
writeln(pesan)
else
while bantu <> nil do
begin
writeln('Simpul: ',i:2,'---> Nama : ',bantu^.nama);
writeln('':15,'Alamat: ',bantu^.alamat);
bantu := bantu^.berikut;
inc(i); //increment//
end;
repeat until keypressed
end;

E. Prosedur Cari Data

procedure CARI_DATA;
var bantu : simpul;
i : integer;
begin
i := 1;
writeln('MENCARI DATA TERTENTU');
bantu:=awal;
if bantu^.nmbuku=bantu^.nmbuku then
begin
writeln('Nama : ', bantu^.nama:5);
writeln('Alamat : ', bantu^.alamat);
end else

18
 writeln('Data Dengan No ',bantu^.:5,'tidak ada');
end;

4. Senarai Berantai Berkepala

A. Pengertian Senarai Berantai Berkepala

Suatu saat kita perlu meletakkan sebuah simpul sebagai simpul pertama dari
sebuah senarai berantai. Simpul ini tidak berisi informasi seperti halnya simpul-
simpul lain, tetapi keberadaannya sangat diperlukan untuk lebih mempercepat
proses eksekusi. Simpul yang demikian disebut dengan simpul kepala (headed
node), sehingga senarai berantai disebut senarai berantai berkepala (headed-
linked-list).
Proses penghapusan simpul sering mengalami masalah terutama penghapusan
simpul akhir yang mana penghapusan hanya boleh dilakukan jika jumlah simpul
dalam senarai lebih dari satu, hal ini tidak efisien jika harus dilakukan
penghapusan semua simpul dengan penghapusan dimulai dari simpul yang paling
akhir dimana ketika senarai hanya memiliki satu simpul harus mengganti metode
penghapusan.
Untuk mengatasi hal tersebut dapat dibuat senarai berantai berkepala yaitu
menambahkan sebuah simpul yang biasaya tidak memiliki informasi atau nilai,
namun demikian tidak tertutup kemungkinan digunakan untuk kepentingan lain
misalnya mencatatkan jumlah simpul yang ada dalam senarai ataupun informasi
lain, tapi secara pasti tidak menyimpan informasi yang sama dengan informasi
yang ada pada simpul lainnya

B. Pendeklasian Beserta Contohnya

Deklarasinya
Simpul = ^data
Data = record
info : tipedata
next : Simpul
end
Membentuk simpul
Kepala
New(Kepala)

19
Kepala^.next = nil

Jika kepala^.next <> nil maka

Baru^.next = Kepala^.next
Kepala^.next= baru

Program Pascalnya
New(baru)
Baru^.info = x
If kepala^.next = nil
Then
Baru^.next = nil
kepala^.next = baru
Else
Baru^.next = kepala^.next
Kepala^.next = baru

C. Menambah Simpul tengah & akhir & Hapus Simpul

Menambah Simpul di akhir pada senarai berantai berkepala, pada prinsipnya

sama dengan penambahan simpul pada senarai berantai yang sudah dibahas
sebelumnya, tetapi penelusuran dilakukan dengan menempatkan akhir = kepala,
dengan demikian tidak perlu dilakukan pengecekan apakah list masih kosong
atau tidak,
Dan untuk penambahan simpul tengah adalah sama, tetapi penelusuran bantu
dilakukan mulai dari kepala
(bantu = kepala)
Procedure Tambah2(x : tipedata) Procedure tambah2b(x : tipedata);
New(baru)
New(baru)
Baru^.info = X
Baru^.Next = nil Baru^.info = x
If awal = nil Baru^.next = nil
Then
Akhir = kepala
Awal = baru
Else While akhir^.next<> nil do
Akhir = awal akhir = akhir^.next
While akhir^.next <> nil Endwhile
Akhir^.next = baru
20
 Do
Akhir = Akhir^.next
endwhile
akhir^.next = baru

Procedure Hapus Simpul

Procedure HAPUS_SIMPUL (var kepala : Simpul; Elemen : char);
Var Bantu, Hapus : Simpul;
Begin
if Kepala = Nil then
writeln(‘Senarai masih kosong, tidak mungkin dihapus’);
else
if Kepala^.Info = Elemen then
begin
kepala := Hapus^.Berikut;
dispose(Hapus);
end
else
begin
Bantu := Kepala^.Berikut;
while (Elemen <> Bantu^.Info) and (Bantu^.Berikut <> nil) do
Hapus :=Bantu^.Berikut;
end;

Prosedur Membaca dan Mencari Data

Procedure BACA_MAJU (Kepala: Simpul);
Var Bantu : Simpul;
Begin
Bantu := kepala^.next;
repeat
write(Bantu^.Info:2);
Bantu := Bantu^.Berikut;
Until Bantu = Nil;
writeln;
End;

Fungsi untuk mencari (tidak terurut)

21
 function ADA_DATA (Elemen : char; Kepala : Simpul) : boolean;
Var Ketemu : boolean;
Bantu : Simpul;
Begin
Bantu := Kepala;
Ketemu := false;
repeat
If Bantu^.Info = Elemen then
Ketemu := true
Else
Bantu := Bantu^.Berikut
Until Ketemu Or (Bantu = Nil);
ADA_DATA := Ketemu;
End;
Fungsi untuk mencari (terurut)
function ADA_DATA (Elemen : char; Kepala : Simpul) : boolean;
Var Ketemu : boolean;
Bantu : Simpul;
Begin
Bantu := Kepala;
Ketemu := false;
repeat
If Bantu^.Info = Elemen then
Ketemu := true
Else
if Bantu^.Info < Elemen then
Bantu := Bantu^.Berikut
Else Bantu := Nil;
Until Ketemu Or (Bantu = Nil);
ADA_DATA := Ketemu;
End;

5. Senarai Berantai Sebaai Stack Menggunakan Array dan Record

A. Pengertian Senarai Berantai Berkepala

22
 Merupakan satu dari berbagai varian sebuah “Linked list”, sebuah Senarai
berkepala (Header Linked List) memiliki sebuah node khusus yang hadir diawal yang
digunakan untuk menyimpan jumlah node yang ada pada senarai berantai.

B. PENGERTIAN STACK
Stack (tumpukan) sebenarnya secara mudah dapat diartikan sebagai list (urutan)
dimana penambahan dan pengambilan elemen hanya dilakukan pada satu sisi yang
disebut top (puncak) dari stack.Dengan melihat definisi tersebut maka jelas bahwa
pada stack berlaku aturan LIFO (Last In First Out), yaitu elemen yang terakhir masuk
akan pertama kali diambil atau dilayani. Salah satu analogi yang dapat dikemukakan
di sini adalah tumpukan piring atau barang lain.

C. Pengertian Array Dan Pointer

1. Senarai berantai berkepala sebagai stack menggunakan pointer
Tipe data pointer adalah tipe data yang berisi alamat memory dari sebuah
variabel.

23
2. Senarai berantai berkepala sebagai stack menggunakan array
Array merupakan variabel yang terdiri dari sekumpulan data yang mempunyai
tipe data yang sama dan disimpan pada alamat memori yang berbeda-beda dan
hanya bisa diakses melalui nilai indeks sesuai urutan.

D. Operasi Stack

Operasi yang terdapat pada stack :

- POP (Menambahkan elemen)
Menambahkan elemen baru pada stack, cara kerjanya yaitu dilakukan
penambahan elemen baru kedalam stack yang dimulai dari awal.

- PUSH (Menghapus elemen)

Menghapus elemen yang ada pada stack, cara kerjanya yaitu dilakukan
penghapusan mulai dari elemen puncak stack.

- IsFull (Keadaan stack penuh)

jika Kondisi stack penuh maka hal tersebut dikatakan ful, dan untuk mengetahui
apakah stack dalam keadaan penuh maka kita bias menggunakan operasi isfull
untuk mengecek apakah full dalam keadaan penuh atau kosong.

- IsEmpty (Keadaan stack kosong)

Untuk mengecek apakah stack dalam keadaan kosong atau tidak maka kita bisa
menggunakan operasi IsEmpty.

24
E. Deklarasi Stack Menggunakan Senarai Berkepala

F. Prosedur Menambah, Menghapus, Menampilkan Dan Mencari Data Pada

Senarai Berantai Berkepala Sebagai Stack Menggunakan Array Atau Pointer

25
Perbedaan implementasi antara senarai berantai sebagai stack menggunakan array
dan yang menggunakan pointer.
Implementasi stack menggunakan array memiliki kapasitas penyimpanan elemen
data yang terbatas (diberikan Batasan oleh tipe data array) dan hanya bisa diakses
melalui indeks. Sedangkan menggunakan pointer kita tidak memiliki batas
penyimpanan data, atau dengan kata lain dapat menyimpan elemen data hingga tak
terhingga.

26
6. Senarai Berntai Berputar Berkepala

A. Pengertian Senarai Berantai Berputar Berkepala

Seperti yang kita ketahui Senarai berantai yang selalu dipelajari sampai saat
ini merupakan senarai yang mempunyai pointer yang berisi nil pada simpul
terakhir, kerugiannya adalah bahwa untuk membaca seluruh isi senarai berantai
harus selalu dilakukan dari simpul pertama. Untuk itu kita memerlukan satu variasi
senarai berantai yang disebut senarai berantai berputar (Circular Linked-List)

Contoh Senarai Berantai Berputar yang masih

kosong (Belum Terisi)

A B C D

Contoh Senarai Berantai Berputar yang sudah terisi

Senarai Berantai Berputar adalah senarai biasa dimana pointer pada simpul
terakhir diarahkan kembali kepada simpul pertama. Dalam hal ini pointer dari simpul
terakhir diarahkan kembali ke simpul kepala, dengan demikian kita tidak mempunyai
simpul yang bernilai nil.
B. Pendeklarasian Beserta Contoh Prosedur/Fungsinya

Procedure INISIALISISASI (var Kepala : Simpul);

Begin
new(Kepala);
Kepala^.Berikut:= Kepala;
End;
{Diperlukan adanya simpul kepala agar inisialisasi ini bisa
dieksekusikan}

27
Prosedur menambah simpul didepan
Procedure TambahAwal(var kepala:simpul;elemen: char);
Var baru,bantu: simpul;
Begin
new(Baru)
baru^.info = elemen;
if kepala^.berikut = kepala then
begin
baru^.berikut := kepala;
kepala^.berikut := baru;
end
else
begin
baru^.berikut := kepala^.berikut;
kepala^.berikut := baru;
end;
End;

Prosedur menambah simpul ditengah

procedure TambahTengah(var Kepala:Simpul;Elemen:Char);
var Baru,Bantu:Simpul;
begin
new(Baru);
Baru^.Info:=Elemen;
If Kepala^.Berikut=Kepala Then
begin
Kepala^.Berikut:=Baru;
Baru^.Berikut:=Kepala;
end
else
begin
Bantu:=Kepala;
While (Bantu^.Berikut^.Info < Elemen) And
(Bantu^.Berikut<>Kepala) Do

28
 Bantu:=Bantu^.Berikut;
if Bantu^.Berikut<>Kepala Then
Baru^.Berikut:=Bantu^.Berikut
else
Baru^.Berikut:=Kepala;
Bantu^.Berikut:=Baru;
end;
end;

Prosedur menambah simpul dibelakang

KEPALA BARU

A B C D E

KEPALA BANTU BARU

A B C D E

KEPALA BARU & BANTU

A B C D E

Procedure TambahAkhir (var Kepala:simpul;elemen:char);

Var baru,bantu : simpul;
Begin
new(baru);
baru^.info:= elemen;
if Kepala^.berikut = kepala then
begin
baru^.berikut := kepala;
kepala^.berikut := baru;
bantu := baru;
end
else
begin
bantu:=kepala^.berikut;

29
 while bantu^.berikut <> kepala do
bantu:= bantu^.kepala;
baru^.berikut:= kepala;
bantu^.berikut:= baru;
end;
End;

Function menghapus simpul

KEPALA BANTU HAPUS

A B C D E

KEPALA BANTU HAPUS

A B C D E

KEPALA BANTU AKHIR

A B C D

function HapusSimpul (var Kepala:Simpul;var Kosong:Boolean; Elemen:char)

:Boolean;
var Bantu,Hapus:Simpul;
Ada:Boolean;
begin
If Kepala^.Berikut=Kepala Then
Kosong:=True
else if Kepala^.Berikut^.Info=Elemen Then
begin
Ada:=True;
Kosong:=False;
Hapus:=Kepala^.Berikut;
Kepala^.Berikut:=Hapus^.Berikut;
Dispose(Hapus);

30
 end
else
begin
Kosong:=False;
Ada:=False;
Bantu:=Kepala^.Berikut;
While (Bantu^.Berikut^.Info <> Elemen) and (Bantu<>Kepala) Do
Bantu:=Bantu^.Berikut;
Hapus:=Bantu^.Berikut;
If Bantu<>Kepala Then
begin
Ada:=True;
Bantu^.Berikut:=Hapus^.Berikut;
dispose(Hapus);
end;
end;
HapusSimpul:=Ada;
end;

Prosedur menampilkan data

procedure LihatData(Kepala:Simpul);
var Bantu:Simpul;
begin
if Kepala^.Berikut<>Kepala Then
begin
Bantu:=Kepala^.Berikut;
Repeat
write(Bantu^.Info:3);
Bantu:=Bantu^.Berikut;
Until Bantu=Kepala;
end
else
writeln('Senarai Kosong....!!!');
readkey;
end;

31
Function mencari data (Tidak Terurut)
Function CariData (Elemen: char; kepala: simpul):boolean;
Var ketemu:boolean;
bantu: simpul;
Begin
bantu:= kepala^.berikut;
Ketemu:= false;
repeat
if bantu^.info = elemen then
ketemu:= true
else
bantu:= bantu^.berikut;
until Ketemu Or (Bantu = kepala);
CariData:= ketemu;
End;

Function mencari data (Terurut)

Function CariData (Elemen:char; Kepala:simpul):boolean;
Var ketemu: boolean;
bantu: simpul;
Begin
Bantu:=kepala^.berikut;
Ketemu:=false;
repeat
if Bantu^.info = elemen then
ketemu:= true
else
if elemen > bantu^.info then
bantu:= bantu^.berikut
else bantu:= kepala;
until Ketemu Or (Bantu = Kepala);
CariData:=ketemu;
End;

32
7. Senarai Berantai Ganda Berkepala

Senarai Berantai Ganda merupakan Senarai berantai yang dimana memiliki

dua arah (two-way list), Setiap simpulnya mempunyai 2 buah pointer dengan pointer
pertama menunjuk ke simpul sebelumnya dan pointer kedua ke simpul sesudahnya.

Deklarasi Senarai Berantai Ganda

Deklarasi A B C
Type Simpul = ^data
data = record
info : char;
kiri, (* merupakan pointer ke kiri )
kanan : simpul; (* merupakan pointer ke kanan )
End;
Var kepala : simpul;

Inisialisasi Senarai Berantai Ganda

Procedure inisialisasi ( var kepala : simpul );
Begin
New(kepala);
With kepala^ do
Begin
Kiri := nil;
Kanan := nil;
End;
End;

Tambah Data dalam Senarai Berantai Ganda

1) Penambahan pada bagian depan
Baru^.kanan := Kepala^.kanan;
Baru^.Kiri := Kepala;
Kepala^.kanan^.kiri := baru;
Kepala^.kanan := baru;

33
2) Penambahan pada bagian Tengah
Baru^.kanan := Bantu^.kanan;
Baru^.Kiri := Bantu;
Bantu^.kanan^.kiri := baru;
Bantu^.kanan := baru;

3) Penambahan pada bagian Akhir

Bantu^.kanan := Baru
Baru^.Kiri := Bantu;

Prosedur untuk menambahkan simpul baru pada senarai berantai ganda adalah
sebagai berikut :
Procedure Tambah_Simpul ( var kepala : simpul; elemen : char);
Var Baru , bantu : simpul;
Begin
New(baru);
With baru^ do
Begin
Info := elemen;
Kiri := nil;
Kanan := nil;
End;
Bantu := kepala;
While bantu^.kanan^.info < elemen do
Bantu := bantu^.kanan
If bantu^.kanan <> nil then
Begin
Baru^.kanan := bantu^.kanan;
Bantu^.kanan^.kiri := baru
End;
Bantu^.kanan := baru;
Baru^.kiri := bantu;
End;

Hapus simpul pada Senarai berantai ganda

Procedure hapus_data ( var kepala : simpul; elemen : char);

34
Var bantu : simpul;
Begin
If kepala^.kanan = nil then
Writeln(‘Senarai kosong’)
Else
Begin
Bantu := kepala;
Repeat
Bantu := bantu^.kanan;
Until (bantu^.info = elemen) or (bantu = nil);
If bantu^.info = elemen then
Begin
Bantu^.kiri^.kanan := bantu^.kanan;
Bantu^.kanan^.kiri := bantu^.kiri;
Dispose(bantu);
Bantu := kepala;
End;
Else writeln(‘ data tidak ada ’);
End;
End;

Lihat Maju Simpul Pada Senarai Berantai Ganda

Procedure lihat_data ( kepala : simpul; elemen : char);
Var bantu : simpul;
Begin
If kepala^.kanan = nil then
Writeln(‘Senarai kosong, tambahkan data terlebih dahulu’);
Else
Begin
Bantu := kepala^.kanan;
Repeat
Writeln( bantu^.info :3);
Bantu := bantu^.kanan;
Until (bantu = nil);
End;
End;

35
Lihat Mundur Simpul Pada Senarai Berantai Ganda
Procedure lihat_data ( kepala : simpul; elemen : char);
Var bantu : simpul;
Begin
If kepala^.kanan = nil then
Writeln(‘Senarai kosong, tambahkan data terlebih dahulu’);
Else
Begin
Bantu := kepala;
Repeat
Bantu := bantu^.kanan;
Until ( bantu^.kanan = nil );
Repeat
Write(bantu^.info:3);
Bantu := bantu^.kiri;
Until ( bantu^.kiri = nil );
End;
End;

Cari simpul pada Senarai berantai ganda

Procedure cari_data ( kepala : simpul; elemen : char);
Var bantu : simpul;
Begin
If kepala^.kanan = nil then
Writeln(‘Senarai kosong, tambahkan data terlebih dahulu’);
Else
Begin
Bantu := kepala;
Repeat
Bantu := bantu^.kanan;
Until (bantu^.info = elemen) or (bantu = nil);
If bantu^.info = elemen then
Begin
Writeln(‘Data Ditemukan !’);
Bantu := kepala;

36
 End;
Else writeln(‘ Data tidak ada ’);
End;
End;

8. Senarai Berantai Ganda Berputar Berkepala

A. Pengertian
Pada senarai bernatai ganda,pointer kiri dari sampul pertama dan pointer
kanan dari simpul terakhir masi bernilai nil, bila pointer kiri kita arahkan ke
ismpul akhir dan pointer kanan dari simpul terakhir kita arahkan ke simpul kepala,
senarai yang demikian dinamakan senarai berantai ganda berputar. Dan berkepala.

Prosedur inisialisasi simpul kepala tersebut sebagai berikut:

Procedure INISIALISASI_SBGBB (var Kepala : Simpul);

Begin
New(Kepala);
With Kepala^ do
begin
Kiri := Kepala;
Kanan := Kepala
end
End;
Prosedur Untuk Penambahan Simpul Pada Senarai Berantai Ganda
Berputar Berkepala Sebagai Berikut:
Procedure TAMBAH_SIMPUL (var Kepala : Simpul;Elemen : char);
Var Baru, Bantu : Simpul;
Begin
New(Baru);
Baru^.Info := Elemen;
If Elemen > Kepala^.Kiri^.Info then
Begin
Baru^.Kiri := Kepala^.Kiri;
Baru^.Kanan := Kepala;
Kepala^.Kiri^.Kanan := Baru;

37
 Kepala^.Kiri := Baru
End;
Else
begin
Bantu := Kepala;
While Bantu^.Kanan^.Info < Elemen do
Bantu := Bantu^.Kanan;
Baru^.Kanan := Bantu^.Kanan;
Bantu^.Kanan^.Kiri := Baru;
Bantu^.Kanan := Baru;
Baru^.Kiri := Bantu
end
End;
Prosedur Untuk Menghapus Simpul Pada Senarai Berantai Ganda Berputar
Berkepala Sebagai Berikut:
Procedure HAPUS_SIMPUL (var Kepala : Simpul;
Elemen : char);
Var Bantu : Simpul;
Begin
If Kepala^.Kanan = Kepala then
Writeln(‘Senarai kosong’)
else
Begin
Bantu := Kepala;
repeat
Bantu := Bantu^.Kanan;
Until (Bantu^.Info = Elemen) or (Bantu = Kepala);
If Bantu^.Info = Elemen then
begin
Bantu^.Kiri^.Kanan := Bantu^.Kanan;
Bantu^.Kanan^.Kiri := Bantu^.Kiri;
Dispose(Bantu);
Bantu := Kepala
End
Else
Writeln(‘Karakter di atas tidak ada’)

38
 end
End;

9. Antran (Queque) Menggunakaan Array dan record

Queue/antrian adalah suatu kumpulan data di mana penambahan data hanya

bisa dilakukan pada suatu ujung yang disebut sisi belakang atau rear dan
penghapusan data dilakukan pada ujung lainnya yang disebut sisi depan atau front.
Jika tumpukan menggunakan prinsip LIFO (Last In, First Out), maka queue/antrian
menggunakan prinsip FIFO (First In, First Out) sehingga elemen yang lebih dulu
masuk akan juga lebih dulu diambil/keluar.

Dalam bidang computer sendiri, kita dapat menggunakan antrian dalam

bentuk pemakaian sistem computer berbagi waktu (time-sharing computer system).
Sistem ini menggunakan sebuah prosesor dan sebuah pengingat utama, maka jika
prosesor sedang dipakai, pemakai lain harus antri sampai gilirannya tiba. Antrian ini
mungkin tidak dilayani secara FIFO murni tetapi berdasarkan suatu prioritas tertentu.
Antrian yang memasukkan unsur prioritas dinamakan dengan antrian berprioritas
(priority queue).

Gambar 2.1

Gambar diatas menunjukkan contoh penyajian antrian menggunakan

larik. Antrian di atas berisi 6 elemen, yaitu A, B, C, D, E dan F. Elemen A
terletak dibagian depan antrian dan elemen F terletak di bagian belakang antrian.
Jika ada elemen baru yang akan masuk, maka ia akan diletakkan di sebelah
kanan F sedangkan jika elemen dihapus, maka A akan terhapus lebih dahulu.

39
 Gambar 2.2

Gambar 2.3

Gambar 2.2 menunjukkan penambahan data G dan H dari gambar 2.1

yang menyebabkan bagian belakang yang awalnya berada di F, berpindah ke H.
Sedangkan gambar 2.3 menunjukkan penghapusan data yang dilakukan 2 kali
sehingga A dan B terhapus dan bagian depan berpindah ke C.
Operasi penambahan elemen baru selalu bisa kita lakukan karena tidak
ada pembatasan banyaknya elemen dari suatu antrian. Tetapi untuk menghapus
elemen, maka kita harus melihat apakah antrian dalam keadaan kosong atau
tidak.
Untuk menyajikan antrian menggunakan larik, maka kita membutuhkan
deklarasi antrian, misalnya, sebagai berikut:
const Max_Elemen = 100;
type Antri = array[1..Max_Elemen] of integer;
var Antrian : Antri;

40
 Depan;
Belakang : integer;

Dalam deklarasi di atas, elemen antrian dinyatakan dalam tipe integer.

Peubah depan menunjukkan posisi elemen pertama dakan larik; peubah belakang
menunjukkan posisi elemenn terakhir dalam larik. Dengan menggunakan larik,
maka kejadian overflow sangat mungkin, yakni jika antrian telah penuh,
sementara kita masih ingin menambah terus. Dengan mengabaikan kemungkinan
adanya overflow, maka penambahan elemen baru, yang dinyatakan oleh peubah
X, kita bisa mengimplementasikannya dengan statemen.
Belakang := Belakang + 1;
Antrian[Belakang] := x;

Operasi penghapusannya bisa diimplementasikan dengan :

X := Antrian[Depan];
Depan := depan + 1;

Pada saat permulaan, belakang dibuat sama dengan 0 dan depan dibuat
sama dengan 1, dan antrian dikatakan kosong jika belakang < depan. Banyaknya
elemen yang ada dalam antrian dinyatakan sebagai belakang – depan + 1.

41
 Gambar c) menunjukkan antrian setelah dua elemen dihapus (Depan = 3
dan Belakang = 4). Gambar d) menunjukkan antrian setelah dua elemen baru
ditambahkan (Depan = 3 dan Belakang = 6). Dalam hal ini banyaknya elemen
dalam antrian adalah 6 – 3 + 1 = 4 elemen. Karena larik terdiri dari 6 elemen,
maka sebenarnya kita masih bisa menambahkan elemen lagi. Tetapi, jika kita
ingin menambahkan elemen baru maka nilai Belakang harus ditambah satu,
menjadi 7.
Salah satu penyelesaiannya adalah dengan mengubah prosedur untuk
menghapus elemen, sedemikian rupa sehingga jika ada elemen yang dihapus,
maka semua elemen lain digeser sehingga antrian selalu dimulai dari Depan = 1,
Dengan cara ini, maka sebenarnya perubah Depan ini tidak diperlukan lagi hanya
perubah Belakang saja yang diperlukan, karena nilai Depan selalu sama dengan
1. Berikut adalah rutin penggeserannya (dengan mengabaikan kemungkinan
adanya underflow).
X := Antrian[1];
For I := 1 to Belakang - 1 do
Antrian [1] := Antrian[I+1];
Belakang := Belakang - 1;
Dalam hal ini antrian kosong dinyatakan sebagai nilai Belakang = 0.
Program Pascal Queue/Antrian Menggunakan Array, Sebagai Berikut:
a. Untuk Menambah Data
procedure inisialisasi;
begin
depan:=0;

42
 belakang:=0;
n:=0;
end;

procedure tambah_data(var antrian:antri);

var x:integer;
lagi:char;
begin
repeat
clrscr;
writeln('TAMBAH DATA');
writeln('===========');
writeln;
write('Masukkan data : '); readln(x);
if belakang=maks then
belakang:= 1
else
belakang:= belakang+1;
if depan=belakang then
begin
writeln('Antrian Sudah Penuh!!!');
if belakang=1 then
belakang:=maks
else
belakang:=belakang-1;
end
else
begin
antrian[belakang]:=x;
n:=n+1;
if depan=0 then depan:=1;
end;
write('Tambah data lagi? [Y/T] : '); readln(lagi);
lagi:=upcase(lagi);
until lagi<>'Y';
end;

43
b. Untuk Menghapus Data
procedure hapus_data(var antrian:antri);
begin
clrscr;
writeln('HAPUS DATA');
writeln('==========');
writeln;
if n=0 then
write('Antrian Kosong!!!')
else
begin
if depan=maks then
depan:=1
else
depan:=depan+1;
writeln('Antrian telah terhapus');
n:=n-1;
end;
readkey;
end;

c. Untuk Menampilkan Data

procedure tampilkan_data(antrian:antri);
var i:integer;
begin
clrscr;
writeln('LIHAT DATA');
writeln('==========');
writeln;
if n=0 then
write('Antrian Kosong!!!')
else
begin
i:=depan;
writeln(depan,belakang);
repeat
write(antrian[i]:3);

44
 if i=maks then
i:=1
else
i:=i+1;
until i=belakang;
if i=belakang then
write(antrian[i]:3);
end;
readkey;
end;

d. Untuk Mencari Data

procedure cari_data(antrian:antri);
var idx,i,x:integer;
ketemu:boolean;
begin
ketemu:=false;
clrscr;
writeln('CARI DATA');
writeln('=========');
writeln;
if n=0 then
write('Antrian Kosong...')
else
begin
write('Masukkan data yang ingin dicari : ');
readln(x);
i:=depan;
repeat
if antrian[i]=x then
begin
ketemu:=true;
idx:=i;
i:=i+1;
end
else i:=i+1;
until i=belakang;

45
 if i=belakang then
if antrian[i]=x then
begin
ketemu:=true;
idx:=i;
end;
if not ketemu then
writeln('Data Tidak Ditemukan!')
else
writeln('Data ',x,' ditemukan pada indeks ke',idx);
end;
readkey;
end;

10.Pohon Biner
a. Pengertian Binary Tree
Pohon biner merupakan jenis pohon m-er (m-ary tree) yang simpul cabangnya
memiliki maksimal dua anak. Karena anak dari suatu cabang maksimalnya hanya
dua, maka anak cabang ini namakan vabang kiri atau cabang kanan.

Karakteristik Pohon Biner (Binary Tree:

1. Setiap simpul paling banyak hanya memiliki dua buah anak

2. Derajat tertinggi darisetiap simpul adalah dua

3. Dibedakan antara cabang kiri dan cabang kanan

46
 Proses traversing dari sebuah binary tree artinya melakukan kunjungan pada
setiap simpul pada suatu pohon biner tepat satu kali. Dengan melakukan kunjungan
secara lengkap, kita akan memperoleh informasi secara linear yang tersimpan
dalam pohon biner. Secara linear dimaksudkan secara garis lurus atau searah.
Dalam melakukan kunjungan pada sebuah pohon biner, kita akan memperlakukan
hal yang sama pada setiap simpul pada cabang-cabangnya.

Beberapa terminologi pada pohon biner :

• Simpul akar (root) sebagai simpul pohon dengan tingkatan tertinggi

• Simpul daun (leaf) simpul-simpul pada pohon yang tidak lagi memiliki simpul
anak (child)

• Induk (parent) simpul yang merupakan induk dari children-nya

• Anak dari simpul x akar-akar (root) dari subpohon–subpohon dari simpul x adalah
anak dari x

• Siblings anak dari induk yang sama

47
b. Mendeklarasikan Pohon Biner

Type Tree = ^simpul;

simpul = record

info : char;

kiri, (*** pointer ke cabang kiri ***)

kanan : tree (*** pointer ke cabang kanan ***)

end;

c. Mendeklarasikan Membuat Simpul baru

FUNCTION BARU(Hrf : char) : tree;

Var akar : tree;

Begin

new(akar)

48
 akar^.info := Hrf ;

akar^.kanan:= nil;

akar^.kiri := nil;

BARU := akar

End;

d. Mendeklarasikan Menyisipkan Simpul Baru

Procedure sisip_rekursif (var akar : tree; hrf : char);

Begin

if pohon = nil then

pohon := BARU(Hrf)

else

if pohon^.info > hrf then

sisip_rekursif(akar^.kiri,hrf);

else

if pohon^.info < hrf then

sisip_rekursif(akar^.kanan,hrf);

else

writeln(‘Karakter ‘,hrf,’ sudah ada dalam pohon ‘);

End

e. Mendeklarasikan Menampilkan simpul Pohon

Menampilkan simpul pohon ada tiga jenis, yakni secara inorder, preorder dan postorder.
Menampilkan secara PreOrder (Depth First Order)
Mempunyai urutan :

49
 a) Cetak isi simpul yang dikunjungi (simpul akar)
b) Kunjungi cabang kiri
Jika kiri bukan kosong (tidak Null) mulai lagi dari langkah pertama,terapkan untuk kiri
tersebut. Jika kiri kosong (Null), lanjutkan ke langkah ke tiga.
c) Kunjungi cabang kanan
Jika kanan bukan kosong (tidak Null) mulai lagi dari langkah pertama,terapkan untuk
kanan tersebut. Jika kanan kosong (Null), proses untuk node ini selesai,tuntaskan proses
yang sama untuk node yang dikunjungi sebelumnya.

Procedure preorder ( akar : tree);

if root <> nil then

begin

write(akar^.info : 4);

preorder(akar^.kiri);

preorder(akar^.kanan);

end;

End;

Menampilkan Secara InOrder (Symmetric Order)

Mempunyai urutan :
a) Kunjungi cabang kiri
Jika kiri bukan kosong (tidak Null) mulai lagi dari langkah pertama, terapkan untuk kiri
tersebut. Jika kiri kosong (Null), lanjut ke langkah kedua.
b) Cetak isi simpul yang dikunjungi (simpul akar)
c) Kunjungi cabang kanan.
Jika kanan bukan kosong (tidak Null) mulai lagi dari langkah pertama, terapkan untuk
kanan tersebut. Jika kanan kosong(Null), proses untuk node ini selesai. Tuntaskan proses
yang sama untuk node yang dikunjungi sebelumnya.

Procedure inorder (akar : tree);

if root <> nil then

begin

50
 inorder(akar^.kiri);

write(akar^.info : 4);

inorder(akar^.kanan);

end;

End;

Kunjungan secara PostOrder

Mempunyai urutan:
a) Kunjungi cabang kiri
Jika kiri bukan kosong (tidak Null) mulai lagi dari langkah pertama, terapkan untuk kiri
tersebut. Jika kiri kosong (Null),lanjut kelangkah kedua.
b) Kunjungi cabang kanan
Jika kanan bukan kosong (tidak Null) mulai lagi dari langkh pertama,terapkan untuk
kanan tersebut. Jika kanan kosong (Null),proses untuk node ini selesai, tuntaskan proses
yang sama untuk node yang dikunjungi sebelumnya.
c) Cetak isi simpul yang dikunjungi (simpul akar)

Procedure postorder (akar : tree);

if root <> nil then

begin

postorder(akar^.kiri);

postorder(akar^.kanan);

51
 write(akar^.info : 4);

end;

End;
Pada ketiga cara kunjungan diatas, kunjungan kecabang kiri dilakukan terlebih dahulu, baru
kemudian kunjungan kecabang kanan. Dengan orientasi semacam ini ketiga kunjungan diatas
disebut dengan left to right oriented atau LRO. Jika kunjungan ke cabang kanan dilakukan lebih
dahulu baru kemudian kunjungan kecabang kiri, maka orientasi semacam ini disebut right to left
oriented atau RLO.

52
53