Buku Ku

Kata Pengantar
Puji syukur alhamdulillah kami panjatkan ke hadirat Tuhan Yang
Maha Esa, karena telah melimpahkan rahmat-Nya berupa kesempatan dan
pengetahuan sehingga buku ini bisa selesai pada waktunya.
Terima kasih juga kami ucapkan kepada teman-teman yang telah
berkontribusi dengan memberikan ide-idenya sehingga buku ini bisa disusun
dengan baik dan rapi.
Kami berharap semoga buku ini bisa menambah pengetahuan para
pembaca. Namun terlepas dari itu, kami memahami bahwa buku ini masih
jauh dari kata sempurna, sehingga kami sangat mengharapkan kritik serta
saran yang bersifat membangun demi terciptanya buku selanjutnya yang
lebih baik lagi.
Makassar, 21 Juli 2018
Penulis
ii
Daftar Isi
Kata Pengantar ...................................................................................... i

Daftar Isi ................................................................................................ ii
Bab 1 Struktur Data ............................................................................. 1
1.1 Pengertian Struktur data .................................................... 1
1.2 Pembuatan Struktur data ................................................... 4
Bab 2 Type Data ................................................................................... 7
2.1 Type Data Sederhana ........................................................ 8
2.2 Type Data Terstruktur ........................................................ 12
2.3 Type Data Pointer .............................................................. 15
Bab 3 Array .......................................................................................... 16
3.1 Pengertian array ................................................................ 16
3.2 Deklarasi Array .................................................................. 17
3.3 Mengakses Elemen Array .................................................. 19
3.4 Mengapa Harus Menggunakan Array ................................ 20
3.5 Array Sebagai Type Data Bentukan .................................. 23
3.6 Array Konstan .................................................................... 24
3.7 Array Sebagai Parameter .................................................. 27
3.8 Array Multidimensi ............................................................. 31
3.9 Array Dua Dimensi ............................................................. 31
3.10 Array Tiga Dimensi ............................................................ 36
iii
Bab 4 Rekursif ..................................................................................... 40
4.1 Defenisi Rekursif ................................................................ 40
4.2 Perbandingan Rekursif dengan Iteratif .............................. 43
4.3 Kesimpulan ........................................................................ 47
Bab 5 Searching .................................................................................. 48
5.1 Defenisi Searching ............................................................. 48
5.2 Metode Pencarian Beruntun .............................................. 48
5.3 Metode Pencarian Bagi Dua .............................................. 52
5.4 Kesimpulan ........................................................................ 56
Bab 6 Sorting ........................................................................................ 58
6.1 Definisi Sorting ................................................................... 58
6.2 Pengurutan Gelembung (Bubble sort) ............................... 59
6.3 Pengurutan Maksimum/Minimum ...................................... 64
6.4 Pengurutan Seleksi ............................................................ 69
Bab 7 Linked List ................................................................................. 73
7.1 Defenisi Linked List ............................................................ 74
7.2 Operasi Dasar Pada Linked List. ....................................... 76
7.3 Menghapus Suatu Node Dari Linked List (Remove) .......... 77
7.4 Menyisipkan Suatu Node Ke Dalam Linked List ................ 79
Bab 8 Stack .......................................................................................... 92
8.1 Defenisi Stack .................................................................... 92
8.2 Operasi Pada Stack ........................................................... 94
8.3 Deklarasi Stack Dalam Cobol Dan Pascal ......................... 96
8.4 Aplikasi Stack .................................................................... 100
iv
Bab 9 Queue ......................................................................................... 118
9.1 Defenisi Queue .................................................................. 118
9.2 Operasi Dasar Pada Antrean .............................................. 122
9.3 Penyajian Dari Antrean ...................................................... 124
9.4 Deque ................................................................................ 129
9.5 Antrean Berprioritas ........................................................... 132
9.6 Penyajian One-Way List Dari Antrean Berprio-Ritas ......... 133
9.7 Penyajian Array Dari Antrean Berprioritas ......................... 138
9.8 Tambahan : Mesin Antrean ............................................... 141
Bab 10 Tree .......................................................................................... 147
10.1 Defenisi Tree (Pohon) ........................................................ 147
10.2 Pohon Binar (Binary Tree) ................................................. 149
10.3 Terminologi Pada Pohon Binar .......................................... 153
10.4 Pohon Binar Lengkap ........................................................ 156
10.5 Pohon-2 ............................................................................. 158
10.6 Pohon Ketinggian Seimbang ............................................. 160
10.7 Ketinggian Minimum Dan Maksimum Pohon Binar ............ 161
10.8 Penyajian Pohon Binar Dalam Memori .............................. 161
10.8.1 Penyajian Kait ..................................................... 162
10.8.2 Penyajian Sekuensial .......................................... 167
10.9 Penyajian Pohon Umum Secara Pohon Binar ................... 170
10.10 Notasi Prefix, Infix Dan Postfix Serta Traversal ................. 174
10.11 Pohon Cari Binar ............................................................... 186
10.12 Cari Dan Penyisipan Simpul Pohon Cari Binar .................. 191
10.13 Penghapusan Simpul Pohon Cari Binar ............................ 195
v
10.14 Pohon Cari Optimal ........................................................... 200
10.15 Lebih Lanjut Tentang Pohon Cari Optimal ......................... 209
10.16 Heap .................................................................................. 221
10.17 Heapsort ............................................................................ 227
vi
BAB 1
STRUKTUR DATA
1.1 Pengertian Struktur Data
Dalam istilah ilmu komputer, sebuah struktur data
adalah cara penyimpanan, penyusunan dan pengaturan data
di dalam media penyimpanan komputer sehingga data
tersebut dapat digunakan secara efisien.Sedangkan 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.
Konstanta digunakan untuk menyatakan nilai tetap
sedangkan variable digunakan dalam program untuk
menyatakan nilai yang dapat berubah-ubah selang eksekusi
berlangsung.
Ada empat istilah data, yaitu:
1. Type data adalah jenis atau macam data di dalam suatu
variable dalam bahasa pemrograman.
2. Objek data mengacu kumpulan elemen, D (domain).
Pengantar Struktur Data 1

3. Representasi data : Suatu mapping dari struktur data ‘d’
ke suatu set ke struktur data ‘e’ (d===e) misal bolean di
representasikan dalam 0 dan 1.
4. Struktur data biasa dipakai untuk mengelompokan
beberapa informasi yang terkait menjadi sebuah
kesatuan.
Dalam teknik pemrograman, struktur data berarti tata
letak data yang berisi kolom-kolom data, baik itu kolom yang
tampak oleh pengguna (user) atau pun kolom yang hanya
digunakan untuk keperluan pemrograman yang tidak tampak
oleh pengguna.Setiap baris dari kumpulan kolom-kolom
tersebut dinamakan catatan (record). Lebar kolom untuk data
dapat berubah dan bervariasi. Ada kolom yang lebarnya
berubah secara dinamis sesuai masukan dari pengguna, dan
juga ada kolom yang lebarnya tetap. Dengan sifatnya ini,
sebuah struktur data dapat diterapkan untuk pengolahan
database (misalnya untuk keperluan data keuangan) atau
untuk pengolah kata (word processor) yang kolomnya
berubah secara dinamis. Contoh struktur data dapat dilihat
pada berkas-berkas lembar-sebar (spreadsheet), pangkal-data

(database), pengolahan kata, citra yang dipampat
(dikompres), juga pemampatan berkas dengan teknik tertentu
yang memanfaatkan struktur data.
Secara garis besar type data dapat dikategorikan menjadi:
Type data sederhana.
Type data sederhana tunggal, misalnya Integer, real, boolean
dan karakter.
Type data sederhana majemuk, misalnyaString
Struktur Data, meliputi:
Struktur data sederhana, misalnya array dan record.
Struktur data majemuk, yang terdiri dari:
a) Linier : Stack, Queue, sertaList dan Multilist
b) Non Linier : Pohon Biner dan Graph
Pemakaian struktur data yang tepat didalam proses
pemrograman akan menghasilkan algoritma yang lebih jelas
dan tepat, sehingga menjadikan program secara keseluruhan
lebih efisien dan sederhana.
Struktur data yang standar yang biasanya digunakan
dibidang informatika adalah:
 List linier (Linked List) dan variasinya

 Multilist
 Stack (Tumpukan)
 Queue (Antrian)
 Tree ( Pohon)
 Graph ( Graf )
1.2 Pembuatan Struktur Data
Untuk membuat menjadi struktur data, kita harus
melakukan dulu aktivitas terhadap objek data, yaitu :
 Mendeskkripsikan kumpulan operasi sah yang diterapkan
ke elemen-elemen objek data.
 Menunjukan mekanisme kerja operasi-operasi.
Objek data integer ditambah operasi (+ , - , * , / , mod
,cell , floor , < , >) dan operasi-operasi lain yang memanipuasi
objek data integer menyatakan struktur data.
Struktur data = Objek data + { Operasi manipulasi }.
Tahap pembuatan struktur data adalah :
- Tahap pertama : Spesifikasi
Pendeskripsian / spesifikasi struktur data menyatakan
apa yang dapat dilakukan struktur data, bukan cara
penerapannya.

Spesifikasi dapat dilakukan dengan dua cara, yaitu :
Spesifikasi secara formal
Spesifikasi secara informal
- Tahap kedua : Implementasi
Implementasi menyatakan cara penerapan struktur
data dengan struktur data yang telah ada.Implementasi
struktur data adalah proses pendefinisian Type data abstrak
sehingga semua operasi dapat dieksekusi computer.
Implementasi struktur penyinpanan item-item data serta
algoritma-algoritma untuk implementasi operasi-operasi
sehingga menjamin terpenuhinya karakteristik struktur data,
relasi item-item data atau invariant pada struktur data itu.
- Tahap ketiga : Pemrograman
Pemrograman terstruktur adalah penerjemahan
menjadi pernyataan di bahasa pemrograman tertentu.
Prosesnya terdiri dari :
Deklarasi yang mendefinisikan objek-objek data dan
hubungannya. Pembuatan prosedur / rutin untuk operasi-
operasi dasar yang menjaga invariant pada struktur data itu .

Sesuai dengan relasi yang didefinisikan di spesifikasi
perancangan harus memilih Type-Type data yang telah ada
untuk merepresentasikan struktur data.
Struktur data di bangun menggunakan fasilitas
pembentukan atau pembuatan struktur data yang disediakan
bahasa seperti array, record, dan sebagainya atau yang telah
di buat seperti stack, queue, atau himpunan menggunakan
linked list.
Pembuatan struktur data adalah pembentukan Type
data lengkap yang mempunyai empat property berikut :
1. Nama : Identifier Type data
2. Domain : Domain / himpunan semesta nilai di Type data
3. Konstanta (penyebutan anggota-anggotanya) : Cara
penyebutan anggota-anggota Type data
4. Operasi-operasi terhadap Type data itu (operator) : Daftar
operasi terhadap anggota Type data sehingga kelakuan
objek data sesuai spesifikasi.

BAB 2
TYPE DATA
Bahasa pemprograman, merupakan adalah suatu
komando atau perintah yang dibuat manusia untuk membuat
komputer menjadi memiliki fungsi tertentu. bahasa
pemrograman ini adalah suatu susunan aturan penulisan
(sintaks) yang membentuk kode kode yang kemudian akan
diterjemahkan oleh program kompiler menjadi bahasa rakitan
(assembly) dan terus diolah hingga dimengerti oleh mesin.
Komputer hanya mengerti bahasa mesin.
Bagi pemula, belajar bahasa pemprograman memang
sulit, namun bukan berarti itu penghalang bagi kita untuk
enggan belajar. Di Jurusan Teknik Informatika yang notabese
khusus mempelajari ilmu-ilmu komputer sekalipun, tidak
semua mahasiswanya pandai dalam bahasa pemrograman
tertentu. Hal itu dikarenakan tidak semua orang mempunyai
pemikiran dan kreativitas yang sama sehingga daya nalar
terhadap sebuah bahasa pemrograman didapatkan hasil yang
berbeda-beda untuk setiap orang. Perlu anda ketahui bahwa

Program yang ditulis dengan menggunakan bahasa pascal
mempunyai ciri yang terstruktur sehingga mudah dipahami
maupun dikembangkan oleh pemogram.
Pada suatu bahasa pemrograman umumnya telah
menyediakan Type – Type data yang sederhana ( simple )
maupun yang terstruktu. Termasuk di bahasa pascal.
2.1 Type Data Sederhana
Type data sederhana adalah Type data dasar, karena
hanya mampu menyimpan satu nilai tiap satu variabelnya.
Jenis data ini merupakan nilai bilangan bulat, yang
terdiri atas integer positif, integer negatif dan nol. Pada
TURBO PASCAL jenis data ini di bagi atas beberapa bagian.
(lihat diatas)
a. Jenis Data Integer
Operator Integer terdiri atas : + , - , * , DIV dan MOD

Contoh Program :
Var
Jumlah : byte;
Begin
Jumlah := 32;
WriteLn(‘Nilai JUMLAH = ‘,Jumlah);
writeln(‘Fajar’);
readln;
End.
b. Real Karakter
Nilai konstanta numeric real berkisar dari 1E-38
sampai 1E+38. E menunjukkan nilai 10 pangkat, dan
Type data ini menempati memori sebesar 6 byte.
Type data karakter Merupakan urut-urutan dari
karakter yang terletak diantara tanda petik tunggal. Nilai
data string akan menempati memori sebesar banyaknya
karakter string ditambah dengan 1byte. Bila panjang dari
suatu string didalam deklarasi variable tidak disebutkan,
maka dianggap panjangnya adalah 255 karakter.
Contoh Program:

Var
Nilai1, Nilai2 : real ;
Begin
Nilai1 : = 12345678901.2345 ;
Nilai2 : = 12345 ;
Writeln (‘ Nilai 1 = ’, Nilai1) ;
Writeln (‘ Nilai 2 = ‘, Nilai2) ;
readln;
End.
c. Bolean
Type data Boolean mempunyai dua nilai yaitu true
(benar) dan false (salah). Nilai Boolean sangat penting
digunakan untuk pengambilan keputusan dalam suatu
kejadian tertentu.Contoh penggunaan:
Contoh Program :
VAR
benar : BOOLEAN;
BEGIN
benar := TRUE;
WRITELN('benar = ',benar);

readln;
END.
d. String
Merupakan urut-urutan dari karakter yang terletak
diantara tanda petik tunggal. Nilai data string akan
menempati memori sebesar banyaknya karakter string
ditambah dengan 1byte. Bila panjang dari suatu string
didalam deklarasi variable tidak disebutkan, maka
dianggap panjangnya adalah 255 karakter.
Contoh Program :
var
s:string[111]; //jika panjang maksimum tidak
dimasukkan, kompilator akan menganggapnya 255
begin;
s:= ‘Fajar’;
writeln(s);
readln;
end.

2.2 Type Data Terstruktur
a. Array
Deklarasi perubah selalu diawali dengan kata VAR
Dalam deklarasi perubah biasa, kita hanya perlu
menentukan type data perubah tersebut misalnya: real,
integer, boolean atau char, sedangkan pada deklarasi larik
(array), kita perlu mendefinisikan type larik, juga harus
menentukan banyaknya index yang akan mengisi larik
tersebut.
Format :
VAR nama : ARRAY [index] OF type
Keterangan :
Nama : nama larik yang dideklarasikan;
Index : batasan index (cacah elemen);
Type : Type data dari larik;
Larik dapat berType data sederhana byte, word, integer,
real, boolean, char atau string dan Type data skalar atau
subrange.
Index dari larik menunjukkan maksimum banyaknya
elemen-elemen dari larik. Index larik ini dapat berupa Type

subrange atau skalar apapun (integer, byte, word, char )
kecuali Type real.
Suatu larik tidak hanya dapat berupa suatu variabel
yang dideklarasikan di bagian variabel, tetapi juga dapat
berupa uatu konstanta yang dideklarasikan di bagian
deklarasi konstanta.
Contoh sintaks:
VAR tabel : ARRAY[1..3,1..2] OF BYTE;
BEGIN;
tabel[1,1] := 5;
tabel[1,2] := 7;
tabel[2,1] := 21;
tabel[2,2] := 18;
tabel[3,1] := 8;
tabel[3,2] := 7;
WRITELN('BARIS 1 KOLOM 2 = ',tabel[1,2]);
WRITELN(‘Fajar’);
READLN;
END.

b. Record
Seperti halnya array(larik), record juga punya elemen, di
sini elemennya disebut "Field". Tiap elemen bisa punya type
data yang berbeda. Banyaknya field dapat bervariasi atau
bisa juga tetap.Record yang punya field yang bervariasi
disebut ‘Variant Record’. Deklarasi type data Record dapat
ditetapkan di bagian deklarasi var atau Type.
program deklarasi;
uses crt;
var p : înteger;
nilai : integer;
begin
clrscr;
nilai:=12;
p:=@nilai;
writeln(p^);
p^:=100;
readln;
end.

2.3 Type Data Pointer
Pointer merupakan variabel khusus yang berisi suatu
address (alamat) di lokasi lain didalam memory. Suatu
variabel yang points(menunjuk) ke sesuatu sehingga disebut
pointer. Ada dua macam pointer:
 typed(tertentu): merupakan pointer yang menunjuk
pada Type data tertentu pada variabl
 generic(umum): merupakan pointer yang tidak
menunjuk pada Type data tertentu pada variable.
Contoh deklarasi pointer:
var p : înteger;
Contoh di atas merupakan deklarasi variabel p sebagai
pointer dari integer. Dengan menambahkan tanda caret (^) di
depan nama Type data variabel yang dideklarasikan:
contoh :

BAB 3
ARRAY
3.1 Pengertian Array
Array (larik) adalah sebuah variabel yang dapat
menyimpan lebih dari satu nilai sejenis (memilikii Type data
sama). Hal ini berbeda dengan variabel biasa yang hanya
mampu menampung satu buah nilai. Setiap nilai yang
disimpan di dalam array disebut dengan elemen array,
sedangkan nilai urut yang digunakan untuk mengakses
elemennya disebut dengan indeks array. Sebagai contoh,
misalkan terdapat array A yang memiliki 10 buah elemen
nilai yang berType integer, maka dapat dipresentasikan
sebagai berikut :
Setiap elemen array di atas menyimpan nilai berType
integer dan akan menempati alamat memori yang berbeda,

hal ini akan menyebabkan array tersebut memiliki ukuran 40
byte, yang berasal dari 10 x 4. Nilai 10 menunjukkan
banyaknya elemen array sedangkan nilai 4 merupakan
ukuran dari Type data integer (dalam 32 bit).
3.2 Deklarasi Array
Sama seperti variabel lain, array juga dideklarasikan di
dalam bagian deklarasi variabel. Bila akan didefinisikan
sebagai Type bentukan, maka array juga akan dideklarasikan
di bagian definisi Type (di bawah kata kunci type). Dalam
bahasa Pascal, pendeklarasian array dilakukan dengan
menggunakan kata kunci array dan Type data yang akan
disimpan di dalamnya, selai itu juga harus disertai dengan
batas-batas indeksnya yang diapit oleh tanda bracket ([ ]).
Berikut ini bentuk umum pendeklarasian array.
Sebagai contoh, apabila kita ingin mendeklarasikan
array dengan nama A yang berisi 10 buah elemen berType
integer, maka kita harus mendeklarasikannya dengan cara
berikut.

Var
A : array [1 . . 10] of integer;
Pada kode tersebut, indeks array diulai dari satu. Perlu
diperhatikan bahwa bahasa Pascal berbeda dengan bahasa C
yang indeks array-nya selalu dimulai dari nol. Pada bahasa
Pascal, indeks array dapat dimulai dari bilangan berapapun.
Selain itu, indeks array juga dapat berType karakter maupun
Type enumerasi. Berikut ini contoh-contoh kode yang dapat
digunakan untuk mendeklarasikan 10 buah elemen array
berType integer sebagai pengganti kode di atas.
Var
A1 : array [0 . . 9] of integer;
A2 : array [5 . . 15] of integer;
A3 : array [’a’ . . ’j’] of integer;
A4 : arrat [’A’ . . ’J’] of integer;
Dalam bahasa Pascal, tersedia dua buah fungsi yang
dapat digunakan untuk mengambil indeks terendah dan
tertinggi dari sebuah array, yaitu fungsi Low dan High.
Adapun parameter dari kedua fungsi tersebut adalah nama
array yang akan dicari indeksnya. Perhatikan contoh kode
berikut.

Var
A: array [1 . . 100] of integer;
terendah, tertinggi : integer;
Begin
terendah := Low (A); {akan menghasilkan nilai 1}
tertinggi := High (A) {akan menghasilkan nilai 100}
..
end.
3.3 Mengakses Elemen Array
Setelah mengetahui cara pendeklarasian array,
selanjutnya kita harus mengetahui bagaimana cara untuk
memanipulasi array tersebut. Langkah pertama yang harus
dilakukan adalah mengisikan nilai ke dalam elemen-elemen
array bersangkutan. Bentuk umum untuk pengisian elemen
array adalah sebagai berikut.
Untuk lebih memahaminya, coba perhatikan contoh kode di
bawah ini.
Var
A: array [1..100] of integer;
Begin

A[1] :=1; {mengisi elemen pertama dengan nilai 1}
A[2] :=2; {mengisi elemen kedua dengan niali 2}
A[3] :=3; {mengisi elemen ketiga dengan niali 3}
....
A[100] :=100; {mengisi elemen keseratus dengan nilai 100}
end.
Kode tersebut akan melakukan pengisian 100 elemen
array dengan nilai 1 sampai 100 sehingga kode tersebut akan
lebih sederhana apabila dituliskan dengan menggunakan
struktur pengulangan seperti yang terlihat pada kode berikut.
Var
A: array [1..100] of integer;
i : integer;
Begin
For i:= 1 to 100 do
Begin
A[1] := i;
end;
End.
3.4 Mengapa Harus Menggunakan Array
Bagi seorang pemula, mungkin akan mucul pertanyaan
mengapa kita perlu mendeklarasikan array? Untuk menjawab
pertanyaan tersebut, coba perhatikan contoh kasus berikut.

Apabila kita akan membuat program untuk menyimpan
sekumpulan data, misalnya data-data hasil penelitian yang
berupa bilangan, dimana jumlah dari data tersebut puluhan,
ratusan atau bahkan ribuan, apakah akan menggunakan
variabel sebanyak data yang ada? Jawabannya tentu tidak,
karena hal tersebut merupakan hal yang sangat tidak efisien.
Sebagai contoh, asumsikan bahwa banyak data tersebut.
Var
N1, n2, n3, n4, n5, n6, n7, n8, n9, n10 : real;
Begin
Writeln(’masukkan data ke-1 : ’); readln(n1);
End.

Hal ini tentu akan merepotkan diri kita. Apabila dilihat,
program di atas memang masih pendek karena datanya
hanya 10, bagaimana bila ratusan ata bahkan ribuan?
Untuk mengatasi masalah ini, seharusnya kita
menggunakan array untuk menyimpan data-data tersebut
sehingga program akan jauh lebih sederhana dan mudah
dalam pengerjaannya. Berikut ini perbaikan program di atas
apabila kita menampung data-datanya ke dalam sebuah
array.
Const max = 10;

Var
n : array [1 . . max] of real;
i : integer;
begin
for i:= 1 to max do
writeln(’Masukkan data ke-’, i,’ : ’); readln(n[i]);
end.
Apabila ternyata data berjumlah 100 atau 1000, maka
kita hanya perlu mengganti nilai dari konstanta max di atas
dengan nilai yang sesuai. Alasan seperti inilah yang
menyebabkan kita perlu untuk menggunakan array.

3.5 Array Sebagai Type Data Bentukan
Array juga dapat digunakan sebagai Type data
bentukan, yaitu dengan cara mendeklarasikannya di bagian
definisi Type data, yaitu bagian yang diawali dengan kata
kunci type.
Type
Bilangan = array [1 . . 100] of integer;
Vokal = array [1 . . 5] of char;
Setelah selesai mendefinisikan array tersebut, maka
kita dapat menggunakannya untuk mendeklarasikan variabel
lain di dalam program. Berikut ini contoh pendeklarasian
variabel yang menggunakan Type bentukan berupa array.
Var
X : bilangan;
Vowel : vokal;
Pada ontoh di atas kita mendeklarasikan variabel
dengan nama x yang berType Bilangan, sedangkan variabel
vowel berType vokal. Hal ini menyebabkan variabel tersebut
juga dapat diperlukan sebagai array. Berikut ini contoh kode
yang menunjukkan penggunaan variabel-variabel tersebut.

Begin
X[1[ := 1;
X[2] := 2;
...
Vowel [1] := ’a’;
Vowel [2] := ’i’;
...
End.
3.6 Array Konstan
Nilai yang terkandung di dalam sebuah array dapat
bernilai konstan, artinya nilai-nilai tersebut tidak dapat
diubah. Untuk melakukan hal tersebut, kita harus
mendeklarasikan array bersangkutan dengan kata kunci
const. Berikut ini bentuk umum pendeklarasiannya.
Perlu diperhatikan bahwa banyaknya nilai konstan
yang dituliskan diatas harus sesuai dengan banyaknya
elemen array yang didefinisikan. Sebagai contoh, apabila kita
ingin mendeklarasikan array dengan jumlah elemen 5, maka

nilai konstan yang diisikan juga haruslah berjumlah 5.
Perhatikan contoh kode berikut.
Const
A : array [1 . . 5] of char = (’A’ , ’B’ , ’C’ , ’D’ , ’E’);
Oleh karena array A di atas bersifat konstan, maka kita
tidak dapat menggantikan nilainya dengan nilai lain, seperti
yang ditunjukkan oleh kode di bawah ini.
A [1] := ’V’ ; {SALAH, karena elemen A [1] selalu bernilai

’A’}
A [2] := ’W’ ; {SALAH, karena elemen A [2] selalu bernilai
’B’}
A [1] := ’X’ ; {SALAH, karena elemen A [3] selalu bernilai
’C’}
A [1] := ’Y’ ; {SALAH, karena elemen A [4] selalu bernilai
’D’}
A [1] := ’Z’ ; {SALAH, karena elemen A [5] selalu bernilai
’E’}
Hal ini menunjukkan bahwa array konstan nilainya
hanya dapat dibaca, namun tidak untuk diubah. Agar lebih
memahami konsepnya, perhatikan contoh implementasi dari
array konstan berikut ini.
Function HariSekarang : string;

Const
Hari : array[0 . .6] of string[6] =
(’Minggu’, ’Senin’, ’Selasa’, ’Rabu’, ’Kamis’, ’Jumat’,
’Sabtu’);
var
thn, bln, hr, indeksHari : word;
begin
getDate(thn, bln, hr, indeksHari);
HariSekarang := Hari [indeksHari];
End;
Pada contoh di atas kita membuat sebuah fungsi untuk
mendapatkan nama hari sesuai dengan tanggal sekarang
(hari ini). Berikut ini contoh program lain yang akan
menunjukkan penggunaan array konstan.
Program ArrayKonstan;
Uses crt;
Const
Bulan : array [1 . . 12] of string =
(’Januari’, ’Februari’, ’Maret’, ’April’, ’Mei’, ’Juni’,
’Juli’, ’Agustus’,
’September’, ’Oktober’, ’Nopember’, ’Desember’);
var
noBulan : integer;
begin

clrscr;
write(’Masukkan nomor bulan :’); readln(noBulan);
write(’Nama bulan ke-’, noBulan, ’adalah ’, Bulan[noBulan]);
readln;
end.
Contoh hasil yang akan diberikan oleh program di atas
adalah sebagai berikut.
Masukkan nomor bulan : 3
Nama bulan ke-3 adalah Maret
3.7 Array Sebagai Parameter
Pada kasus-kasus pemrograman tertentu kita juga
dituntut untuk menggunakan array sebagai parameter
sebuah prosedur ataupun fungsi. Hal ini sering kita jumpai
pada saat kita akan melakukan pencarian maupun
pengurutan dari sekumpulan data. Berikut ini contoh
penggunaan array di dalam sebuah prosedur.
Type
Bilangan = array[1..100] of integer;
Procedure inputArray[a:bilangan; N:integer);
Var
i : integer;

Begin
For i := 1 to N do
Write (’masukkan elemen array ke-’, i); readln(A[i]);
End;
Pada contoh di atas kita telah membuat prosedur yang
memiliki parameter berType array. Prosedur tersebut akan
digunakan untuk melakukan pengisian elemen array
sebanyak N, dimana 1 N  100.
Perlu diperhatikan bahwa array yang dilewatkan
sebagai parameter ini harus dideklarasikan terlebih dahulu.
Berikut ini contoh penggunaan array yang tidak
diperbolehkan oleh kompiler.
Procedure InputArray [A:array[1..100] of integer; N);

{salah}
Berikut ini kode yang merupakan perbaikan dari kode
sebelumnya.
Procedure InputArray [A:array of integer; N);

{benar}

Untuk lebih memahaminya, perhatikan contoh program
di bawah ini dimana kita akan menggunakan array sebagai
parameter.
Program ParamArray;
Uses crt;
Const max = 100;]type
Bilangan = array [1 . . max] of integer;
Procedure InputArray[A:bilangan; N:integer);
Var
i:integer;
Begin
Writeln (’Memasukkan data :’);
For i : 1 to N do
Write(’Masukkan nilai A[’, i, ’] : ’); readln(A[i]);
End;
Procedure OutputArray (A:bilangan; N:integer);
Var
i:integer;
begin
writeln(’Menampilkan data :’);
for i : 1 to N do
write (’A[’, i, ’] = ’, A[i]);
end;
var

Arr:bilangan;
count:integer;
Begin
Clrscr;
Write (’Masukkan banyaknya elemen array :’); readln(count);
Writeln;
OutputArray (Arr, count);
Readln;
End.
Contoh hasil yang akan diberikan dari program di atas adalah
sebagai berikut.
Masukkan banyaknya elemen array : 3
Memasukkan data :
Masukkan nilai A[1] : 10
Menampilkan data :
A[1] = 10
A[2] = 20
A[3] = 30

3.8 Array Multidimensi
Sejauh ini kita baru membahas mengenai array
berdimensi satu. Pada bagian ini kita akan mempelajari
bagaimana cara mendeklarasikan dan memanipulasi data
yang terdapat pada array multidimensi. Agar lebih
mempermudah pembahasan, materi ini akan dibagi menjadi
dua kelompok, yaitu array dua dimensi dan array tiga
dimensi.
3.9 Array Dua Dimensi
Array dua dimensi adalah array yang memiliki dua
buah elemen berType array. Dengan kata lain, array dua
dimensi memiliki dua buah subskrip, yang biasanya
dipresentasikan dengan baris dan kolom. Untuk lebih
memahami konsepnya, perhatikan terlebih dahulu gambar di
bawah ini.

Pada gambar di atas, array memiliki 3 buah baris dan 4
buah kolom, sehingga jumlah elemennya adalah 3x4 = 12.
Perlu diketahui bahwa keadaan tersebut sebenarnya hanya
merupakan keadaan logik yang bertujuan untuk
mempermudah pemahaman array dua dimensi. Pada
kenyataannya, pengalamatan memori di komputer dari array
dua dimensi tetap akan dipresentasikan dengan sebuah
deretan larik yang memanjang (tidak berbentuk baris dan
kolom). Pendeklarasian array dua dimensi di dalam bahasa
Pascal dilakukan melalui bentuk umum di bawah ini.
NamaArray : array [1 . . banyakbaris, 1 . . banyakkolom] of

Type_data;
Sebagai contoh, apabila kita akan mendeklarasikan
array dua dimensi dengan 3 buah baris dan 4 buah kolom
dimana setiap elemennya berType integer, maka kita dapat
menuliskan kode seperti berikut.
Array2D : array [1 . . 3, 1 . . 4] of integer;
Untuk melakukan pengaksesan terhadap elemen-
elemennya, kita harus menuliskan indeks baris dan
kolomnya. Sebagai contoh, apabila kita ingin mengisikan nilai

100 ke dalam elemen yang terdapat pada baris ke-2 kolom
ke-3, maka kita harus menuliskannya sebagai berikut.
Array2D [2, 3] : = 100;
Berikut ini contoh program yang menunjukkan
penggunaan array dua dimensi. Di sini kita akan membuat
program yang dapat menjumlahkan dua buah matriks A dan
B yang masing-masing berordo 2 x 3 (memiliki 2 baris dan 3
kolom).
Program JumlahMatriks;
Uses crt;
Const
Jbaris = 2;
Jkolom = 3;
Type
Matriks23 = array [1 . . Jbaris, 1 . . Jkolom] of integer;
Var
A,B,C : Matriks23;
j, k : integer;
begin
clrscr;
{mengisikan matriks A}
writeln (’Matriks A’);
for j: = 1 to Jbaris do begin

for k: = 1 to Jkolom do begin
write(’A[’, j, ’ , ’ , k, ’] = ‚); readln(A[j, k]);
end;
writeln;
end;
writeln;
{mengisikan matriks B}
writeln(’Matriks B’);
write(’B[’, j, ’ , ’ , k, ’] = ‚); readln(B[j, k]);
end;
writeln;
end;
writeln;
{melakukan penjumlahan matriks A dan B sekaligus
menampilkan hasilnya ke layar}
writeln(’Hail Penjumlahan’);
C[j, k] : = A[j, k] + B[j, k];
write(’C[’, j, ’ , ’ , k, ’] = ‚); readln(C[j, k]);
end;
writeln;
end;
readln;
end.

Contoh hasil yang akan diberikan oleh program di atas
adalah sebagai berikut.
Matriks A
A[1, 1] = 1
A[1, 2] = 2
A[1, 3] = 3
A[2, 1] = 4
A[2, 2] = 5
A[2, 3] = 6
Matriks B
B[1, 1] = 3
B[1, 2] = 2
B[1, 3] = 1
B[2, 1] = 6
B[2, 2] = 5
B[2, 3] = 4
Hasil Penjumlahan
C[1, 1] = 4
C[1, 2] = 4
C[1, 3] = 4
C[2, 1] = 10
C[2, 2] = 10
C[2, 3] = 10

3.10 Array Tiga Dimensi
Array tiga dimensi merupakan array yang memiliki tiga
buah subskrip dan lebih kompleks apabila dibandingkan
dengan array dua dimensi. Di sini, subskrip yang ada akan
dipresentasikan dengan sumbu x, y dan z atau panjang, lebar
dan tinggi seperti yang ditunjukkan oleh gambar berikut.
Berikut ini bentuk umum yang digunakan untuk
mendeklarasikan array tiga dimensi di dalam bahasa Pascal.
Sebagai contoh apabila kita ingin mendeklarasikan
array yang memiliki panjang 2, lebar 3 dan tinggi 4 elemen
berType integer, maka kita akan menuliskannya seperti di
bawah ini.
Array3D : array [1 . . 2, 1 . . 3, 1 . . 4] of integer;

Jumlah elemen yang terdapat di dalam array tersebut
adalah 2 x 3 x 4 = 24. Sekarang apabila kita ingin mengisikan
nilai 100 ke dalam elemen yang berada pada posisi panjang
ke-2, lebar ke-3 dan tinggi ke-1, maka kita akan
melakukannya melalui kode berikut.
Array3D : [2, 3, 1] : = 100;
Berikut ini adalah contoh yang akan menunjukkan cara
pengaksesan elemen di dalam array 3 dimensi.
Program AksesArray3D;
Uses crt;
Const
xMaks = 2;
yMaks = 2;
zMaks = 2;
Type
Array3D = array [1 . . xMaks, 1 . . yMaks,1 . . zMaks] of
integer;
Var
A: Array3D;
i, j, k : integer;
begin
clrscr;

{mengisikan nilai ke dalam array A}
x := 1;
for i := 1 to xMaks do begin
for j := 1 to jMaks do begin
for k := 1 to zMaks do begin
A[i, j, k] := x;
inc(x);
end;
end;
end;
{menampilkan isi yang terdapat dalam array A}

for i := 1 to xMaks do begin
for j := 1 to jMaks do begin
for k := 1 to zMaks do begin
write(’A[ ’ , i, ’,’ , j, ’,’ , z, ’ ] = ’, A[ i, j, k] , ’ ’ );
end;
end;
writeln;
end;
readln;
end.
Hasil yang akan diberikan oleh program diatas adalah
sebagai berikut:

A[1, 1, 1] = 1 A[1, 1, 2] = 2 A[1, 2, 1] = 3
A[1, 2, 2] = 4
A[2, 1, 1] = 5 A[2, 1, 2] = 6 A[2, 2, 1] = 7

A[2, 2, 2] = 8
Penutup
Array merupakan sebuah variabel yang dapat
menyimpan lebih dari satu nilai yang memiliki Type data
sama. Hal ini berbeda dengan variabel biasa yang hanya
mampu menampung satu buah nilai. Setiap nilai yang
disimpan di dalam array disebut dengan elemen array,
sedangkan nilai urut yang digunakan untuk mengakses
elemennya disebut dengan indeks array.
Apabila kita akan membuat program untuk menyimpan
sekumpulan data, misalnya data-data hasil penelitian yang
berupa bilangan, dimana jumlah dari data tersebut puluhan,
ratusan atau bahkan ribuan, apakah akan menggunakan
variabel sebanyak data yang ada? Jawabannya tentu tidak,
karena hal tersebut merupakan hal yang sangat tidak efisien.
Penggunaan array dalam program akan membuat program
lebih efisien dan mudah dipahami.

BAB 4
REKURSIF
4.1 Definisi Rekursif
Rekursif adalah suatu proses dari fungsi yang
memanggil dirinya sendiri. Fungsi yang seperti ini disebut
fungsi rekursif (recursive function). Dalam sebuah fungsi
rekursif pemanggilan dapat terjadi berulang kali. Karena ada
proses yang berulang-ulang maka harus ada suatu kondisi
yang mengakhiri prosesnya. Jika tidak, maka proses tidak
akan pernah berhenti sampai memori yang digunakan tidak
dapat menampung lagi.
Pemecahan masalah dengan pendekatan rekursif dapat
dilakukan jika masalah tersebut dapat didefinisikan secara
rekursif, yaitu masalah dapat diuraikan menjadi masalah
sejenis yang lebih sederhana
Contoh Fungsi Rekursi

Hasil Running:
Dalam membuat fungsi rekursi harus ditentukan
kondisi perhentian. Pada contoh listing program 11.1 di atas
kondisi perhentiannya adalah jika nilainsudah lebih kecil
atau sama dengan 0. Setiap kali fungsi memanggil dirinya
sendiri, nilai darin dikurangi dengan nilai 1, sehingga nilain
akhirnya akan menjadi nol dan proses rekursi akan diakhiri,
sehingga fungsi ini akan memanggil dirinya sendiri
sebanyaknkali. Contoh untuk menggambarkan fungsi
rekursif yang sering digunakan adalah fungsi untuk
mendapatkan nilai faktorial dari suatu bilangan bulat
Contoh Program Faktorial

Hasil Running
Program 11.2 di atas dapat dijelaskan sebagai berikut:
1. Fungsi utama memanggil fungsifactorial()dengan
mengirimkan nilai n = 5 untuk parameter formala, yang
maksudnya akan dilakukan perhitungan sebanyak 5
faktorial
2. Jika nilai dari a pertama kali yang diberikan oleh fungsi
utama bernilai kurang dari atau sama dengan satu, maka
hasil faktorial yang akan diberikan adalah bernilai 1.
3. Jika nilai a pertama kali yang diberikan oleh fungsi utama
lebih besar dari 1, maka proses rekursi akan dilakukan
misalnya nilai a = 5 , maka proses rekursi yang pertama
adalah return ( 5 * factorial(4) );
Proses ini akan memanggil kembali fungsi dirinya
sendiri dengan mengirimkan nilai 4 sebagai nilaia yang baru.
Karena nilaia masih lebih besar dari 1 maka proses rekursi
kedua akan dilakukan dengan hasilnya adalah 4 * factorial(3).
Untuka adalah 3, hasilyang diperoleh oleh rekursi adalah 3 *

factorial(2) dan seterusnya sampai nilai adalah 1. Untuk nilai
sama dengan 1 ini, perintah return (1) akan mengembalikan
proses ke bagian yang memanggilnya.
4.2 Perbandingan Rekursif dengan Iteratif
Kekurangan fungsi rekursif:
1. Memerlukan memory yang lebih banyak untuk
menyimpan activation record dan variabel lokal.
Activation record diperlukan waktu proses kembali
kepada pemanggil.

2. Memerlukan waktu yang lebih banyak untuk
menanganiactivation record.
Secara umum gunakan penyelesaian rekursif hanya jika:
1. Penyelesaian sulit dilaksanakan secara iteratif.
2. Efisiensi dengan cara rekursif sudah memadai.
3. Efisiensi bukan masalah dibandingkan dengan kejelasan
logika program
Contoh program untuk membandingkan penggunaan
itertif dan rekursif dapat dilihat dalam program menampilkan
deret fibonacci pada listing program 11.3 dan listing program
11.4 bawah ini.
Contoh Program Fibonacci dengan Rekursif

Hasil Running:
Penjelesan Program :
Deret fibonacci mempunyai nilai suku-suku bilangan berikut:
0, 1, 1, 2, 3, 5, 8, 13, 21, ............
Ciri khusus deret ini adalah tiap-tiap suku adalah hasil
penjumlahan dari nilai dua suku sebelumnya. Misalnya
adalah nilai suku ke dua adalah penjumlahan nilai suku ke 0
(bernilai 0) dengan suku ke 1 (bernilai 1) jadi nilai suku ke 2
adalah sama dengan 1 (0 + 1). Nilai suku ke tiga adalah nilai
suku ke dua ditambah nilai suku ke satu. Misalnya untuk
mencari bilangan fibonacci ke- 5, maka urutan
pengerjaannya adalah sebagai berikut:
Dari diagram terlihat bahwa untuk mendapatkan deret
ke 5 dari deret fibonacci maka fungsi fibo(4) dihitung satu

kali, fungsi fibo(3) dihitung dua kali, fungsi fibo(2) dihitung
tiga kali dan fungsi fibo(1) dihitung dua kali. Hal ini
menyebabkan proses lebih lama dan juga sumber daya yang
dibutuhkan untuk menangani proses ini lebih banyak.
Contoh Program Fibonacci dengan Iteratif
Hasil Running
Penjelasan Program
Dari listing program 11.4, terlihat bahwa setiap kali
akan menghitung suku ke-n, maka nilai-nilai suku

sebelumnya akan digunakan kembali, yaitu nilai dari n-
1(variabel fb1) dan nilai dari n-2(variabel fb2). Pertama
dihitung nilai dari deret ke-n, kemudian nilai dari deret n-1
diberikan kepada deret n-2, dan nilai dari deret n diberikan
kepada deret n-1.
4.3 Kesimpulan
Fungsi rekursif merupakan salah satu konsep yang
penting untuk dikuasai. Hal ini dikarenakan fungsi ini
memiliki sangat banyak implementasi, yang dalamhal ini
adalah implementasi dalam algoritma. Secara umum fungsi
rekursif memiliki algoritma yang lebih mudah dipahami dan
dibuat tetapi membutuhkan penggunaan memori yang besar.

BAB 5
SEARCHING
5.1 Defenisi Searching
Pencarian (searching) data tertentu yang terkandung di
dalam array merupakan hal yang banyak ditemukan dalam
kasus-kasus pemrograman. Maka dari itu, pada bagian ini
kita akan membahas mengenai cara yang seharusnya
digunakan untuk melakukan hal tersebut serte
pengimplementasiannya di dalam bahasa Pascal. Dalam ilmu
algoritma, metode pencarian data di dalam array
diklasifikasikan menjadi dua, yaitu metode pencarian
beruntun (sequential search) dan metode pencarian bagi
dua/pencarian biner (binary search). Berikut ini
penjelasannya dari kedua metode tersebut.
5.2 Metode Pencarian Beruntun
Metode ini banyak digunakan karena efektif untuk
melakukan pencarian dari sekumpulan data, baik data sudah
terurut maupun yang belum terurut atau masih acak. Bila
dibandingkan dengan yang lainnya, metode ini memiliki cara

kerja yang relatif mudah untuk dipahami. Dalam metode ini,
data yang dicari akan dibandingkandengan seluruh elemen
array yang ada. Sebagai contoh, apabila kita memiliki array A
yang memiliki indeks 1 sampai n dan kita akan mencari nilai
x di dalam array tersebut, maka nilai x tersebut akan
dibandingkan dengan nilai A[1] sampai A[n]. Dalam metode
ini juga diterapkan bahwa apabila data ditemukan pada
indeks tertentu, maka proses pencarian akan dihentikan. Hal
ini bertujuan agar proses pembandingan nilai tidak dilakukan
sampai indeks terakhir karena nilai yang dicari telah
ditemukan.Agar lebih memperjelas, perhatikan gambar
proses pencarian data berikut.
Pada gambar di atas, nilai 1, 2, …5 merupakan indeks
array sedangkan nilai 75, 73, … 80 merupakan nilai yang
terkandung dalam elemen-elemen array. Sekarang misalkan

kita akan melakukan pencarian data 78 di dalam array
tersebut, maka salah satu cara yang dapat digunakan adalah
dengan membandingkan nilai 78 tersebut dengan seluruh
elemen array (dari A[1] sampai A[5]). Mula-mula kita akan
membandingkan nilai 78 dengan elemen pertama (A[1]),
karena nilainya tidak sama maka pencarian akan dialnjutkan
ke elemen berikutnya (A[2]), begitu seterusnya. Pada saat
elemen ketiga, nilai A[3] sama dengan nilai yang dicari
pencarian akan dihentikan.
Berikut ini contoh program yang akan menunjukkan
implementasi dari pencarian array dengan menggunakan
metode di atas. Apabila data yang dicari ditemukan dalam
array, maka program akan menampilkan indeks dimana data
tersebut berada. Sebaliknya, apabila data tidak ditemukan
maka program akan mengembalikan indeks nol.
Program CariBeruntun;
Uses crt;
Const
A : array [1 . . 5] of integer = (75, 73, 78, 81, 80);
Var
i, x, indeks : integer;

begin
clrscr;
write (‘Masukkan nilai yang akan dicari : ’); readln(x);
indeks := 0;
for i := 1 to 5 do begin
if A[i] = x then begin
indeks := I;
break;
end;
end;
writeln (x, ‘ditemukan pada indeks ke-‘, indeks);
readln;
end.
Adapun contoh hasil yang akan diberikan oleh program
di atas adalah sebagai berikut .
Masukkan nilai yang akan dicari : 78

78 ditemukan pada indeks ke-3
Sekarang tinjaulah kasus apabila ternyat data yang
dicari dalam array tidak ditemukan. Sebagai contoh apabila
kita memiliki array dengan n buah elemen, maka dengan
metode runtunan ini, program akan melakukan
pembandingan nilai sebanyak n kali, yaitu dari indeks

pertama sampai indeks ke-n. Hal ini tentu dapat dikatakan
sebagai sebuah kelemahan dari metode tersebut.
5.3 Metode Pencarian Bagi Dua
Berbeda dengan metode pencarian beruntun yang dapat
digunakan untuk data belum terurut, metode pencarian bagi
dua ini hanya dapat digunakan untuk data-data yang telah
terurut, baik secara menaik maupun menurun.
Dalam metode ini elemen array akan dibagi menjadi
dua, sehingga banyaknya proses pembandingan nilai dapat
dikurangi. Sebagai contoh, apabila terdapat array A yang
memiliki n buah elemen dengan indeks 1 sampai n dan
datanya telah terurut secara menaik, maka array tersebut
akan dipenggal pada indeks ke-k, dimana k = n + 1 div 2. hal
tersebut mengakibatkan array A terbagi menjadi dua bagian,
yaitu dari A[1] . . A[k-1] dan A[k+1] . . A[n], sedangkan a[k]
menjadi pemenggal atau pembatas antara dua bagian
tersebut. Apabila x (nilai yang dicari) sama dengan nilai A[k]
maka hentikan pencarian, sedangkan bila tidak, periksa
apakah nilai A[k] > x ataukah A[k] < x. Bila A[k] lebih besar

dari x, maka ulangi metode pencarian tersebut untuk A[1]
sampai A[k-1]. Sebaliknya, apabila A[k] lebih kecil dari x,
maka ulangi metode pencarian tersebut untuk A[k+1] sampai
A[n]. Perhatikan gambar berikut.
Pada gambar di atas, array terdiri dari 14 buah elemen
yang sudah terurut secara menaik dengan indeks 1 sampai
14. Mula-mula (keadaan pertama), array akan dibagi menjadi
dua bagian. Pembatasnya adalah indeks ke-7. Nilai 7 didapat
dari (1+14) div 2. Karena nilai pada indeks ke-7 (nilai 19)
lebih kecil dari nilai yang dicari (nilai 22), maka proses
pencarian akan diulang untuk indeks ke-8 sampai ke-14.
Pada keadaan kedua ini array tersebut juga akan dibagi
menjadi dua. Kali ini pembatasnya adalah indeks ke-11, yang
berasal dari (8+4) div 2. Karena nilai pada indeks ke-11 (nilai

25) lebih besar dari nilai yang dicari (niali 22), maka proses
pencarian akan dilakukan lagi untuk indeks ke-8 sampai ke-
10. Pada keadaan ini (keadaan ketiga), array akan dibagi
menjadi dua pada indeks ke-9, yang berasal dari (8+10) div 2.
Karena nilai pada indeks ke-9 sama dengan nilai yang dicari,
maka proses pencarian pun dihentikan. Untuk lebih
memperjelas pembahasan serta menunjukkan
implementasinya, perhatikan contoh program di bawah ini.
Program CariBagiDua;
Uses crt;
Const
A : array [1 . . 14] of integer =
(10,12,14,15,16,18,19,20,22,24,25,26,28,29);
Var
idxAwal, {indeks array awal}
idxAkhir, {indeks array akhir}
k, {indeks pemenggal/pembatas}
x : integer; {nilai yang dicari}
ketemu : boolean; {variabel status, ditemukan atau tdak ?}
begin
clrscr;
write (‘masukkan nilai yang akan dicari : ‘); readln(x);
{melakukan pencarian}

idxAwal := 1;
idxAkhir := 14; {14 adalah jumlah elemen array A}
ketemu := false;
while (not ketemu) and (idxAwal<= idxAkhir) do begin
k:= (idxAwal + idxAkhir) div 2;

if A[k] = x then begin
ketemu := true;
end else begin
if A[k] < x then begin
idxAwal := k + 1; {mencari di bagian kanan}
end else begin
idxAkhir := k – 1; {mencari di bagian kiri}
end;
end;
end;
{memeriksa, ketemu atau tidak}

if ketemu then begin
writeln (x, ‘ ditemukan pada indeks ke-‘, k);
end else begin
writeln(x, ‘ tidak ditemukan’);
end;
readln;
end.

Berikut contoh hasil yang akan diberikan oleh program di
atas.
Masukkan nilai yang akan dicari : 22

22 ditemukan pada indeks ke-9
5.4 Kesimpulan
Pencarian (searching) dilakukan untuk menemukan
nilai tertentu pada sejumlah nilai yang tersedia. Terdapat
bermacam-macam program pencarian yang telah
dikembangkan dengan ide dasar yang berbeda. Dua
diantaranya adlah pencarian beruntun dan pencarian bagi
dua.
Pencarian beruntun dilakukan dengan melakukan
perbandingan nilai yang dicari dengan setiap elemen array,
mulai dari indeks terkecil sampai indeks terbesar yang
terdefinisi. Pencarian dihentikan jika nilai yang dicari telah
ditemukan atau semua elemen sudah diperiksa. Mencari nilai
terbesar atau terkecil adalah contoh lain dari proses beurtan
terhadap array.

Metode pencarian bagi dua ini hanya dapat digunakan
untuk data-data yang telah terurut, baik secara menaik
maupun menurun. Dalam metode ini elemen array akan
dibagi menjadi dua, sehingga banyaknya proses
pembandingan nilai dapat dikurangi.

BAB 6
SORTING
6.1 Definisi Sorting
Selain pencarian, pengurutan data merupakan salah
satu permasalahan umum yang juga sering dijumpai dalam
pemrograman. Sebagai bukti nyata, tinjaulah metode
pencarian bagi dua di atas yang menuntut kita untuk
melakukan pengurutan terlebih dahulu sebelum kita
melakukan pencarian.
Dalam pemrograman, terdapat beberapa metode untuk
melakukan pengurutan data. Namun terdapat 8 (delapan)
metode yang umumnya banyak digunakan, yaitu :
1. Bubble Sort
2. Maximum/Minimum Sort
3. Selection Sort
4. Insertion Sort
5. Heap Sort
6. Quick Sort
7. Merge Sort
8. Shell Sort

Pada pembahasan ini, hanya 3 (tiga) metode yang akan
dibahas yaitu metode pengurutan gelembung (bubble sort),
pengurutan maksimum/minimum (maximum/minium sort)
dan pengurutan seleksi (selestion sort).
6.2 Pengurutan Gelembung (Bubble sort)
Menurut sumber yang ada, metode ini diinspirasi oleh
adanya gelembung sabun yang mengapung di atas
permukaan air. Hal ini tentunya disebabkan karena berat
jenis gelembung sabun lebih kecil dari berat jenis air. Konsep
dari fenomena tersebut kemudian diterapkan sebagai metode
pengurutan data di dalam array. Dalam metode ini data
dengan nilai terkecil akan diapungkan ke posisi teratas, dan
sebaliknya data dengan nilai terbesar akan berada pada
posisi terbawah. Sebagai contoh, asumsikan bahwa kita
memiliki array A yang berisi lima buah elemen data, seperti
yang tampak di bawah ini.
25 22 18 20 15
A[1] A[2] A[3] A[4] A[5]

Di sini kita akan mengurutkan array tersebut secara
menaik, yaitu dengan mengapungkan nilai terkecil ke posisi
teratas (paling kiri). Proses ini tentu akan dilakukan dengan
menggunakan pertukaran antar elemen array. Tahapan-
tahapan yang harus dilakukan adalah sebagai berikut.
Tahap 1
Mulai dari A[5] sampai A[2], lakukan perbandingan nilai
antara A[k] dan A[k-1] dimana variabel k mewakili indeks
array yang sedang aktif. Apabila nilai A[k] lebih kecil, maka
tukarkan nilai A[k] dengan A[k-1]. Sampai di sini, array
tersebut akan menjadi seperti berikut.
15 25 22 18 20
A[1] A[2] A[3] A[4] A[5]
Gambar Hasil Pengurutan Array A tahap 1
Tahap 2
Mulai dari A[5] sampai A[3], lakukan proses seperti pada
tahap 1 sehingga array akan menjadi seperti berikut.
15 18 25 22 20
A[1] A[2] A[3] A[4] A[5]
Gambar. Hasil Pengurutan Array A tahap 2

Tahap 3
Mulai dari A[5] sampai A[4], lakukan proses seperti pada
tahap 1 dan 2 sehingga array akan menjadi seperti berikut.
15 18 20 25 22
A[1] A[2] A[3] A[4] A[5]
Tahap 4
Tahap ini merupakan tahap terakhir dimana kita akan
melakukan perbandingan terhadap nilai dari elemen terakhir
(A5]) dengan elemen terakhir-1 (A[4]). Apabila nilai A[5] lebih
kecil maka tukarkan nilainya dengan A[4] sehingga array A di
atas akan terurut secara menaik seperti yang tampak di
baeah ini.
15 18 20 22 25
A[1] A[2] A[3] A[4] A[5]
Pada proses yang terjadi di atas tampak jelas bahwa
untuk melakukan pengurutan data dengan lima buah
elemen, kita harus melakukan empat tahapan. Sekarang,

apabila proses di atas kita translasikan ke dalam bahasa
pascal, maka hasilnya adalah sebagai berikut.
Var
n, {banyaknya elemen array}
j, k {variabel bantu untuk indeks
pengulangan}
temp : integer; {variabel bantu untuk melakukan
pertukarannilai}
begin
for j:= 1 to N-1 do begin
for k:= N downto j+1 do begin
if A[k] < A[k-1] then begin
temp := A[k];
A[k] := A[k-1];
A[k-1] := temp;
End;
End;
End;
End;
Untuk lebih memperjelas, coba perhatikan implementasinya
di dalam program berikut.
Program UrutGelembung;
Uses crt;
Const

n = 5;
A : array [1 . . n] of integer = (25, 22, 18, 20, 15);
Var
j, k, temp : integer;
begin
clrscr;
{menampilkan data sebelum proses pengurutan}
Writeln(’Data sebelum diurutkan’);
For j := 1 to n do begin
Writeln(’A[’, j,’] = ’, A[j];
End;
Melakukan proses pengurutan data}

For j:= 1 to n-1 do begin
For k:= n downto j+1 do begin
If A[k] < A[k-1] then begin
Temp :=A[k];
A[k] := A[k-1];
Ak-1] := temp;
End;
End;
End;
{Menampilkan data setelah proses pengurutan}

Writeln;
Writeln (’Data setelah diurutkan’);

For j:= 1 to n do begin
Writeln(’A[’, j, ’] = ’, A[j]);
End;
Readln;
End.
Hasil yang akan diberikan oleh program di atas adalah
sebagaii beriku.
Data sebelum diurutkan

25
22
18
20
15
Data setelah diurutkan

15
18
20
22
25
6.3 Pengurutan Maksimum/Minimum
Dengan metode ini, elemen array dengan nilai
maksimum/minimum akan disimpan ke bagian ujung array

(elemen pertama maupun terakshir). Selanjutnya nilai
tersebut akan diisolasi atau diikat dan tidak diikutkan lagi
dalam proses selanjutnya. Di sini, kita hanya akan
menggunakan metode maksimum saja dan tidak akan
membahas mengenai metode minimum. Hal ini disebabkan
karena konsep yang terdapat pada metode minimum sama
persis dengan metode maksimum. Untuk mempermudah
pembahasan, coba perhatikan kembali array A yang terdapat
pada bahasan sebelumnya.
25 22 18 20 15
A[1] A[2] A[3] A[4] A[5]
Gambar Array A sebelum diurutkan dengan metode
Maksimum/Minimum
Pada bagian ini kita akan melakukan pengurutan data
di dalam array tersebut dengan menggunakan metode
maksimum, di mana kita akan melempar nilai maksimum ke
bagian paling kanan array. Adapun tahapan-tahapan yang
perlu dilalui untuk melakukan hal tersebut adalah sebagai
berikut.

Tahap 1
Mulai dari A[1] sampai A[5], cari nilai maksimum dan
tukarkan nilainya dengan elemen terakhir (A[5]) sehingga
array akan akan berubah menjadi seperti di bawah ini.
15 22 18 20 25
A[1] A[2] A[3] A[4] A[5]
Sampai di sini, elemen terakhir (A[5]) tidak akan diikutkan
lagi ke dalam proses atau tahap selanjutnya.
Tahap 2
tukarkan nilainya dengan elemen terakhir saat ini (A[4])
sehingga array akan akan berubah menjadi seperti di bawah
ini.
15 20 18 2 25
A[1] A[2] A[3] A[4] A[5]
Sampai di sini, elemen ke-4 (A[4]) juga tidak akan diikutkan
lagi ke dalam proses atau tahap selanjutnya.

Tahap 3
tukarkan nilainya dengan elemen terakhir saat ini (A[3])
sehingga array akan tampak seperti di bawah ini.
15 18 20 22 25
A[1] A[2] A[3] A[4] A[5]
Sampai di sini, elemen ke-3 (A[3]) juga tidak akan diikutkan
lagi ke dalam proses selanjutnya.
Tahap 4
Tahap terakhir, cari nilai maksimum antara A[1] sampai A[2]
dan tukarkan nilainya dengan elemen A[2]. Untuk kasus ini
nilai maksimum terdapat pada A[2] sehingga di sini benarnya
terjadi proses yang seharusnya tidak perlu dilakukan, yaitu
menukarkan nilai A[2] dengan A[2]. Berikut ini bentuk
translasi metode di atas ke dalam bahasa Pascal.
Var
n, {banyaknya elemen array
keseluruhan}
x, {banyaknya elemen array yang
belum terurut}
j, k, {untuk indeks pengulangan}

maks, {untuk menyimpan nilai maksimal}
imaks, {untuk menyimpan indeks dari
elemen yang menyimpan nilai
maksimal}
temp : integer; {variabel bantu untuk proses
pertukaran}
begin
x:= n; {mula-mula semua belum terurut}
for j:= 1 to n-1 do begin
maks := A[1];
imaks := 1;
for k:= 2 to x do begin

if(A[k] > maks) then begin
maks := A[k];
imaks := k;
end;
end;
{tukarkan maks dengan A[x]}
Temp := A[x];
A[x] := A[imaks];
A[imaks] := temp;
{ikat elemen terakshir dengan menurunkan nilai x}
x := x – 1;
end;
end;

6.4 Pengurutan Seleksi
Pengurutan dengan metode seleksi ini bekerja dengan
cara memilih salah satu elemen serta menganggapnya
sebagai nilai terkecil. Kemudian nilai tersebut aan
dibandingkan dengan elemen-elemen pada posisi berikutnya.
Apabila nilai yang dipilih pertama kali lebih besar dari nilai
elemen pembanding maka tukarkan kedua buah nilai
tersebut. Untuk memperjels pembahasan ini, marilah kita
perhatikan kembali array A seperti pembahasan sebelumnya.
Berikut gambarannya.
25 22 18 20 15
A[1] A[2] A[3] A[4] A[5]
Gambar Array A sebelum diurutkan dengan metode Seleksi
Tahap 1
Mula-mula, A[1] akan dianggap sebagai nilai terkecil, yaitu
dengan cara memasukkan nilai 1 ke dalam variabel, misalnya
dengan nama min. Mulai dari j = min + 1 sampai n (jumlah
elemen array), lakukan perbandingan antara A[j] dengan nilai
A[min]. Apabila nilai dari A[min] > A[j], isikan min = j. Setelah
pengulangan selesai, tukarkan nilai A[min] dan A[1]. Untuk

kasus ini, nilai min adalah 5 karena nilai terkecil tersimpan
pada indeks ke-5. hal tersebut akan menyebabkan array A
tampak menjadi seperti berikut.
15 22 18 20 15
A[1] A[2] A[3] A[4] A[5]
Tahap 2
dengan cara memasukkan nilai 2 ke dalam variabel, misalnya
dengan nama min. Kemudian sama seperti di atas, lakukan
pengulangan mulai dari j = min + 1 sampai n dan bandingkan
setiap nilainya. Setelah didapatkan nilai min, maka tukarkan
A[min] dengan A[2]. Untuk kasus ini, nilai minimum
ditemukan pada indeks ke-3 sehingga min = 3. Tukarkan
A[min] dengan A[2] sehingga array A akan tampak seperti
berikut.
15 18 22 20 25
A[1] A[2] A[3] A[4] A[5]

Tahap 3
dengan cara memasukkan nilai 3 ke dalam variabel min.
Kemudian sama seperti di atas, lakukan pengulangan mulai
dari j = min + 1 sampai n dan bandingkan setiap nilainya.
Setelah didapatkan nilai min, maka tukarkan A[min] dengan
A[3]. Untuk kasus ini, nilai minimum ditemukan pada indeks
ke-4 sehingga min = 4. Tukarkan A[min] dengan A[4] sehingga
array A akan tampak seperti berikut.
15 18 20 22 25
A[1] A[2] A[3] A[4] A[5]
Tahap 4
dengan cara memasukkan nilai 4 ke dalam variabel min.
Kemudian sama seperti di atas, lakukan pengulangan mulai
dari j = min + 1 sampai n dan bandingkan setiap nilainya.
Setelah didapatkan nilai min, maka tukarkan A[min] dengan
A[4]. Untuk kasus ini, nilai minimum ditemukan pada indeks

ke-4 sehingga min = 4. Tukarkan A[min] dengan A[4] sehingga
array A akan tampak seperti berikut.
15 18 20 22 25
A[1] A[2] A[3] A[4] A[5]
Penutup
Untuk menguasai materi ini, sebaiknya anda membuat
ringkasan materi tentang sorting (pengurutan) dan membuat
sendiri beberapa program dengan sorting.
Jawab pertanyaan di atas dengan langsung membuat
program di komputer. Jalankan program tersebut sampai
benar. Hapus kembali listing program yang sudah benar dan
buat kembali program tersebut, dan jalankan. Kalau tingkat
kesalahan pada pembuatan program sudah kecil, anda dapat
melanjutkan materi berikutnya. Kalau program belum jalan,
perbaiki terus sampai benar.

BAB 7
LINKED LIST
Dalam suatu linear list kita dapat melakukan operasi
penyisipan atau penghapusan atas elemen-elemennya pada
sembarang posisi.
Misalkan ada 1500 item yang merupakan elemen dari
suatu linear list.
Jika elemen ke-56 akan kita keluarkan, maka elemen ke-1
s/d elemen ke-55 tidak akan berubah posisinya pada linear
list tersebut. Tetapi elemen ke-57 akan menjadi elemen ke-
56, elemen ke-58 akan menjadi elemen ke-57 dst.
Selanjutnya, jika kita sisipkan satu elemen pada posisi
setelah elemen ke-41, maka elemen ke-42 s/d elemen ke-
1500 akan berubah posisinya.
Untuk menyatakan keadaan diatas diperlukan suatu konsep
yang berbeda dengan konsep sekuensial sebelumnya.
Linked list merupakan suatu cara non-sekuensial yang
digunakan untuk merepresentasikan suatu data.

7.1 Defenisi Linked List
Linked list (one way list) adalah suatu kumpulan
elemen data (yang disebut sebagai node) dimana urutannya
ditentukan oleh suatu pointer.
Setiap elemen (node) dari suatu linked list terdiri atas
dua bagian, yaitu :
 INFO , berisi informasi tentang elemen data yang
bersangkutan.
 NEXT (link field/next pointer field), berisi alamat dari
elemen (node) selanjutnyayang dituju.
Berikut ini sebuah contoh linked list yang terdiri atas 4 node :
Pada node ke-4 field NEXT-nya berisi NULL, artinya
node ke-4 tsb. adalah node terakhir.
Node-node dalam linked list tidak harus selalu
digambarkan paralel seperti pada gambar diatas. Linked list
pada contoh diatas dapat pula digambarkan seperti berikut
ini :

Catatan :
 Ada dua hal yang menjadi kerugian dengan representasi
suatu data dengan linked list ini, yaitu :
1. Diperlukan ruang tambahan untuk
menyatakan/tempat field pointer.
2. Diperlukan waktu yang lebih banyak untuk mencari
suatu node dalam linked list.
 Sedangkan keuntungannya adalah :
1. Jenis data yang berbeda dapat di-link.
2. Operasi REMOVE atau INSERT hanya dilakukan
dengan mengubah pointer-nya saja.

7.2 Operasi Dasar Pada Linked List.
Ada beberapa aturan yang didefinisikan pada operasi
didalam linked list, yaitu :
 Jika P adalah suatu variabel pointer, maka nilainya
adalah alamat atau lokasi dari variabel lain yang dituju.
 Operasi yang didefinisikan pada suatu variabel pointer
adalah
1. Test apakah sama dengan NULL.
2. Test untuk kesamaan dengan variabel pointer lain.
3. Menetapkan sama dengan NULL.
4. Menetapkan menuju ke node lain.
Notasi yang didefinisikan sehubungan dengan operasi
diatas adalah :
1. NODE(P), artinya node yang ditunjuk oleh pointer P.
2. INFO(P), artinya nilai INFO dari node yang ditunjuk
pointer P.
3. NEXT(P), artinya hubungan (link) selanjutnya dari
node yang ditunjuk oleh pointer P.

Sebagai contoh, perhatikan linked list dibawah ini :
NODE(P) = node yang ditunjuk oleh P yaitu node pertama.
INFO(P) = A
NEXT(P) = node ke-dua
INFO(NEXT(NEXT(P))) = C
7.3 Menghapus Suatu Node Dari Linked List (Remove)
Untuk menghapus node dalam linked list digunakan
procedure FREENODE.
Jika Q adalah suatu variabel pointer, maka
FREENODE(Q) akan menyebabkan node yang ditunjuk oleh
variabel pointer Q dihapus dari linked list.
Perhatikan linked list berikut :

langkah ke-1 :
Q := Next(P)
langkah ke-2 :
Next(P) := Next(Q)
langkah ke-3 :
Freenode(Q)
procedure Freenode(Q)
(a) Next(Q) := Avail
(b) Info(Q) := Null

(c) Avail := Q
7.4 Menyisipkan Suatu Node Ke Dalam Linked List
Untuk menyisipkan node dalam linked list digunakan
procedure GETNODE.
Jika NEW adalah suatu variabel pointer, maka
GETNODE(NEW) akan menyebabkan node yang ditunjuk oleh
variabel pointer NEW disisipkan ke dalam linked list.
procedure Getnode(NEW)
if Avail = Null
then out-of-free-space
(a) Else begin
Getnode := Avail;

(b) Avail := Next(Avail);
(c) Next(Getnode) : = Null;
end;
Algoritma menyisipkan sebuah Node
(a) Getnode(NEW);
(b) Info(NEW) := Name;
(c) Q := Next(P)
(d) Next(P) := NEW

(e) Next(NEW) := Q
Logika Linked List pada Array
(a) Jika tidak menggunakan logika linked list
(pada umumnya dalam meng-input data digunalan
cara sequential)
(b) Jika menggunakan logika Linked List

Mendefinisikan Linked List dalam Pascal
Type nodeptr = ^ nodetype;
nametype = packed array [1..10] of char;
nodetype = record
info : nametype;
next : nodeptr;
end;
Var p : nodeptr;
node : nodetype;
Catatan :
P ^. Info : Info dari node yang ditunjuk oleh pointer P
P^. Next : Next dari node yang ditunjuk oleh pointer P
P := nil : pointer P berisi nilai Null
New(P) : fungsi Getnode dalam Pascal
dispose(P) : procedure Freenode dalam Pascal
Menghapus sebuah Node dalam Pascal
procedure removaf(p:nodeptr, var out:nametype);
var q : nodeptr;
begin
if (p^.Next = nil)

then UNDERFLOW-CONDITION
else begin
q := p^.Next;
p^.Next := q^.Next;
out := q^.Info;
dispose(q);
end;
end;
Menyisipkan sebuah Node dalam Pascal
procedure inseraf(p:nodeptr, in:nametype);
var q : nodeptr;
begin
New(q);
q^.Info := in;
q^.Next := p^.Next;
p^.Next := q;
end;

Penyisipan pada akhir dari suatu Linked List (Linked List
Antrean) dalam Pascal
Procedure Inserend(first : nodeptr, in :nametype);
Var newnode, q : nodeptr;
Begin
New(newnode);
newnode^.Info := in;
newnode^.Next := nil;
q := first;
do while (q^.next <> nil)
q := q^.Next;
q^.Next := newnode;
End;
Jika sebuah Linked List digunakan untuk
menggambarkan suatu antrean, dalam hal ini pointer dapat
langsung menunjuk ke rear/akhir dari antrean untuk
menghindari pengulangan melalui semua node untuk
menemukan node terakhir.
procedure inserend(in : nametype, var rear : nodeptr);

var newnode : nodeptr;
begin
New(newnode);
newnode^.Info := in;
newnode^.Next := nil;
rear^.Next := newnode;
rear := newnode;
end;
Circular Linked List
Head Nodes

Algoritma penyisipan node yang berisi variabel Name
pada head dalam Linked List
a. Ambil node baru pada free storage kemudian node
tersebut ditunjuk oleh pointer NEW
b. Isikan Info dengan Name pada node baru tsb.
c. Next dari node baru tsb. menunjuk ke node yang ditunjuk
oleh pointer Head
d. Pindahkan pointer Head menunjuk ke node yang baru.
Menghapus Node Khusus
Procedure removp(head : nodeptr, var p:nodeptr, out :
nametype);
Var prior, this : nodeptr;
flag : 0..2;
Begin
prior := head;
this := head^.next;
flag := 1;
While flag = 1
do begin
if (this = head)

then flag := 2;
if (this = p)
then flag := 0
else begin
prior := this;
this := this^.next;
end;
end;
if (flag > 0)
then Node yang ditunjuk oleh pointer p tidak ada
dalam List else
begin
prior^.next := p^.next;
out := p^.info;
dispose(p)
end;
End;

Doubly Linked List
Tiap node memiliki pointer yang menunjuk ke node
sesudahnya dan pointer yang menunjuk
ke node sebelumnya.
Node Sesudahnya : Next(Node)
Node sebelumnya : Prior(Node)
Next(Prior(P)) = P dan P = Prior(next(P))
Double linked list kosong :
prior head next Prior(Head) = Head
Next(Head) = Head
Dalam Pascal :
Type nodeptr = ^ nodetype
nodetype = record
prior : nodeptr;
info : nametype;
next : nodeptr
end;

Procedure menghapus sebuah node pada Double Linked
List
(a) Set pointer P
(b) Ubah pointer pada node Next predecessor P ke node
Successor P
(c) Ubah pointer pada node dari prior Successor P ke node
Predeccssor P
(d) bebaskan node yang ditunjuk pointer P
Dalam Pascal :
Procedure Removp(var p:nodeptr, out : nametype);
Var pred, succ : nodeptr;
Begin
pred := p^.prior;

succ := p^.next;
pred^.next := succ;
succ^.prior := pred;
out := p^.info;
dispose(p)
End;
Penyisipan sebuah Node pada Doubly Linked List
(a) Ambil sebuah node baru dan isikan datanya
(b) Set pointer dari Next node baru menunjuk ke Successor P
dan pointer Proirnya ke P
(c) Ubah pointer Next P menunjuk ke node baru
(d) Ubah pointer Prior dari Successor P menunjuk ke node
baru

Contoh Aplikasi Linked List
Polynomial
anxn + an-1 xn-1 + ... + a2 x2 + a1 x + a0
Type nodeptr = ^nodetype;
nodetype = record
exp : integer;
coef : integer;
next : nodeptr;
end;
143 x4 + 201 x2 + 14 x + 2
a4 = 143 a3 = 0 a2 = 201 a1 = 14 a0 = 2

BAB 8
STACK
8.1 Defenisi Stack
Stack atau tumpukan adalah bentuk khusus dari linear
list. Pada stack, penghapusan serta pemasukan elemennya
hanya dapat dilakukan di satu posisi, yakni posisi akhir dari
list. Posisi ini disebut puncak atau top dari stack. Elemen
stack S pada posisi ini dinyatakan dengan TOP(S).
Jelasnya, bila stack S [S1, S2, …, ST ], maka TOP(S)
adalah ST. Banyaknya elemen stack S pada suatu saat
tertentu biasa kita sebut sebagai NOEL(S). Jadi untuk stack
kita di atas, NOEL(S) = T. Seperti halnya pada semua linear
list, pada stack dikenal operasi penghapusan dan
pemasukan.
Operator penghapusan elemen pada stack disebut POP,
sedangkan operator pemasukan elemen, disebut PUSH.
Untuk menggambarkan kerja kedua operator di atas, berikut
ini suatu contoh bermula dari stack hampa S[ ], yang kita
gambar sebagai :

S NOEL(S) = 0, TOP(S) tidak terdefinisi
mula-mula kita PUSH elemen A, diperoleh Stack S = [A]
A S NOEL(S) = 1, TOP(S) = A
Apabila kemudian kita PUSH elemen B, diperoleh Stack S =
[A,B]
B S NOEL(S) = 2, TOP(S) = B
A
Selanjutnya bila PUSH elemen C, diperoleh Stack S = [A,B,C]
Kemudian bila kita POP elemen C, diperoleh Stack S = [A,B]

Terlihat bahwa kedua operasi di atas, pada stack adalah
bersifat ‘terakhir masuk pertama keluar’ atau ‘last in first out
(LIFO)’. Pada hakekatnya kita tidak membatasi berapa
banyak elemen dapat masuk ke dalam stack. Untuk suatu
stack S[S1, S 2,... , SNOEL], kita katakan bahwa elemen Si,
berada di atas elemen Sj, jika i lebih besar dari j. Suatu
elemen tidak dapat kita POP ke luar, sebelum semua elemen
di atasnya dikeluarkan.
8.2 Operasi Pada Stack
Terdapat empat operasi pada stack, yakni CREATE
(stack), ISEMPTY(stack), PUSH(elemen, stack), dan POP
(stack). CREATE(S) adalah operator yang menyebabkan stack
S menjadi satu stack hampa. Jadi NOEL(CREATE(S)) adalah
0, dan TOP(CREATE(S)) tak terdefinisi.
Sedangkan operator ISEMPTY(S) bermaksud memeriksa
apakah stack S hampa atau tidak. Operandnya adalah data
berType stack, sedangkan hasilnya merupakan data berType
boolean. ISEMPTY(S) adalah true, jika S hampa, yakni bila

NOEL(S) = 0, dan false dalam hal lain. Jelas bahwa
ISEMPTY(CREATE(S)) adalah true.
Operator PUSH (E,S) akan bekerja menambahkan
elemen E pada stack S. E ditempatkan sebagai TOP(S).
Operator POP(S) merupakan operator yang bekerja
mengeluarkan elemen TOP(S) dari dalam stack. POP(S) akan
mengurangi nilai NOEL(S) dengan 1. Suatu kesalahan akan
terjadi apabila, kita mencoba melakukan POP(S) terhadap
stack S yang hampa.
Kesalahan overflow akan terjadi jika kita melakukan
operasi pemasukan data (PUSH) pada stack yang sudah
penuh (dalam hal ini jika banyaknya elemen yang kita
masukkan ke dalam sebuah stack sudah melampaui batas
kemampuan memori atau telah didefinisikan sebelumnya).
Sebaliknya, kesalahan underflow akan terjadi jika stack
sudah dalam keadaan hampa, kita lakukan operasi
pengeluaran atau penghapusan (POP).

8.3 Deklarasi Stack Dalam Cobol Dan Pascal
Meskipun stack amat luas digunakan, banyak bahasa
pemrograman tidak mempu-nyai Type data stack secara built-
in. Dalam hal ini, Pemrogram harus memanipulasi sendiri
fasilitas yang dimiliki bahasa pemrograman tersebut, untuk
dapat melakukan operasi stack terhadap variabel stack.
Mungkin cara yang paling sederhana adalah
membentuk stack dalam bentuk se-macam array. Jelas kita
harus membedakan suatu stack dengan suatu array yang
sesungguhnya. Pemrogram harus memaksakan berlakunya
aturan LIFO bagi stack. Selain itu juga, penempatan stack
dalam bentuk array mengakibatkan suatu keterbatasan,
yakni bahwa elemen stack harus homogen. Keterbatasan lain
yang timbul adalah keharusan Pemrogram untuk
menentukan batas atas dari subscript array , walaupun stack
secara teori tidak memiliki batas maksimum dalam jumlah
elemen. Jika diinginkan, seharusnya kita dapat membuat
stack yang panjangnya tak hingga.
Satu hal yang nyata membedakan stack dengan array
adalah banyaknya elemen stack yang dapat bertambah atau

berkurang setiap waktu, sementara banyaknya elemen
sebuah array selalu tetap.
Sekarang marilah kita bicarakan deklarasi dari variabel
S yang berType data stack. Diasumsikan bahwa elemen dari S
masing-masing berType data integer dan panjang stack
maksimum adalah 100 elemen. Kita mendeklarasikan sebuah
array yang dilengkapi dengan variabel TOP-PTR.
Variabel TOP-PTR ini menyatakan subscript dari elemen
TOP(S) dari stack. Kita menamakan kombinasi dari array dan
indikator untuk TOP tersebut dengan nama STACK-STRUC.
Dengan penyajian seperti ini, berlaku bahwa NOEL(S) = TOP-
PTR, ISEMPTY(S) adalah true bila TOP-PTR = 0, dan false bila
TOP-PTR lebih besar dari 0.
Dalam COBOL
1 STACK-STRUCT. 02 S PIC 9(5)
OCCURS 100 TIMES. 02 TOP-PTR PIC 9(3).
Dalam Pascal
type stackstruct;
record stack: array[1..100[of integer;
top-ptr : integer

end
var S : stackstruct;
Kompilator tidak dapat mengerti aturan LIFO yang kita
inginkan. Untuk itu Pem-rogram harus berhati-ati dan tidak
memberi indeks pada S di sembarang tempat, selain dengan
nilai TOP-PTR.
Operasi PUSH dan POP dapat kita program sebagai
berikut : kita gunakan EON untuk menyatakan elemen yang
di-PUSH ke dalam S dan EOFF untuk elemen yang di-POP ke
luar S. NOEL-MAX menyatakan panjang maksimum stack.
Jadi di sini NOEL-MAX = 100.
Dalam paragraf COBOL :
PUSH.
IF TOP-PTR < NOEL-MAX.
THEN COMPUTE TOP-PTR = TOP-PTR+1
MOVE EON TO S(TOP-PTR)
ELSE overflow condition
POP
IF TOP-PTR > 0
THEN MOVE S(TOP-PTR) TO EOFF

COMPUTE TOP-PTR = TOP-PTR-1
ELSE underflow condition
Dalam procedure Pascal :
procedure PUSH (eon : integer);
begin
if (s.topptr < noelmax) then
begin s.topptr <= s.topptr + 1;
s.stack [s.topptr] := eon
end
else OVERFLOW-CONDITION
end;
procedure POP (var eoff : integer);
begin
if (s.topptr > 0)
then
begin eoff := s.Stack(s.topptr);
s.topptr := s.topptr-1
end
else UNDERFLOW-CONDITION
end;

8.4 Aplikasi Stack
Stack sangat luas pemakaiannya dalam menyelesaikan
berbagai macam problema. Kompilator, sistem operasi, dan
berbagai program aplikasi banyak menggunakan konsep
stack tersebut. Salah satu contoh adalah problema
Penjodohan Tanda Kurung atau matching parantheses.
Sebuah kompilator mempunyai tugas, salah satu di
antaranya adalah menyelidiki apakah Pemrogram telah
dengan cermat mengikuti aturan tata bahasa, atau sintaks
dari bahasa pemrograman yang bersangkutan. Misalnya
untuk parantheses kiri (tanda kurung buka) yang diberikan,
harus dipastikan adanya parantheses kanan (tanda kurung
tutup) yang bersangkutan.
Stack dapat digunakan dalam prosedur matching yang
digunakan. Algoritmanya sederhana, kita amati barisan
elemen dari kiri ke kanan. Bila kita bertemu dengan suatu
parantheses kiri, maka parantheses kiri tersebut kita PUSH
ke dalam sebuah stack. Selanjutnya bila kita bertemu dengan
suatu parantheses kanan, kita periksa stack, apakah hampa
atau tidak. Kalau stack hampa, berarti terdapat parantheses

kanan tanpa adanya parantheses kiri. Suatu kesalahan, atau
error, apabila stack tidak hampa, berarti tidak diperoleh
sepasang parantheses kiri, dan kanan, kita POP elemen ke
luar stack.
Jika sampai berakhirnya barisan elemen, stack tidak
hampa berarti terdapat parantheses kiri yang tidak tertutup
dengan parantheses kanan. Lagi suatu kesalahan. Kita akan
membuat programnya dalam COBOL. Barisan elemen yang
diamati kita tampung karakter demi karakter dalam variabel
array bernama STRING. Stack ditempatkan dalam array
STACK. Kita asumsikan bahwa jumlah maksimum karakter
dalam barisan elemen adalah 80 dan barisan berakhir
dengan karakter titik-koma..
Struktur datanya didefinisikan sebagai berikut :

Struktur di atas kita manipulasi dengan prosedur
sebagai berikut :
PERFORM SCAN-NEXT-CHAR
VARIYING NECT CHAR FROM 1 BY 1
UNTIL NEXT-CHAR > 80
OR CHAR(NEXT-CHAR) = “;”.
IF TOP-PTR NOT = 0 THEN invalid syntax. parenthesis kiri
tak tertutup
ELSE valid syntax
SCAN NEXT-CHAR
IF CHAR(NEXT-CHAR) = “(“
PERFORM PUSH
ELSE
IF CHAR(NEXT-CHAR) = “)”
PERFORM POP
PUSH COMPUTE TOP-PTR = TOP-PTR + 1
MOVE CHAR (NEXT-CHAR) TO STACK (TOP-PTR).
IF TOP-PTR > 0
COMPUTE TOP-PTR – 1
ELSE invalid syntax, tak ada parenthesis

Silakan Anda buat programnya dalam bahasa
pemrograman yang Anda kuasai.
Notasi Postfix
Aplikasi lain dari stack adalah pada kompilasi dari
ekspresi dalam bahasa pemrograman tingkat tinggi.
Kompilator harus mampu menyerahkan bentuk yang biasa,
misalnya ((A+B)*C/D+E^F)/G ke suatu bentuk yang dapat
lebih mudah dipergunakan dalam pembentukan kode
objeknya.
Cara yang biasa kita lakukan dalam menulis ekspresi
aritmetik seperti di atas, dikenal sebagai notasi infix. Untuk
operasi binar seperti menjumlah, membagi, mengurangi,
mengalikan ataupun memangkatkan, operator tampil di
antara dua operand, misalnya operator + tampil di antara
operand A dan B pada operasi A + B.
Stack dapat digunakan untuk mentransformasikan
notasi infix ini menjadi notasi posfix. Pada notasi posfix,
kedua operand tampil bersama di depan operator, misalnya
AB+ atau PQ* dan sebagainya. Kompilator akan lebih mudah
menangani ekspresi dalam notasi posfix ini.

Berikut contoh melakukan pengalihan ekspresi infix ke
postfix secara manual. Ekspresi infix = A + B / C * D akan
dialihkan menjadi ekspresi postfix.
1. Pilih sub-ekspresi yang berisi “dua operand dan satu
operator” yang memiliki level tertinggi di ekspresi di atas.
Didapat B / C dan C * D. Pilih yang paling kiri, maka kita
peroleh : B / C.
2. Ubah sub-ekspresi tersebut menjadi sebuah operand,
misalkan B / C menjadi E, maka ekspresi semula menjadi
: A + E * D.
3. Lakukan langkah ke (2) hingga ekspresi di atas menjadi
“dua operand dan satu operator” saja. Didapat : A + F
4. Alihkan menjadi bentuk postfix : operand-operand-
operator, diperoleh A F +
5. Kembalikan setiap operand menjadi ekspresi semula. F
tadinya adalah E * D, maka nilai F = E * D. Satukan
dengan ekspresi yang telah menjadi postfix. Hasilnya = A *
E+D
6. Ulangi langkah ke (5) hingga terbentuk ekspresi postfix.
Didapat A * B + C /D

Dengan demikian, ekspresi infix : A+B/C*D akan
menjadi ABC/D*+ dalam notasi postfix. Perhatikan dan
pelajari tabel berikut ini :
Bila ada sub-ekspresi di dalam tanda kurung, maka
sub-ekspresi tersebut harus dikerjakan terlebih dulu.
Berikut ini diberikan sebuah algoritma untuk
mengubah notasi infix ke dalam notasi posfix. Sebuah stack
digunakan untuk keperluan ini. Ekspresi diamati satu
persatu dari kiri ke kanan. Pada algoritma ini terdapat 4
aturan dasar, sebagai berikut :
1. Jika simbol adalah ''('' (kurung buka), maka ia kita PUSH
ke dalam stack
2. Jika simbol adalah '')'' (kurung tutup), POP dari stack
elemen-elemen stack, sampai pertama kali kita POP
simbol ''(''. Semua elemen stack yang di POP tersebut
merupakan output, kecuali ''('' tadi.

3. Jika simbol adalah sebuah operand, tanpa melakukan
perubahan elemen stack, operand tersebut langsung
mcrupakan output.
4. Jika simbol adalah sebuah operator, maka jika TOP stack
adalah operator dengan level lebih tinggi atau sama, maka
elemen TOP kita POP, sekaligus keluar sebagai output,
dilanjutkan proses seperti ini sampai TOP merupakan ''(''
atau operator dengan level lebih rendah. Kalau hal ini
terjadi, operator (yang diamati) kita PUSH ke dalam stack.
Biasanya ditambahkan simbol ; (titik-koma) sebagai
penutup ekspresi. Dalam keadaan ini, kita POP semua
elemen stack, sehingga stack menjadi hampa.
Dapat dicatat bahwa terdapat 3 level operator, yakni
pemangkatan (level tertinggi), level menengahnya adalah
perkalian (*) dan pembagian (/) dan level terendah adalah
penjumlahan (+) dan pengurangan (-). Tabel berikut
menunjukkan pelaksanaan algoritma di atas untuk
mengubah ekspresi ((A+B)*C/D+E^F)/G; ke dalam notasi
postfix.

L adalah K + I yang postfixnya : K + I
Bila disatukan dengan hasil sebelumnya menjadi : K + I /G
K adalah J / D yang postfixnya : J / D
Bila disatukan dengan hasil sebelumnya menjadi : J/D+I/G
J adalah H * C yang postfixnya : H * C
Bila disatukan dengan hasil sebelumnya menjadi :
H*C/D+I/G
I adalah E ^ F yang postfixnya : E ^ F

H*C/DÊ+F/G
H adalah A + B yang postfixnya : A + B
A+B*C/DÊ+F/G
Perhatikan, bahwa dalam notasi postfix, tidak ada tanda
kurung buka maupun kurung tutup. Silakan Anda buat
program (dengan bahasa pemrograman apapun yang Anda
kuasai) untuk menyelesaikan soal seperti di atas.
Untuk lebih jelasnya, mari kita ulangi langkah-demi
langkah. Misalkan untuk notasi infix : (A * (B + C) ^ D – E) / F
+ G, bagaimana bentuk postfixnya ?
Langkah pertama : kita mulai dari karakter pertama
mulai dari kiri :
( A * (B + C) ^ D - E) / F + G
Kita dapat operator ‘(‘ dan tentu saja stack masih dalam
keadaan hampa sehingga TOP(S) belum terdefinisi. Masukkan
saja tanda ‘(‘ ke dalam stack dan menjadi TOP(S)-nya.

( TOP(S)
Selanjutnya, kita bergeser ke kanan. Karakter berikutnya
adalah operand ‘A’. Operand (langsung) dijadikan hasil saja.
A * (B + C) ^ D - E) / F + G
( TOP(S) Hasil : A
Lanjutkan kembali dengan karakter berikutnya, yakni
operator ‘*’. Bandingkan operator tersebut dengan TOP(S)-
nya.
* (B + C) ^ D - E) / F + G
Karena TOP(S) adalah operator ‘(‘, maka masukkan
operator ‘*’ tersebut, sehingga TOP(S) sekarang adalah
operator ‘*’
* TOP(S)
( Hasil : A

Selanjutnya, kita dapatkan operator ‘(‘ yang akan
kembali kita masukkan ke dalam stack. Tanpa perlu ragu-
ragu lagi, operator ‘(‘ dimasukkan ke dalam stack dan akan
menjadi TOP(S) yang baru.
( B + C) ^ D - E) / F + G
( TOP(S)
*
( Hasil : A
Kita lanjutkan lagi untuk memeriksa karakter
berikutnya. Kita dapatkan operand ‘B’.
Seperti biasa, operand (langsung) dijadikan hasil saja.
B + C) ^ D - E) / F + G
( TOP(S)
*
(
Hasil : A B
Selanjutnya, bergeser lagi ke kanan, kita dapatkan
operator ‘+‘ yang akan kembali kita masukkan ke dalam

stack. Tanpa perlu ragu-ragu lagi, jika TOP(S) adalah ‘(‘, maka
operator apapun dimasukkan saja ke dalam stack dan akan
menjadi TOP(S) yang baru.
+ C) ^ D - E) / F + G
+ TOP(S)
(
*
( Hasil : A B
Kita lanjutkan lagi untuk memeriksa karakter
berikutnya. Kita dapatkan operand ‘C.’ Seperti biasa, operand
(langsung) dijadikan hasil saja.
C ) ^ D - E) / F + G
+ TOP(S)
(
*
( Hasil : A B C
Bergeser ke kanan lagi, kita peroleh operator ‘)’ yang
akan dibandingkan dengan TOP(S)-nya.

) ^ D - E) / F + G
Jika yang akan kita (coba) masukkan adalah operator
‘)’, maka keluarkan isi stack satu per satu (menjadi hasil)
hingga ketemu operator ‘(‘ yang terdekat. Tetapi, baik operator
‘(‘ maupun operator ‘)’-nya dibuang saja (tidak dijadikan
hasil). Hasilnya :
* TOP(S) Hasil : A B C +
(
Berikutnya, kembali kita bergeser ke kanan satu
langkah, kita peroleh operator ‘^’.
^ D - E) / F + G
Kita bandingkan operator ‘^’ dengan TOP(S)-nya yakni ‘*’.
Karena derajat operasi ‘^’ lebih tinggi dari ‘*’, maka masukkan
saja.
^ TOP(S)
* Hasil : A B C +
(

Kita lanjutkan lagi, dan kembali kita dapatkan operand
‘D’. Seperti biasa, langsung jadikan hasil saja.
D - E) / F + G
^ TOP(S)
* Hasil : A B C + D
(
Geser lagi ke kanan. Kini kita dapatkan operator ‘-‘.

Bandingkan operator tersebut dengan posisi TOP(S).
- E) / F + G
Karena operator ‘-‘ berderajat operasi lebih rendah dari
operator ‘^’, maka keluarkan operator ‘^’ dari dalam stack
untuk dijadikan hasil.
* TOP(S) Hasil : A B C + D ^
(
Kini TOP(S) adalah operator ‘*’. Karena operator ‘*’ yang
merupakan TOP(S) tersebut masih berderajat operasi lebih
tinggi dari operator ‘-’ yang akan kita masukkan, maka
operator ‘*’ tersebut dikeluarkan dari stack dan dijadikan

hasil. Proses pengulangan seperti ini (selama TOP(S)
berderajat operasi lebih tinggi dari operator yang akan
dimasukkan ke dalam stack) disebut dengan rekursif.
Perhatikan, kini TOP(S) berisi operator ‘(‘. Operator
tersebut hanya akan bereaksi dengan operator ‘)’. Dengan
demikian, operator ‘-’ kini kita masukkan ke dalam stack dan
menempati TOP(S).
- TOP(S) Hasil : A B C + D ^ *
Langkah berikutnya, kembali kita periksa satu karakter
di kanan ‘-’ tadi, kita dapatkan operand ‘E’.
E )/F+G
Seperti biasa, operand (langsung) kita jadikan hasil :
- TOP(S) Hasil : A B C + D ^ * E
(

Di kanan operand ‘E’ kita peroleh operator ‘)’. Ingat,
operator ‘)’ akan mengeluarkan semua isi stack yang dimulai
dari posisi TOP(S) hingga ke operator ‘(‘, tetapi operator ‘(‘ dan
‘)‘ dibuang saja, tidak dimasukkan menjadi hasil.
Tampak bahwa stack dalam keadaan hampa,
ISEMPTY(S) = true, NOEL(S) = 0, TOP(S) tidak terdefinisi.
Kita lanjutkan dengan operator ‘/’. Karena stack dalam
keadaan hampa, maka operator ‘/’ dimasukkan saja ke dalam
stack.
/ F+G
Hasil : A B C + D ^ * E -
/ TOP(S)
Kini stack berisi kembali, ISEMPTY(S) = false, NOEL(S) =
1, TOP(S) = ‘/’ Kembali kita lanjutkan, kita dapatkan operator
‘F’ yang tentu saja langsung dijadikan hasil.

F +G
Hasil : A B C + D ^ * E - F
/ TOP(S)
Berlanjut lagi, kini kita dapatkan operator ‘+’ yang
akan kita bandingkan dengan TOP(S)-nya yaitu ‘/’.
+ G
Karena operator ‘+’ berderajat operasi lebih rendah dari
‘/’, maka TOP(S) dikeluarkan sebagai hasil dan posisinya
digantikan oleh operator ‘+’.
Hasil : A B C + D ^ * E - F
/
+ TOP(S)
Pemeriksaan sampai pada elemen terakhir dari notasi
infix yaitu operand ‘G’.
Seperti biasa, operand langsung dijadikan hasil saja.
Hasil : A B C + D ^ * E - F / G
+ TOP(S)

Nah, karena tidak ada lagi elemen dari notasi yang akan
diperiksa, maka akhiri pengerjaan dengan mengeluarkan
semua isi stack yang dimulai dari posisi TOP(S)-nya. Ingat,
prinsip kerja stack adalah last in first out. Karena kebetulan
cuma ada satu elemen di dalam stack yang juga merupakan
TOP(S)-nya, maka hanya satu itu yang dikeluarkan. Hasil
akhirnya menjadi :
Hasil : A B C + D ^ * E - F / G +
Dengan demikian, untuk notasi infix : (A * (B + C) ^ D –
E) / F + G akan menjadi A +B ^C * D – E / F + G dalam notasi
postfix-nya. Periksalah !

BAB 9
QUEUE/ANTREAN
9.1 Defenisi Queue
Antrean atau queue adalah suatu bentuk khusus dari
linear list, dengan operasi penyisipan (insertion) hanya
diperbolehkan pada salah satu sisi, yang disebut sisi
belakang (REAR), dan operasi penghapusan (deletion) hanya
diperbolehkan pada sisi lainnya, yang disebut sisi depan
(FRONT), dari list.
Sebagai contoh dapat kita lihat antrean (Q1, Q2,...,QN).
Kita notasikan bagian depan dari antrean Q sebagai
FRONT(Q) dan bagian belakang sebagai REAR(Q).
Jadi untuk antrean Q = [Q1, Q2, …, QN] :
FRONT(Q) = Q1 dan REAR(Q) = QN
Kita menggunakan notasi NOEL(Q) untuk menyatakan
jumlah elemen di dalam antrean Q. NOEL(Q) mempunyai
harga integer. Untuk antrean Q = [Q1,Q2,…, QN], maka
NOEL(Q) = N.

Operator penyisipan (insertion) disebut INSERT dan
operator penghapusan (deletion) disebut REMOVE.
Sebagai contoh untuk memperjelas bekerjanya antrean,
kita perhatikan sederetan operasi berikut ini. Kita mulai
dengan antrean hampa Q. Antrean hampa Q, atau Q[ ] dapat
disajikan seperti terlihat pada Gambar.
--------------------------------
--------------------------------
Gambar Antrean hampa
Di sini :
NOEL(Q) = 0
FRONT(Q) = tidak terdefinisi
REAR(Q) = tidak terdefinisi
Lalu kita INSERT elemen A, diperoleh Q = [A], seperti terlihat
di Gambar.
------ ------------
A
------ ------------
Gambar Elemen A dimasukkan
Di sini :
NOEL(Q) = 1

FRONT(Q) = A
REAR(Q) = A
Dilanjutkan dengan INSERT elemen B, sehingga
diperoleh Q = [A, B], seperti terlihat di Gambar.
------ ------------
A B
------ ------------
Gambar Elemen B dimasukkan setelah elemen A
Di sini :
NOEL(Q) = 2
FRONT(Q) = A
REAR(Q) = B
Dilanjutkan dengan INSERT elemen C, sehingga
diperoleh Q = [A, B, C], seperti terlihat di Gambar.
-------------
ABC
-------------
Gambar Elemen C dimasukkan setelah elemen B
Di sini :
NOEL(Q) = 3
FRONT(Q) = A
REAR(Q) = C

Dilanjutkan dengan DELETE satu elemen dari Q,
sehingga diperoleh Q = [B, C], seperti terlihat di Gambar.
-------------
BC
-------------
Gambar Satu elemen dihapus
Di sini :
NOEL(Q) = 2
FRONT(Q) = B
REAR(Q) = C
Demikian seterusnya, kita dapat melakukan
serangkaian INSERT dan DELETE yang lain. Suatu kesalahan
underflow dapat terjadi, yakni apabila kita melakukan
penghapusan pada antrean hampa. Antrean dikatakan
beroperasi dalam cara FIRST-IN-FIRST-OUT (FIFO). Disebut
demikian karena elemen yang pertama masuk merupakan
elemen yang pertama ke luar.
Model antrean, sangat sering ditemukan dalam kejadian
sehari-hari, seperti mobil yang menunggu untuk pengisian
bahan bakar, mobil pertama dari antrean merupakan mobil
pertama yang akan keluar dari antrean. Sebagai contoh lain

adalah orang yang menunggu dalam antrean di suatu bank.
Orang pertama yang berada di dalam barisan tersebut akan
merupakan orang pertama yang akan dilayani.
9.2 Operasi Dasar Pada Antrean
Ada 4 operasi dasar yang dapat dilakukan pada
struktur data antrean, yakni :
1. CREATE(antrean)
2. ISEMPTY(antrean)
3. INSERT(elemen,antrean)
4. REMOVE(antrean)
Pandang misalnya antrean Q = [Q1, Q2, …, QNOEL], maka :
Create (antrean) :
Create (Q) adalah suatu operator untuk membentuk
dan menunjukkan suatu antrean hampa Q.
Berarti :
NOEL(CREATE(Q)) = 0
FRONT(CREATE(Q)) = tidak terdefinisi
REAR(CREATE(Q)) = tidak terdefinisi

Isempty (antrean)
ISEMPTY(Q) adalah operator yang menentukan apakah
antrean Q hampa atau tidak. Operand dari operator ini
merupakan antrean, sedangkan hasilnya merupakan Type
data boolean.
Di sini :
ISEMPTY(antrean) = true, jika Q hampa, yakni jika
NOEL(Q)=0
= false, dalam hal lain.
Maka, ISEMPTY(CREATE(Q)) = true.
Insert (elemen, antrean)
Insert (E,Q) adalah operator yang memasukkan elemen
E ke dalam antrean Q. Elemen E ditempatkan di bagian
belakang dari antrean. Hasil dari operasi ini adalah antrean
yang lebih panjang.
REAR(INSERT(E,Q)) = E
QNOEL adalah E
ISEMPTY(INSERT(E,Q)) = false

Remove (antrean)
Remove (Q) adalah operator yang menghapus elemen
bagian depan dari Antrean Q. Hasilnya merupakan antrean
yang lebih pendek. Pada setiap operasi ini, harga dari
NOEL(Q) berkurang satu, dan elemen kedua dari Q menjadi
elemen terdepan.
Jika NOEL(Q) = 0, maka REMOVE(Q) memberikan
suatu kondisi error, yakni suatu underflow. Jelas bahwa
REMOVE(CREATE(Q)) juga memberikan kondisi underflow
error.
9.3 Penyajian Dari Antrean
Antrean dapat disajikan di dalam komputer dalam
berbagai cara. Biasanya dengan menggunakan one-way-list
(linear linked list) ataupun menggunakan array. Kalau tidak
disebutkan lain, maka antrean kita sajikan dalam array
QUEUE, dengan dilengkapi dua variabel penunjuk. FRONT,
berisi lokasi dari elemen DEPAN antrean dan REAR, berisi
lokasi dari elemen BELAKANG antrean. Nilai FRONT = NULL
menunjukkan bahwa antrean adalah hampa.

Gambar yang menunjukkan bagaimana menyajikan
suatu antrean dalam sebuah array QUEUE dengan N elemen.
Gambar itu juga menunjukkan bagaimana melakukan
pemasukan dan penghapusan elemen antrean.
Pada Gambar 4.6(a) terlihat bahwa antrean mula-mula
terdiri atas elemen AAA (sebagai DEPAN), BBB, CCC, dan
DDD (sebagai BELAKANG) . Gambar 4.6.(b) me-nunjukkan
keadaan setelah penghapusan elemen. Di sini elemen DEPAN
yakni AAA dihapus. Gambar 4.6.(c) menggambarkan keadaan
setelah penambahan berturut-turut elemen EEE dan FFF.
Terakhir sekali, keadaan setelah penghapusan elemen
DEPAN, BBB.
Gambar cara kerja antrian/queue

Dapat kita lihat bahwa pada setiap kali penghapusan,
nilai lokasi FRONT akan bertambah 1. Untuk setiap kali
pemasukan elemen, nilai REAR akan bertambah 1. Hal ini
berakibat bahwa setelah pemasukan elemen ke N (berawal
dari antrean hampa), maka lokasi QUEUE(N) telah diduduki.
Di sini mungkin saja tidak sebanyak N elemen ada dalam
antrean (karena sudah dilakukan beberapa penghapusan).
Untuk melakukan pemasukan berikutnya, yakni
memasukkan elemen ITEM, kita dapat menggunakan lokasi
QUEUE(1). Demikian seterusnya. Dalam hal ini, kita
menggunakan array sirkular, yakni bahwa QUEUE(1) datang
sesudah QUEUE(N) di array dalam. Berdasarkan asumsi ini,
maka REAR adalah 1.
Secara yang sama, jika FRONT = N dan kita akan
melakukan penghapusan, maka sekarang FRONT adalah 1,
bukan N+l.
Gambar yang memperlihatkan antrean yang disimpan
dalam array dengan 5 lokasi memori, sebagai array sirkular.

Gambar Circular Array
Sekarang kita akan menampilkan algoritma QINSERT,
yang dimaksudkan untuk memasukkan data ke dalam suatu
antrean. Yang mula-mula kita laksanakan dalam algoritma
adalah, memeriksa kemungkinan terjadi overflow error, yakni
dengan melihat apakah antrean tersebut terisi penuh.

Algoritma kedua adalah algoritina QDELETE yang
dimaksudkan untuk menghapus elemen DEPAN dari
antrean.Yang mula-mula kita laksanakan ialah memeriksa
kemungkinan terjadi underflow error, yakni dengan melihat
apakah antrean tersebut kosong.
Algoritma Q INSERT
Q INSERT (QUEUE, N, FRONT, DATA)
1. [Apakah antrean penuh]
Jika FRONT := 1 dan REAR := N, atau jika FRONT :=
REAR + 1, maka write OVERFLOW, return.
2. Jika FRONT := NULL, maka FRONT := 1
REAR := 1
dalam hal lain
jika REAR := N, maka
REAR := 1
dalam hal lain
REAR := REAR + 1
2. QUEUE (REAR) := DATA (masukkan elemen baru)
3. Return

Algoritma QDELETE
QDELETE(QUEUE, N, FRONT, REAR, DATA)
1. [Apakah antrean kosong]
Jika FRONT := NULL,
maka Write :
UNDERFLOW, return
2. DATA := QUEUE(FRONT)
3. (FRONT mendapat nilai baru). Jika FRONT := REAR, maka
(antrean memuat hanya 1 elemen) FRONT := NULL.
REAR := NULL, dalam hal lain
Jika FRONT := N, maka FRONT := 1, dalam hal lain :
FRONT := FRONT + 1
4. Return.
9.4 Deque
Kali ini akan kita bicarakan beberapa struktur data
yang merupakan bentuk variasi dari struktur data antrean
atau queue, yang telah kita bicarakan terdahulu. Struktur
data tersebut adalah deque (atau deck atau dequeue) dan
Antrean berprioritas (atau priority queue).

DEQUE adalah suatu linear list atau daftar linear, yang
penambahan dan penghapusan elemennya dapat dilakukan
pada kedua sisi ujung list, tetapi tidak dapat dilakukan di
tengah-tengah list. Dari sini, kita boleh mengatakan bahwa
deque adalah suatu queue ganda atau double queue.
Ada banyak cara penyajian suatu deque di dalam
komputer. Namun yang biasa digunakan adalah penyajian
dengan cara penempatan di dalam sebuah array sirkular atau
array putar DEQUE.
Di sini kita menggunakan dua pointer atau penunjuk,
LEFT dan RIGHT, yang berturut-turut menunjuk pada sisi
kiri dan sisi kanan dari deque. Kita senantiasa
mengasumsikan bahwa elemen deque berurut dari kiri ke
kanan. Pengertian sirkular di atas timbul karena elemen
DEQUE(l) berada sesudah elemen DEQUE(N) dari array.
Gambar 4.8 menggambarkan 2 buah deque, masing-
masing berisi 4 elemen, yang ditempatkan di dalam sebuah
array dengan 8 lokasi memori. Kondisi LEFT = NULL
dipergunakan untuk menyatakan bahwa suatu deque adalah
hampa.

Selain deque dengan sifat yang telah kita sebutkan di
atas, masih ada 2 model variasi deque. Kedua variasi tersebut
adalah deque input terbatas, dan deque output terbatas, yang
merupakan tengah-tengah antara deque dan antrean.
Deque input terbatas adalah suatu deque yang
membatasi pemasukan elemen hanya pada satu ujung dari
list, sementara penghapusan elemen boleh dilakukan pada
kedua ujung list.
Deque output terbatas adalah suatu deque yang hanya
memperbolehkan penghapusan elemen pada salah satu
ujung, tetapi memperbolehkan pemasukan elemen pada
kedua ujung list.
Sama halnya dengan antrean, komplikasi dapat timbul
dalam pemrosesan deque, yakni apabila (a) terjadi overflow,

yakni pada saat suatu elemen dimasukkan ke dalam deque
yang sudah berisi penuh, dan (b) terjadi underflow, yakni bila
suatu elemen harus dihapus dari deque yang sudah hampa.
9.5 Antrean Berprioritas
Sekarang kita bahas mengenai antrean berprioritas
antrean berprioritas adalah himpunan elemen, yang setiap
elemennya telah diberikan sebuah prioritas, dan urutan
proses penghapusan elemen adalah berdasarkan aturan
berikut :
1. Elemen yang prioritasnya lebih tinggi, diproses lebih
dahulu dibandingkan dengan elemen yang
prioritasnya lebih rendah.
2. Dua elemen dengan prioritas yang sama, diproses
sesuai dengan urutan mereka sewaktu dimasukkan
ke dalam priority queue.
Suatu protoType dari antrean berprioritas adalah sistem
time sharing. Di sini pro-gram dengan prioritas yang lebih
tinggi diproses terlebih dahulu, dan sejumlah program

dengan prioritas yang sama akan membentuk queue yang
standar.
Ada bermacam-macam cara penyimpanan antrean
berprioritas di dalam memori. Kita akan membahas dua di
antaranya, yakni yang pertama kita pergunakan cara
penyimpanan dalam one-way list, dan yang kedua dengan
cara penyimpanan dalam multiple queue.
Kemudahan dan kesulitan di dalam operasi
penambahan ataupun penghapusan elemen, pada antrean
berprioritas, akan tergantung pada penyajian mana yang
akan dipilih.
9.6 Penyajian One-Way List Dari Antrean Berprio-Ritas
Satu cara untuk menyimpan antrean berprioritas dalam
memori adalah dengan menggunakan one-way list, dengan
ketentuan seperti berikut ini :
1. Setiap simpul dalam list akan berisi 3 buah data atau
field, yakni field informasi yang biasa disebut INFO,
Nomor prioritas (priority number) disebut PRN, dan
nomor link, disebut LINK.
2. Simpul X mendahului simpul Y di dalam list :

a. bila X mempunyai prioritas yang lebih tinggi dari
pada Y
b. bila keduanya mempunyai prioritas yang sama,
tetapi X dimasukkan ke dalam queue terlebih
dahulu sebelum Y.
Ini berarti bahwa urutan pada one-way list adalah
berkorespondensi dengan urutan pada antrean berprioritas.
Priority number akan beroperasi seperti cara yang biasa
dipakai, yakni simpul dengan priority number terendah, akan
mendapat prioritas yang tertinggi.
Sebagai contoh, perhatikan Gambar 4.9 yang
memperlihatkan diagram skematik dari antrean berprioritas
dengan 7 elemen. Diagram tidak dapat menceritakan kepada
kita apakah BBB dimasukkan ke dalam list sebelum atau
sesudah DDD. Di lain pihak, diagram dapat memperlihatkan
kepada kita, bahwa BBB dimasukkan sebelum CCC, karena
BBB dan CCC mempunyai priority number yang sama dan
BBB berada sebelum CCC di dalam list. Pada Gambar 4.10
diperlihatkan bagaimana cara antrean berprioritas muncul

dalam memori, dengan menggunakan array INFO, PRN, dan
LINK.
Sifat utama dari penyajian one-way list dari sebuah
antrean berprioritas adalah bahwa elemen dalam antrean
yang seharusnya diproses pertama kali selalu muncul pada
bagian permulaan one-way list . Oleh karena itu, adalah
sangat sederhana untuk menghilangkan dan memproses
sebuah elemen antrean prioritas kita tersebut.
Algoritmanya adalah sebagai berikut :
Algoritma 1
Algoritma ini bekerja untuk menghapus dan memproses
elemen pertama dalam sebuah antrean berprioritas yang
muncul dalam memori sebagai sebuah one-way list.
1. Pasang ITEM := INFO(START). (Langkah ini
dimaksudkan untuk menyimpan data dalam simpul
pertama).

2. Hapus simpul pertama dari list.
3. Proses ITEM
4. Keluar
Silakan anda merinci algoritma di atas, lengkap dengan
kemungkinan terjadinya underflow.
Menambah suatu elemen pada antrean berprioritas kita
adalah jauh lebih rumit dibandingkan dengan proses
menghapus sebuah elemen dari antrean, karena kita harus
menemukan tempat yang benar untuk menyisipkan elemen
itu.

Algoritma 2
Algoritma ini bekerja untuk menambahkan sebuah
ITEM dengan nomor prioritas N, pada suatu antrean
berprioritas yang disimpan dalam memori sebagai sebuah
one-way list.
1. Telusuri one-way list sampai ditemukan suatu simpul
X yang nomor prioritasnya melebihi N. Sisipkan ITEM
di depan simpul X
2. Jika tidak ditemukan simpul semacam itu, sisipkan
ITEM sebagai elemen terakhir list.
Kesulitan utama dalam algoritma muncul dari
kenyataan bahwa ITEM disisipkan sebelum simpul X. Hal ini
berarti bahwa ketika menelusuri list itu, seseorang harus
tetap memperhatikan alamat simpul yang mendahului simpul
yang sedang diakses.

Sebagai contoh, perhatikan kembali antrean
berprioritas pada Gambar 4.9. Misal-kan item XXX dengan
nomor prioritas 2, akan dimasukkan ke dalam antrean. Kita
telusuri list, sambil membandingkan nomor prioritas.
Perhatikan bahwa elemen DDD merupakan elemen pertama
di dalam list yang dijumpai mempunyai nomor prioritas lebih
besar dari nomor prioritas XXX Karena itu, XXX dimasukkan
ke dalam list di depan DDD, seperti terlihat pada Gambar 4-
11.
Dapat dilihat pula bahwa XXX datang sesudah BBB dan
CCC, yang mempunyai nomor prioritas sama dengan XXX.
Pandang sekarang kita akan menghapus elemen dari queue.
Dalam hal ini AAA merupakan elemen pertama dari list akan
terhapus. Pandang bahwa tidak ada lagi penyisipan elemen
lain. Elemen berikutnya yang akan dihapus adalah BBB, lalu
CCC, kemudian XXX dan seterusnya.
9.7 Penyajian Array Dari Antrean Berprioritas
Cara lain untuk menyajikan suatu antrean berprioritas
dalam memori adalah menggunakan suatu antrean terpisah

untuk setiap tingkat prioritas (untuk setiap nomor prioritas).
Setiap antrean semacam itu akan muncul dalam array
sirkularnya sendiri dan harus mempunyai sepasang
penunjuk sendiri, FRONT dan REAR. Kenyataannya, jika
masing-masing antrean dialokasikan jumlah ruang yang
sama, suatu array dua dimensi QUEUE dapat digunakan
sebagai pengganti array. Gambar 4.12 menunjukkan repre-
sentasi ini, untuk antrean berprioritas dalam Gambar 4.11,
perhatikan bahwa FRONT(K) dan REAR(K) berisi masing-
masing elemen depan dan belakang dari baris K array
QUEUE, baris yang memuat antrean elemen yang bernomor
prioritas K.
Berikut ini garis besar algoritma untuk menghapus dan
menyisipkan elemen pada suatu antrean berprioritas yang

disimpan dalam memori oleh sebuah array dua dimensi
QUEUE, seperti tersebut di atas.
Algoritma 3
Algoritma ini bekerja untuk menghapus dan memproses
elemen pertama dalam sebuah antrean berprioritas yang
disajikan oleh suatu array dua dimensi QUEUE.
1. (cari antrean tidak hampa yang pertama). Cari K
terkecil, sedemikian sehingga FRONT(K) tidak sama
dengan NULL.
2. Hapus dan proses elemen dari baris K QUEUE.
3. Keluar
Algoritma 4
Algoritma ini bekerja untuk menambah sebuah ITEM
dengan nomor prioritas M pada suatu antrean berprioritas
yang disajikan oleh sebuah array dua dimensi QUEUE.
1. Sisipkan ITEM sebagai elemen belakang dari baris M
QUEUE.
2. Keluar

Jika kita ambil kesimpulan tentang baik buruknya
masing-masing penyajian antrean berprioritas tersebut di
atas, maka dapatlah dikatakan bahwa penyajian array adalah
lebih efisien dari segi waktu dibandingkan dengan penyajian
one-way list. Namun dari segi ruang yang dibutuhkan,
penyajian one-way list adalah lebih efisien.
9.8 Tambahan : Mesin Antrean
Setelah kita bahas antrean dengan definisi dan
teorinya, sekarang akan kita bahas suatu prosedur untuk
pelaksanaan beberapa operasi terhadap antrean. Himpunan
prosedur tersebut kita namakan “mesin antrean”.
Dalam pembahasan mesin antrean, kita menyediakan
beberapa perintah dalam bentuk perintah huruf besar
tunggal. Input dan output dari nilai yang akan dijalankan
harus melalui suatu kode yang berupa perintah huruf besar
tunggal. Petunjuk perintah dari mesin antrean adalah sebagai
berikut :
I adalah menyisipkan sebuah nilai ke dalam antrean.
D adalah menghapus nilai depan dari sebuah antrean.

F adalah menampilkan nilai depan dari sebuah antrean.
B adalah menentukan maksimum isi antrean.
C adalah mengosongkan antrean.
E adalah keluar.
Deklarasi untuk perintah mesin antrean
Penyisipan Sebuah Nilai Ke Dalam Antrean
Maksud dari operasi ini adalah untuk menyisipkan
sebuah nilai ke dalam antrean. Sebelum menyisipkan sebuah
nilai, maka harus diketahui dahulu batas maksimumnya
dengan menggunakan perintah huruf besar tunggal B.

Sebagai contoh dalam suatu antrean akan diisi nilai
1,2,3,4,5 dengan menggunakan perintah huruf besar tunggal
I. Sebelum mengisi nilai harus diketahui dahulu batas
maksimumnya, misal batas maksimum di sini adalah 5
dengan menggunakan perintah huruf besar tunggal B.
Hasilnya akan terlihat dengan menggunakan perintah
huruf tunggal F, maka hasilnya adalah 1,2,3,4,5.
Jika nilai antrean yang disisipkan lebih besar dari batas
maksimumnya, maka nilai yang ditentukan tadi tidak akan
keluar, di situ akan terlihat bahwa “antrean telah penuh,”
dengan demikian kita harus mencoba perintah yang lain.

Menghapus Nilai Depan Dari Sebuah Antrean
Selain menyisipkan sebuah nilai ke dalam antrean,
antrean juga perlu dihapus. Untuk menghapus sebuah nilai
antrean yakni dengan menggunakan perintah huruf besar
tunggal D.
Pada operasi ini akan ditentukan jika kita ingin
menghapus sebuah nilai yang telah disisipkan. Dalam hal ini
yang akan dihapus adalah nilai depan dari suatu antrean.
Sebagai contoh dalam suatu antrean yang mempunyai
nilai 1,2,3,4,5 dengan menggunakan perintah huruf besar
tunggal I, maka nilai yang terhapus adalah nilai I dengan
menggunakan perintah huruf besar tunggal D. Akan terlihat
hasilnya dengan menggunakan perintah huruf besar tunggal
F menjadi 2,3,4,5.
Perlu kita diketahui, jika dalam suatu antrean yang
akan dihapus tidak ada nilainya, maka akan terlihat hasilnya
''Antrean kosong'', seperti terlihat pada procedure di bawah
ini.

Menampilkan Nilai Depan Dari Sebuah Antrean
Operasi ini merupakan suatu operasi yang khusus
menampilkan sesuatu nilai. Pada dasarnya operasi ini hanya
merupakan sebagai tampilan, khususnya menampilkan nilai
depan dari sebuah antrean. Nilai -nilai yang telah dihasilkan
merupakan nilai-nilai seperti terlihat pada contoh di atas
yakni pada penggunaan perintah-perintah huruf besar
tunggal I, D, B dan C. Perintah huruf besar tunggal C
merupakan perintah yang fungsinya hanya untuk
mengosongkan antrean.
Jika antrean yang dijalankan tidak menghasilkan suatu
nilai, maka hasilnya akan terlihat menjadi ''Antrean kosong''

BAB 10
TREE
10.1 Defenisi Tree (Pohon)
Pohon atau tree adalah salah satu bentuk graph
terhubung yang tidak mengandung sirkuit. Karena
merupakan graph terhubung, maka pada pohon selalu
terdapat path atau jalur yang menghubungkan setiap dua
simpul dalam pohon. Kali ini kita sampai pada pembahasan
suatu bentuk pohon, yang dilengkapi dengan apa yang
disebut “akar” atau “root”. Pohon semacam ini disebut pohon
berakar atau rooted tree. Selanjutnya, lebih khusus lagi
dibahas tentang pohon berakar yang disebut “pohon binar”
atau “binary tree”. Contoh di Gambar 7.1 yang disebut pohon
berakar P.

Sifat utama sebuah pohon berakar adalah :
1. Jika pohon mempunyai simpul sebanyak n, maka
banyaknya ruas atau edge adalah (n-1). Pada pohon P di
Gambar 7.1, banyak simpul adalah n = 8, dan banyak
edge (n – 1) = 8 – 1 = 7
2. Mempunyai simpul khusus yang disebut “root,” yang
merupakan simpul yang memiliki derajat keluar >= 0, dan
derajat masuk = 0. Simpul P merupakan root pada pohon
di Gambar 7.1 di atas.
3. Mempunyai simpul yang disebut sebagai “daun” atau
“leaf,” yang merupakan simpul berderajat keluar 0, dan
berderajat masuk = 1. Simpul-simpul R, S, V, W
merupakan daun pada pohon di Gambar 7.1.
4. Setiap Simpul mempunyai tingkatan atau level, yang
dimulai dari root yang le-velnya = 0, sampai dengan level n
pada daun paling bawah.
Pada pohon P di Gambar
7.1 : P berlevel 0
Q dan T berlevel 1
R, S dan U berlevel

2 V dan W berlevel
“Simpul yang mempunyai level sama disebut “bersaudara”
atau “brother” atau “siblings”.
5. Pohon mempunyai ketinggian atau kedalaman atau
“height,” yang merupakan level tertinggi + 1. Pohon di
Gambar 7.1 mempunyai ketinggian atau kedalaman 3+1 =
4.
6. Pohon mempunyai berat atau bobot atau “weight,” yang
merupakan banyaknya daun pada pohon. Pohon di
Gambar 7.1 mempunyai bobot = 4.
10.2 Pohon Binar (Binary Tree)
Dalam struktur data, pohon memegang peranan yang
cukup penting. Struktur ini biasanya digunakan terutama
untuk menyajikan data yang mengandung hubungan
hirarkikal antara elemen-elemen mereka. Kita lihat misalnya,
data pada record, keluarga dari pohon, ataupun isi dari tabel.
Mereka mempunyai hubungan hirarkikal.
Bentuk pohon berakar yang khusus, yang lebih mudah
kita kelola dalam komputer adalah pohon binar (binary tree).

Bentuk pohon berakar yang umum, kita kenal sebagai “pohon
umum” atau “general tree.”
Sebuah pohon binar T didefinisikan terdiri atas sebuah
himpunan hingga elemen yang disebut simpul (node),
sedemikian sehingga :
(a) T adalah hampa (disebut pohon null) atau;
(b) T mengandung simpul R yang dipilih (dibedakan dari yang
lain), disebut “akar” atau “root” dari T, dan simpul sisanya
membentuk 2 pohon binar (subpohon kiri dan subpohon
kanan dari akar R) T1 dan T2 yang saling lepas.
Perhatikan bahwa pendefinisian pohon binar di atas
adalah rekursif. Jika T1 tidak hampa, maka simpul akarnya
disebut suksesor kiri dari R. Hal serupa untuk akar dari T2
(tidak hampa) disebut suksesor kanan dari R.
Pohon binar acapkali disajikan dalam bentuk diagram.
Perhatikan contoh Pohon binar pada Gambar 7.2 berikut.
Pohon binar tersebut mempunyai 11 simpul yang diberi label
huruf A sampai L (tak termasuk I). Simpul akar adalah
simpul yang digambar pada bagian paling atas. Untuk
mengambarkan suksesor kiri serta suksesor kanan, dibuat

garis ke kiri bawah dan ke kanan bawah. Perhatikan pada
Gambar tersebut bahwa B adalah suksesor kiri dari A,
sedangkan C adalah suksesor kanan dari A. Subpohon kiri
dari A mengandung simpul-simpul B, D, E dan F, sedangkan
subpohon kanannya mengandung simpul-simpul C, G, H, J,
K dan L.
Kita dapat melihat bahwa jika N adalah sebarang
simpul dari pohon binar T, maka N mempunyai 0, 1 atau 2
buah suksesor. Suksesor kerap kali disebut anak atau anak
lelaki (child atau son). Jadi simpul N tersebut boleh kita sebut
ayah atau orang-tua (father atau parent) dari suksesornya.
Pada contoh kita, Simpul A, B, C dan H mempunyai 2
anak, simpul E dan J mempunyai satu anak. Sementara itu
simpul-simpul D, F, G, L dan K tidak mempunyai satu
anakpun. Simpul yang tidak mempunyai anak disebut “daun”
atau “terminal.”

Sekali lagi perhatikan bahwa definisi pohon binar di
atas adalah rekursif. T dide-finisikan berdasarkan subpohon
binar T1 dan T2. Ini berarti bahwa setiap simpul N dari pohon
mengandung subpohon kiri dan kanan. Jika simpul N adalah
daun maka kedua subpohon kiri dan kanannya adalah
hampa.
Dua pohon binar T dan U disebut “similar” jika mereka
mempunyai bangun (susunan) yang sama. Dua pohon binar
pada Gambar 7.3 berikut ini adalah similar, sementara itu,
pohon pada Gambar 7.4 menggambarkan dua pohon yang
tidak saja similar tetapi juga sama persis antara satu dengan
lainnya (baik susunan atau struktur pohon, maupun isi dari
setiap simpulnya) yang disebut dengan salinan (copy /
copies).

10.3 Terminologi Pada Pohon Binar
Terminologi hubungan keluarga banyak digunakan
dalam terminologi pada pohon binar. Misalnya istilah anak
kiri dan anak kanan, untuk menggantikan suksesor kiri dan
suksesor kanan, serta istilah ayah untuk pengganti
predesesor. Selain itu juga istilah saudara (brother) yang
diberikan kepada dua simpul yang mempunyai ayah yang
sama. Jelas bahwa setiap simpul kecuali akar mempunyai
ayah yang tunggal.
Simpul L disebut keturunan (atau descendant) dari
simpul N dan sebaliknya N disebut moyang (atau ancestor)
dari L, bila L diperoleh dari percabangan berturut- turut dari
N. Khususnya, L disebut keturunan kiri atau kanan dari N

tergantung apakah L terletak pada subpohon kiri atau kanan
dari N.
Pada Gambar 7.5 di atas, K misalnya adalah keturunan
kanan dari D, tetapi bukan keturunan dari F, E ataupun M.
Simpul G adalah ayah dari K dan L. Di sini K dan L adalah
bersaudara, masing -masing anak kiri dan kanan dari G.
Selain terminologi hubungan keluarga di atas, terminologi
dari teori graph juga banyak digunakan. Garis yang ditarik
dari simpul N ke suksesor disebut ruas dan sederetan ruas
yang berturutan disebut jalur atau path. Sebuah jalur yang
berakhir pada daun (simpul terminal) disebut cabang.
Sebagai contoh, pada Gambar 7.5 tersebut, garis AD,
ataupun GL adalah contoh ruas. Sedangkan barisan ruas
(AD, DG, GL) adalah jalur dari simpul A ke simpul L. Jalur ini
sekaligus merupakan cabang, karena berakhir di Simpul

terminal (daun) L. Jalur (AD, DG) bukan sebuah cabang.
Setiap simpul dari pohon mempunyai nomor tingkat (level).
Akar R dari pohon T mempunyai tingkat nol. Simpul lain,
mempunyai tingkat lebih besar dari tingkat ayahnya. Di sini
satu simpul yang mempunyai tingkat dikatakan berada pada
satu generasi.
Kembali sebagai contoh, Pohon Binar pada Gambar 7.5
di atas, simpul A mempunyai tingkat 0. Simpul-simpul D dan
E berada pada generasi dengan tingkat 1. Generasi
berikutnya terdiri atas simpul-simpul F, G dan M dengan
tingkat 2. Generasi terakhir, diisi oleh simpul K dan simpul L
dengan tingkat = 3.
Kedalaman atau ketinggian (depth atau height) dari
pohon binar T didefinisikan sebagai banyak maksimum
simpul, dari cabang di T. Dengan kata lain, panjang
maksimum jalur di T ditambah 1. Ketinggian juga sama
dengan tingkat tertinggi dari simpul ditambah 1. Pohon pada
Gambar 7.5 di atas mempunyai ketinggian 4. Perhatikan
bahwa cabang (AD, DG, GK) ataupun (AD, DG, GL)
mengandung simpul dengan jumlah maksimum, yakni = 4.

Cabang yang lain mengandung simpul yang lebih sedikit,
cabang (AE, EM) serta (AD, DF) misalnya hanya mengandung
3 simpul.
10.4 Pohon Binar Lengkap
Setiap simpul dari pohon binar paling banyak
mempunyai dua anak. Dapat kita lihat bahwa simpul akar
bertingkat = 0, hanya terdiri 1 simpul. Anaknya adalah
bertingkat =1, terdiri paling banyak 2 simpul. Demikian
seterusnya, simpul dengan tingkat = r paling banyak ada 2r.
Suatu pohon binar T dikatakan lengkap atau complete,
bila setiap tingkatnya, kecuali mungkin tingkat yang terakhir,
mempunyai semua simpul yang mungkin, yakni 21 simpul
untuk tingkat ke-r, dan bila semua simpul pada tingkat
terakhir muncul di bagian kiri pohon.
Jadi pohon binar lengkap dengan n simpul, Tn adalah
tunggal (dalam hal ini dengan mengabaikan label simpul).
Gambar 7.6 berikut menggambarkan berturut-turut T4, T6,
T11, dan T21.

Dapat dicatat bahwa beberapa buku mendefinisikan
pohon binar lengkap harus mengandung semua simpul
untuk semua tingkat pohon binar menurut pendefinisian kita
di atas disebut pohon binar hampir lengkap atau almost
complete.
Kita dapat memberi label pohon binar lengkap
menggunakan integer 1, 2, ..., n dari kiri ke kanan generasi
demi generasi seperti pada Gambar 7.6 (d) di atas. Pemberian
label seperti ini mempermudah kita untuk mengetahui ayah
serta anak dari suatu simpul dalam pohon binar lengkap.
Dalam hal ini anak kiri dan anak kanan dari simpul K adalah
berturut-turut 2*K dan 2*K+1. Sedangkan ayah dari K adalah
INT(K/2). Notasi INT(P) adalah integer terbesar yang lebih

kecil atau sama dengan P. Jadi INT(3.8) = 3, INT(15/2) = 7,
INT(4) = 4, dan sebagainya. Sebagai contoh, anak kiri dan
anak kanan dari simpul 7 adalah simpul 14 dan simpul 15,
sedangkan ayahnya adalah simpul INT(7/2) = 3.
Ketinggian dari pohon binar lengkap Tn diberikan oleh
rumus INT(2log n) +1. Sebagai contoh, ketinggian dari T4
adalah INT(21og 4) + 1 = 3, ketinggian dari T21 = INT(2 log21) =
5 dan sebagainya. Nilai ketinggian dari Tn relatif kecil
dibandingkan nilai n yang bersangkutan. Lihat misalnya
ketinggian dari Tn untuk n satu juta simpul, ketinggiannya =
21.
10.5 Pohon-2
Pohon binar T dikatakan pohon-2 atau pohon binar
yang dikembangkan (extended binary tree) bila setiap simpul
mempunyai 0 atau 2 anak. Dalam kasus ini, simpul dengan 2
anak disebut simpul internal, sedangkan simpul tanpa anak
disebut simpul eksternal. Dalam diagramnya, seringkali
diadakan pembedaan antara simpul internal dan eksternal.

Simpul internal digambar sebagai lingkaran, sedangkan
simpul eksternal sebagai bujur sangkar.
Istilah ''pohon binar yang dikembangkan'' datang dari
pengoperasian berikut. Per-hatikan pohon binar pada
Gambar 7.7 berikut. Ia dapat dikembangkan menjadi pohon-
2 dengan mengganti subpohon hampa dengan simpul baru.
Hal ini terlihat pada Gambar 7.8. Di sini simpul yang
lama adalah menjadi simpul internal, sementara itu simpul
baru menjadi simpul eksternal dari pohon-2.

Sebuah pemakaian penting dari pohon-2 adalah untuk
menyajikan suatu ekspresi aritmetik yang mengandung
operasi binar. Di sini simpul eksternal menyajikan operand
(variabel) sedangkan simpul internal menyajikan operator
yang bekerja terhadap ke dua subpohonnya. Sebagai contoh
adalah pohon-2 pada Gambar 7.9 berikut yang menyajikan
ekspresi (a-b) / ((c+d) *e)
10.6 Pohon Ketinggian Seimbang
Pohon binar yang mempunyai sifat bahwa ketinggian
subpohon kiri dan subpohon kanan dari pohon tersebut
berbeda paling banyak 1, disebut pohon ketinggian seimbang
atau height balanced tree (HBT). Gambar 7.10 menunjukkan
contoh-contoh HBT.

10.7 Ketinggian Minimum Dan Maksimum Pohon Binar
Untuk menentukan ketinggian minimum, jika diberikan
banyaknya simpul N, dapat digunakan rumus :
Hmin = INT(21og N) + 1
Sebagai contoh, untuk N = 80
Hmin = INT(21og 80) + 1
=7
Banyaknya simpul pohon binar merupakan ketinggian
maksimum Pohon binar tersebut.
10.8 Penyajian Pohon Binar Dalam Memori
Kita dapat menyajikan suatu pohon binar T dalam
memori dengan dua cara. Cara pertama adalah penyajian kait
(link). Cara ini biasa digunakan. Ia analog dengan cara list
berkaitan (linked list) ketika disajikan dalam memori. Cara

kedua adalah dengan menggunakan sebuah array tunggal
disebut penyajian sekuensial dari T.
Kebutuhan utama yang harus dipenuhi pada setiap
penyajian dari T adalah bahwa seseorang dapat mempunyai
akses langsung ke akar R dan T, dan bila diberikan sem-
barang simpul N, seseorang harus dapat akses langsung ke
anak dari N.
10.8.1 Penyajian Kait
Kalau tidak dinyatakan lain, suatu pohon binar T akan
disimpan dalam memori secara penyajian kait. Penyajian ini
menggunakan tiga array sejajar INFO, LEFT, dan RIGHT,
serta sebuah variabel penuding ROOT. Masing-masing simpul
N dari pohon T berkorespondensi dengan suatu lokasi K,
sedemikian sehingga :
1. INFO[K] berisi data pada simpul N
2. LEFT[K] berisi lokasi dari anak kiri simpul N
3. RIGHT[K] berisi lokasi dari anak kanan simpul N.
ROOT akan berisi lokasi dari akar R dari pohon T. Jika
suatu subpohon hampa, maka penuding yang bersangkutan

akan berisi harga nol. Jika suatu pohon T sendiri hampa,
maka ROOT akan berisi harga nol.
Dapat dicatat bahwa simpul dari pohon bisa saja berisi
lebih dari satu informasi. Pada prakteknya simpul biasanya
berisi sebuah record . Jadi INFO sebenarnya berupa linear
array dari record ataupun berupa sebuah koleksi array
sejajar. Selain itu, karena suatu simpul boleh diselipkan
sebagai simpul baru pohon, atau simpul lama boleh dihapus
dari pohon, kita juga secara implisit mengasumsikan bahwa
lokasi hampa dalam array INFO, LEFT dan RIGHT
membentuk sebuah list berkaitan dengan penuding AVAIL.
Kita biasanya memisalkan array LEFT berisi penuding untuk
list AVAIL.
Untuk menuding ke alamat yang invalid (subpohon
hampa), dipilih penuding nol yang dinyatakan sebagai NULL.
Kenyataannya dalam praktek, kita gunakan 0 atau bilangan
negatif sebagai isi dari NULL.
Sebagai contoh, Gambar 7.12 menggambarkan skema
dari penyajian kait pohon binar Gambar 7.11. Terlihat bahwa
setiap simpul digambar terdiri atas tiga field. Terlihat juga di

sini, subpohon hampa digambar berlabel x untuk mengisi
penuding nol. Selanjutnya
Gambar 7.13 menunjukan bagaimana penyajian kait
pohon binar yang bersangkutan. Sebagai contoh, misalkan
diketahui berkas personalia suatu pe-rusahaan kecil yang
berisi data 9 pegawainya dengan fields : NAME, SOCIAL-
SECURITY-NUMBER (SSN), SEX, serta SALARY. Berkas
tersebut disimpan dalam memori sebagai pohon binar, seperti
terlihat pada Gambar 7.15.

Untuk memudahkan, kita menulis label dari simpul
hanya berupa field kunci, NAME. Kita membentuk pohon
pada Gambar 7.15 tersebut sebagai berikut :
1. Harga dari ROOT = 14 menunjukkan bahwa record
nomor 14 dengan NAME = “Harris” adalah akar dari
Pohon.
2. LEFT[14] = 9 menunjukan bahwa Cohen (record nomor
9) adalah anak kiri dari Harris, dan RIGHT[14] = 7
menunjukkan bahwa Lewis adalah anak kanan dari
Harris.
Dengan mengulangi langkah (2) kita peroleh diagram
pohon binar seperti Gambar 7.15. Ingat bila LEFT[N] atau
RIGHT[N] bernilai 0 menandakan bahwa simpul N tidak
mempunyai anak kiri /kanan.
10.8.2 Penyajian Sekuensial
Pandang pohon binar T yang lengkap atau hampir
lengkap. Terdapat sebuah cara yang efisien untuk
menyajikan T dalam memori. Penyajian ini disebut penyajian
sekuensial. Penyajian ini hanya menggunakan sebuah linear
array TREE sebagai berikut :

1. Akar R dari pohon T tersimpan sebagai TREE[i]
2. Jika simpul N menduduki TREE[K] maka anak kirinya
tersimpan dalam TREE[2*K] dan anak kanannya
dalam TREE[2*K+l]
Nilai penuding NULL, seperti penyajian kait, juga
diperuntukkan menunjukkan subpohon hampa. Khusus bila
TREE[i] = NULL, maka berarti Pohon T adalah pohon hampa.
Berdasarkan kenyataan tersebut di atas, secara umum
penyajian sekuensial ini menjadi tidak efisien. Penyajian
sekuensial dari pohon binar pada Gambar 7.16(a) terlihat
pada Gambar 7.16(b).
Dapat kita lihat bahwa penyajian membutuhkan 14
lokasi dalam array TREE, meskipun T hanya mempunyai 9
simpul. Kenyataannya, bila kita memasukkan elemen nol
sebagai suksesor dari simpul terminal, kita akan
membutuhkan TREE[29] untuk suksesor kanan dari
TREE[14].
Berbicara secara umum, penyajian sekuensial dari
pohon binar dengan ke-tinggian d akan membutuhkan array
dengan banyak elemen mendekati 2n+1. Hal ini tidak efisien,

kecuali tentunya untuk pohon binar T yang lengkap atau
hampir lengkap. Sebagai contoh, pohon binar T pada Gambar
7.11 dengan 11 simpul dan ketinggian = 5 membutuhkan
array dengan banyak elemen mendekati 25+1 = 64 elemen.

10.9 Penyajian Pohon Umum Secara Pohon Binar
Kalau kita mempunyai sebuah struktur pohon yang
umum (general tree), maka ada sebuah algoritma yang dapat
menyajikannya secara pohon binar. Kita ingat kembali bahwa
pohon binar selalu terdiri atas paling banyak dua subpohon,
yakni subpohon kiri dan subpohon kanan. Pendefinisian ini
berlaku secara rekursif. Gambar 7.17 merupakan contoh dari
pohon binar.
Pada pohon binar dapat kita lihat bahwa setiap simpul
selalu mempunyai 0, 1 atau 2 anak, tak lebih dari itu.
Gambar 7.18 menunjukkan sebuah contoh pohon umum,
yang bukan pohon binar.

Pohon pada Gambar 7.18 tersebut bukan pohon binar,
karena simpul D mempunyai 3 anak, yakni simpul-simpul H,
I, dan J. Algoritma yang akan kita gunakan untuk
menyajikan pohon umum secara pohon binar terdiri atas 2
langkah. Pertama, kita tambahkan ruas (edge) baru,
menghubungkan 2 Simpul bersaudara yang berdampingan,
lalu kita hapus ruas dari simpul ayah (parent) ke simpul anak
bersaudara tersebut, kecuali ruas ke simpul anak paling kiri.
Langkah kedua, kita melakukan rotasi sebesar 45o, searah
jalannya putaran jarum jam terhadap pohon hasil langkah
pertama tadi.

Sebagai contoh, Gambar 7.19a dan 7.19b menunjukkan
penggunaan algoritma di atas terhadap pohon umum pada
Gambar 7.18. Gambar 7.19a adalah pelaksanaan langkah
pertama dan Gambar 7.19b adalah pelaksanaan langkah
kedua, sehingga diperoleh pohon binar yang diinginkan.
Gambar 7-19a terjadi setelah pada Gambar 7.18 ruas
mendatar (B,C), (C,D), (F,G), (H,I), (I,J) kita tambahkan.
Mereka menghubungkan dua simpul bersaudara yang
berdampingan. Kemudian dilakukan penghapusan ruas (A,C),
(A,D), (C,G), (D,I), (D,J) dan (G,L).

Gambar 7- 19b terjadi setelah perotasian pohon pada
Gambar 7.19a. Dari hasil ini dapat kita lihat dan simpulkan
bahwa ruas kiri pada pohon binar hasil merupakan penuding
ke simpul anak pada 1 pohon umum semula. Sementara itu
ruas kanan merupakan pertanda bahwa kedua simpul adalah
saudara yang berdampingan pada pohon semula.
Dari kesimpulan kita tersebut, kita selalu dapat
mengembalikan pohon binar secara penyajian pohon umum
ke penyajian semula. Hal ini dapat kita lakukan dengan
mudah seperti pohon binar pada Gambar 7.20 yang kita
kembalikan ke pohon semula pada Gambar 7.21.

10.10 Notasi Prefix, Infix Dan Postfix Serta Traversal
Akan kita lihat bagaimana struktur pohon dipakai
untuk menempatkan data, guna memudahkan pekerjaan cari
(search). Pohon juga berguna untuk menyajikan koleksi data
yang mempunyai struktur logik bercabang.

Sebagai contoh, perhatikan pohon binar pada Gambar
7.22 dan 7.23 yang menya-jikan ekspresi aritmetika (c+d)*e
dan ((a+b)*(c/d)+(e^f))/g. Pada penyajian ini, masing-masing
simpul yang bukan daun, mewakili operator, sedangkan
subpohon kiri, dan kanannya merupakan operand.
Contoh pohon pada Gambar 7.24 menyajikan koleksi
elemen data yang disusun sedemikian rupa, yakni bila K
adalah label/ nama suatu simpul, maka label dari semua
simpul subpohon kirinya lebih kecil atau sama dengan K
(secara alfabetik), dan label semua simpul subpohon
kanannya lebih besar dari K.
Proses kunjungan dalam pohon, dengan setiap simpul
hanya dikunjungi tepat satu kali disebut traversal. Ketika

dilakukan traversal pohon, koleksi simpul dari pohon terlihat
satu persatu. Hasil dari traversal pohon adalah suatu untai
simpul pohon yang urut secara linear. Suatu simpul
dikatakan dikunjungi, bila simpul tersebut kita masuk-kan
ke dalam urutan linear tersebut.
Tiga kegiatan yang terdapat dalam traversal pohon binar
adalah :
1. mengunjungi simpul akar (root)
2. melakukan traversal subpohon kiri dan
3. melakukan traversal subpohon kanan.
Kita mengenal tiga macam traversal pohon, yang
berbeda satu dengan yang lain dari cara pengurutan ketiga
kegiatan di atas. Ketiga traversal tersebut adalah traversal

pre-order, in-order dan post-order. Pada traversal pre-order
dilakukan berturut-turut :
1. Kunjungi simpul akar
2. Lakukan traversal subpohon kiri secara pre-order
3. Lakukan traversal subpohon kanan secara pre-order
Perhatikan bahwa proses berlangsung secara rekursif.
Kalau kita lakukan traversal pre-order terhadap pohon pada
Gambar 7.22, 7.23 dan 7.24 maka berturut-turut diperoleh
deretan urutan linear
Gambar 7.22 : c * d + e
Gambar 7.23 : a / b + c * d + e / f ^ g
Gambar 7.24 : M E B A D L P N V T Z
Untuk jelasnya perhatikan Gambar 7.25, 7.26 dan 7.27
dengan arah dari traversal (dinyatakan dengan garis putus-
putus).:
Traversal in-order berbeda urutannya, yakni :
1. Lakukan traversal subpohon kiri secara in-order
2. Kunjungi simpul akar
3. Lakukan traversal subpohon kanan secara in-order

Kalau kita lakukan traversal in-order terhadap pohon
pada Gambar 7.22, 7.23 dan 7.24 maka diperoleh deretan
urutan linear, berturut-turut :
Gambar 7.22 : (c + d) * e
Gambar 7.23 : ((a + b) * (c / d) + (e ^ f)) / g
Gambar 7.24 : A B D E L M N P T V Z
Gambar 7-28(a) menggambarkan traversal secara in-
order pada pohon di Gambar 7.22. Sisanya dapat anda coba
sendiri.

Tanda Kurung pada Notasi Infix
Lihat kembali gambar 7.28(a) di atas, kunjungan secara
in -order pada pohon tersebut seharusnya menghasilkan : c +
d * e. Akan tetapi, hal itu akan berbeda hasilnya jika operand-
operand aritmetika tersebut kita beri nilai. Contoh, c kita beri
nilai 2, b = 3 dan e = 4. Maka hasil perhitungan 2 + 3 * 4
adalah 14. Padahal seharusnya (2 + 3) * 4 = 20.
Mari kita lakukan langkah-langkah pembuatan pohon
binar (1) c + d * e dan (2) (c + d) * e. Apakah kedua notasi
tersebut akan memiliki struktur pohon yang sama ? Kita
mulai dengan pohon binar (1).

c + d * e; maka operasi yang akan dilakukan pertama kali
adalah d * e (sesuai kaidah derajat operasi
matematika). Bila d * e kita anggap sebagai f,
maka notasi semula bisa disederhanakan menjadi
c + f.
c + f; struktur pohonnya adalah :
Kita ketahui bahwa f adalah d * e yang struktur
pohonnya adalah :
Kita ganti f di atas menjadi d * e, sehingga hasil
akhirnya menjadi :

Sekarang, kita kerjakan pohon kedua (c + d) * e.
Operasi yang pertama kali dilakukan adalah (c + d). Jika (c +
d) kita misalkan f, maka ekspresinya akan menjadi f * e.
f * e akan digambarkan sebagai :
Kita tahu bahwa f adalah (c + d) yang struktur pohonnya
adalah :
Maka, ketika kita masukkan ke posisi sebenarnya, struktur
pohon akhirnya adalah :
Bisa Anda lihat, bahwa kedua pohon di atas berbeda
strukturnya. Hal yang rumit adalah menuliskan notasi infix

ketimbang prefix dan postfix karena pada notasi infix harus
memperhatikan tanda kurung, sedang yang lain tidak
memerlukannya. Tanda kurung itu digunakan untuk
“mengurungi” setiap substree yang ada.
Perhatikan kembali Gambar 7.23 di atas. Notasi yang
dihasilkan adalah :
Substree paling kiri : (a + b)
Substree di sebelahnya : (c / d)
Digabung menjadi (a + b) * (c / d)
Substree berikutnya : ( e ^ f)
Digabung lagi menjadi ( (a + b) * (c / d) ) * (e ^ f)
Digabung keseluruhannya menjadi : ( ( (a + b) * (c / d) ) *
(e ^ f) ) / g
Operasi itu akan menghasilkan nilai yang berbeda jika
tidak digunakan tanda kurung :
a + b * c / d * e ^ f / g.
Traversal yang ketiga, yakni traversal post-order
memakai urutan :
- Lakukan traversal subpohon kiri secara post-order
- Lakukan traversal subpohon kanan secara post-order

- unjungi simpul akar.
Traversal post-order terhadap Pohon pada Gambar 7-22,
7-23 dan 7-24 menghasilkan:
Gambar 7.22 :c+d*e
Gambar 7.23 :a+b/c*dê+f/g
Gambar 7.24 :ADBLENTZVPM
Terlihat bahwa hasil yang diperoleh dari traversal pohon
yang menyajikan ekspresi aritmetika, merupakan ekspresi
aritmetika secara notasi prefix, infix serta postfix. Hanya di
sini urutan operasi berdasarkan hirarki operator dan tanda
kurung yang diberikan tidak terjaga pada traversal in -order.
Keunggulan post-order, selain tidak memerlukan tanda
kurung, juga dapat lebih mudah dikomputasi.
Operator selalu didahului oleh dua operand. Namun
traversal in-order menunjuk-kan keunggulannya pada
traversal pohon pada Gambar 7.24. Hasil traversal adalah
urut secara alfabetik. Pre-order banyak digunakan dalam
sistem manajemen database seperti Information Management
System (IMS) dari IBM. Traversal pre-order ekivalen dengan
hirarchi sequence order dari IMS.

Jadi ketiga metode traversal tersebut sama-sama
penting, sehingga perlu kita ketahui dengan baik. Juga dapat
dicatat bahwa pemberian penuding (pointer) arah tra-versal,
baik secara pre-in atau post-order sangat membantu. Pohon
yang telah dilengkapi dengan penuding tersebut, seperti pada
Gambar 7.25 sampai 7.28(b) berupa garis putus-putus,
disebut pohon binar berbenang atau threaded.
Berikut ini adalah rangkuman langkah-langkah
membuat pohon binar dari arit-metika infix :
1. Susun serta beri tanda kurung ekspresi yang
dimaksud
2. Tentukan hirarki atau tingkatan dari operator
aritmetika yang berlaku
3. Mulailah dari tingkat tertinggi, pembentukan pohon
dari bawah ke atas.
Berikut ini beberapa contoh pohon binar untuk
menyajikan ekspresi secara infix, prefix, dan postfix yang
bersangkutan.

Contoh 7.1
Ekspresi infix : ( K + L + M – N – E – F ) * G / H
mempunyai pohon binar seperti pada Gambar 7-29.
Notasi infix : ( ( ( ( ( ( (K+L) +M) – N) – E) – F) *G) /H),
hasil operasinya akan sama dengan notasi (K+ L + M – N – E –
F) *G / H.
Prefix untuk Gambar 7.29 adalah : K / L * M – N – E – F
+G+H
Postfix untuk Gambar 7.29 adalah : K + L + M – N – E –
F*G/H

Tampak bahwa root tree akan menjadi elemen pertama
dalam prefix tetapi menjadi elemen terakhir dalam postfix.
Contoh 7.2
Ekspresi infix ((A + B) * C + D) / (E + F * H), mempunyai
pohon binar seperti terlihat pada Gambar 7.30.
10.11 Pohon Cari Binar
Kali ini kita membahas sebuah struktur data bentuk
khusus dari pohon binar yang teramat penting dalam ilmu
komputer, yakni pohon cari binar (binary search tree). Ia
penting untuk mengorganisasi koleksi besar data yang
memerlukan kemampuan akses baik secara langsung
maupun sekuensial.
Dalam struktur ini, seseorang dapat melakukan
pencarian (searching) elemen dalam waktu pelaksanaan O(log
n) . Ia juga memungkinkan kita dengan mudah melakukan
penyisipan (inserting) serta penghapusan (deleting) elemen.
Pohon cari binar ini dibandingkan dengan struktur lain
seperti linear array terurut ataupun list berkaitan (linked list),
mempunyai beberapa keuntungan.

Prefixnya adalah : / + * + A B C D + E * F H
Postfixnya adalah : A B + C * D + E F H * + /
Pada linear array terurut, memang kita dapat
melakukan cari dalam waktu pelaksanaan O(log n), namun
proses penyisipan dan penghapusan elemen sukar serta
mahal untuk dilakukan. Sementara itu pada list berkaitan;
sungguhpun proses penyisipan dan penghapusan elemen
lebih mudah dilaksanakan, namun proses cari secara linear
membutuhkan waktu pelaksanaan yang kurang baik, yakni
O(n).
Sungguhpun setiap simpul dari pohon cari binar boleh
berisi record data, pende-finisian pohon cari binar tergantung

pada field yang diberikan tertentu (field kunci) yang nilainya
berbeda dan dapat diurutkan. Nilai tersebut dinamakan
nama record atau nilai simpul.
Pandang T suatu pohon binar. Maka T disebut pohon
cari binar (atau disebut juga pohon terurut binar) bila
masing- masing simpul N dari T mempunyai sifat seperti
berikut : “Nilai dari N selalu lebih besar dari setiap nilai
simpul pada subpohon kiri dari N dan selalu lebih kecil dari
setiap nilai simpul pada subpohon kanan dari N.”
Definisi di atas menjamin bahwa traversal in-order
terhadap pohon cari binar selalu menghasilkan untai yang
terurut. Gambar 7.31 menggambarkan sebuah pohon cari
binar T. Terlihat bahwa nilai simpul N pada pohon selalu
lebih besar dari nilai setiap simpul di subpohon kanannya.
Misalkan simpul bernilai 23 kita ganti nilainya dengan 35,
maka T ternyata tetap merupakan pohon cari binar. Lain
halnya bila 23 tersebut kita ganti dengan 40, T bukan lagi
pohon cari binar.

Contoh berikut adalah pohon cari binar pada Gambar
7.33 untuk berkas (file) pada Gambar 7.32 dengan field kunci
NAMA. Kalau field kunci diambil NOMOR-PEGAWAI, maka
pohon binar tersebut bukan merupakan pohon cari binar.
Dapat dicatat bahwa dalam definisi pohon cari binar di
atas, semua nilai/label simpul adalah berbeda. Kalau
diijinkan terjadi adanya label yang sama; kita dapat
melakukan sedikit modifikasi. Definisi pohon cari binar
menjadi “bila N adalah simpul dari pohon maka nilai semua
simpul pada subpohon kiri dari N adalah lebih kecil atau sama
dengan nilai simpul N dan nilai semua simpul pada subpohon
kanan dari N adalah lebih besar dari nilai simpul N”.

Juga patut diingat, bahwa terdapat lebih dari satu
pohon cari binar yang dapat dibentuk untuk menyajikan
nama record. Perhatikan Gambar 7.34 yang menggambarkan
beberapa pohon cari binar untuk nama field Adhini,
Budiman, Cherry dan Doddy.

10.12 Cari Dan Penyisipan Simpul Pohon Cari Binar
Akan kita berikan sebuah algoritma sederhana untuk
operasi cari dan penyisipan elemen pada pohon cari binar.
Operasi penghapusan akan kita bicarakan pada sub-bab 7.13
nanti.
Pandang bahwa diberikan sebuah ITEM informasi.
Algoritma di bawah ini akan menemukan lokasi dari ITEM
dalam pohon cari binary T atau menyelipkan ITEM sebagai
simpul baru dari T dalam posisi yang tepat.

Algoritma
Algoritma bekerja sebagai berikut :
1. Bandingkan ITEM dengan simpul akar N dari pohon, jika
ITEM < N proses subpohon kiri dari N, jika ITEM > N
proses subpohon kanan dari N.
2. Ulangi langkah (a) sampai hal berikut ditemui :
a. Ditemukan simpul N sedemikian sehingga ITEM = N,
dalam hal ini pencarian berhasil;
b. Dijumpai subpohon hampa, ini menunjukkan bahwa
pencarian tidak berhasil, dan kita selipkan ITEM
mengisi subpohon yang hampa tadi.

Jadi dengan kata lain, kita memproses mulai dari
simpul akar R turun sepanjang pohon T, sampai ditemukan
atau dilakukan penyisipan ITEM sebagai daun dari T.
Sebagai contoh, pandang pohon cari binar pada
Gambar 7.31. Misalkan diberikan ITEM = 20. Dengan
algoritma di atas, kita kerjakan langkah-langkah sebagai
berikut :
1. Bandingkan ITEM = 20 dengan akar = 38. ITEM <
akar, kita proses subpohon kiri dari 38 dengan akar =
14.
2. Bandingkan ITEM = 20 dengan 14. Karena ITEM >
akar, proses subpohon kanan dari 14. Akar dari
subpohon tersebut = 23.
3. Bandingkan ITEM = 20 dengan 23. Karena ITEM <
akar, proses subpohon kiri dari 23. Akar dari
subpohon tersebut = 18.
4. Bandingkan ITEM = 20 dengan 18. Karena ITEM >
akar, proses subpohon kanan dari 18. Subpohon
tersebut adalah hampa, jadi algoritma selesai,
diperoleh penyisipan 20 sebagai anak kanan dari 18.

Gambar 7.35 menunjukkan pohon cari binar setelah 20
diselipkan. Pada gambar itu juga ditunjukkan jalur dari
simpul akar turun sampai ke elemen 20 yang diselipkan,
selama berlangsungnya algoritma.
Untuk lebih jelas, sekali lagi kita pakai algoritma di atas
terhadap pohon cari binar pada Gambar 7.33. Sebagai ITEM
diberikan Dyah. Kita peroleh langkah sebagai berikut :
1. Bandingkan ITEM Dyah dengan akar pohon yakni Harry.
Karena ITEM < akar, proses subpohon kiri dari Harry.
Akar subpohon itu adalah Cahyo.
2. Bandingkan ITEM Dyah dengan Cahyo. Karena ITEM >
akar, proses subpohon kanan dari Cahyo. Akar subpohon
tersebut adalah Gunawan.
3. Bandingkan Dyah dengan Gunawan. Karena Dyah <
Gunawan, proses subpohon kiri dari Gunawan yang
akarnya adalah Dyah
4. Karena ITEM Dyah sama dengan akar maka algoritma
selesai. Di sini diperoleh bahwa Dyah ada di dalam pohon
cari binar tersebut.

10.13 Penghapusan Simpul Pohon Cari Binar
Setelah pada bagian yang lalu kita bicarakan operasi
cari dan penyisipan, kali ini kita bicarakan operasi
penghapusan (deletion) simpul pohon cari binar. Operasi
penghapusan suatu simpul dari pohon cari binar bukan
merupakan hal yang mudah. Pertama-tama kita harus
tetapkan lebih dahulu simpul yang akan kita hapus, bila
merupakan simpul daun, maka proses akan berlangsung
dengan mudah, karena simpul daun tersebut akan dapat
langsung kita hapuskan dari pohon cari binar yang
bersangkutan.
Jika Simpul yang akan dihapuskan mempunyai hanya
sebuah subpohon kanan, maka untuk menggantikan posisi
simpul yang dihapuskan tersebut kita ambil simpul akar
subpohon kiri dan subpohon kanan tersebut. Jika Simpul
yang akan dihapuskan mempunyai dua buah subpohon kiri
dan subpohon kanan, maka untuk menggantikan posisi dari
simpul yang dihapus tersebut, kita tentukan simpul dari
salah satu subpohon kiri atau subpohon kanan sedemikian
sehingga bangun pohon yang terbentuk kembali, memenuhi

sifat sebagai pohon cari binar. Perhatikan bangun pohon cari
binar pada Gambar 7.36.
Jika simpul yang akan dihapuskan hanya mempunyai
satu subpohon, misalnya “Secretary”, maka untuk
menggantikan “Secretary” tersebut, dapat kita tempatkan
”Programmer” secara langsung. Tetapi bila simpul yang akan
dihapuskan mempunyai dua subpohon, contohnya “Sweeper,”
kita pilih simpul dengan nama tertentu dari subpohon kiri
dan subpohon kanan, sehingga pohon cari yang terbentuk
kembali memenuhi sifat sebagai “pohon cari binar.” Misalkan
kita pilih simpul dengan nama “Teacher” dan sekarang
“Teacher” akan menempati posisi “Sweeper”. Bangun pohon
cari yang dibentuk kembali karena penghapusan “Sweeper”
terlihat pada Gambar 7.37. Terlihat bahwa pohon cari binar

yang terbentuk kembali tersebut memenuhi sifat pohon cari
binar lagi.
Prosedur untuk penghapusan suatu simpul dari pohon
cari, dapat kita tulis sebagai berikut :
1. Jika pohon hampa, maka penghapusan yang dilakukan
gagal. Berhenti. Jika tidak, lakukan (2).
2. Jika n < Ri (akar), subpohon kiri dari Ri diselidiki sampai
ditemukan simpul yang telah ditentukan untuk dihapus.
3. Jika n > Ri, maka subpohon kanan dari Ri diselidiki
sampai ditemukan simpul yang telah ditentukan untuk
dihapus.
4. Jika n = Ri dan subpohon kiri dan subpohon kanan
hampa, maka hapus Ri.

5. Jika n = Ri dan subpohon kirinya hampa, maka hapus Ri,
kemudian ambil akar dari subpohon kanan untuk
menggantikan posisi Ri. Pohon baru akan memenuhi sifat
sebagai pohon cari lagi.
6. Jika n = Ri dan subpohon kanannya hampa, maka hapus
Ri. Ambil akar dari subpohon kiri untuk menggantikan
posisi Ri. Pohon baru akan memenuhi sifat sebagai pohon
cari lagi.
7. Jika n = Ri dan subpohon kanan tidak hampa, maka
untuk menggantikan posisi Ri yang dihapus, kita
tentukan suatu simpul, mungkin dari subpohon kiri atau
mungkin dari subpohon kanan, sedemikian sehingga
pohon yang terbentuk kembali memenuhi sifat sebagai
pohon cari lagi.
Contoh 7.3
Perhatikan pohon cari binar pada Gambar 7.36 yang
lalu. Misalkan simpul dengan nama “Sweeper” akan kita
hapus dari pohon. Cara untuk menghapuskan “Sweeper”
tersebut, sebagai berikut :

Langkah (1) : Kita periksa apakah pohon cari tersebut
kosong atau tidak.
Langkah (2) : “Sweeper” > “Manager,” berarti subpohon
kanan dari akar Ri = “Manager” diselidiki.
Subpohon kanannya terlihat pada Gambar
7.38.
Langkah (3) : Akar Ri = “Sweeper” = n dan subpohon kiri
serta subpohon kanan tidak kosong (lihat
Gambar 7.39). Untuk menggantikan posisi
“Sweeper”, kita ambil simpul dengan nama
“Teacher” dari subpohon kanan. Jika
“Teacher” kita tempatkan di posisi “Sweeper”,
akan kita dapatkan kembali bangun pohon

cari yang memenuhi sifat sebagai suatu
pohon cari binar. Bangun pohon cari yang
baru terlihat pada Gambar 7.39.
10.14 Pohon Cari Optimal
Telah kita ketahui dari bagian-bagian yang lalu bahwa
suatu himpunan data ataupun himpunan record dapat
disajikan dalam berbagai pohon cari binar. Besarnya upaya
yang diperlukan untuk mencari suatu elemen tertentu pada
sebuah pohon cari tergantung dari letak elemen tersebut.
Proses pencarian untuk menemukan sebuah elemen pada
pohon cari dimulai dari akar. Besarnya upaya yang
diperlukan dalam pencarian tersebut diukur oleh banyaknya
perbandingan yang dilakukan. Yang dimaksudkan dengan
banyak per-bandingan yang dilakukan adalah banyaknya

simpul pada jalur cari, yaitu jalur yang berawal dari akar dan
berakhir di simpul record yang kita cari tersebut. Sebagai
contoh, perhatikan himpunan record 1, 2 dan 3, ketiga nama
record tersebut dapat dibentuk menjadi 5 pohon cari yang
berbeda, seperti terlihat pada Gambar 7.40.
Untuk menemukan record 2 pada pohon cari binar di
atas, banyaknya perbandingan yang dilakukan adalah
berbeda-beda, seperti terlihat pada Tabel 7.1.
Untuk menemukan record 2 pada pohon cari binar di
atas, banyaknya perbandingan yang dilakukan adalah
berbeda-beda, seperti terlihat pada Tabel 7.1.

Jadi untuk record 2 pada pohon c, banyaknya
perbandingan lebih kecil dari pohon a, pohon b, pohon d dan
pohon e. Masalah yang kita hadapi adalah, bagaimana
menen-tukan bahwa suatu bangun pohon cari lebih baik dari
pohon cari lainnya, untuk himpunan record yang sama dan
juga bagaimana bangun suatu pohon cari yang baik
Bangun pohon cari binar tidak dapat dievaluasi dengan
baik jika hanya berdasarkan jalur cari yang didapat dari
pencarian satu record saja. Kita harus mengikut-sertakan
semua record pada evaluasi tersebut. Sehingga bila rata-rata
panjang dan jalur cari bangun tersebut dibandingkan,
barulah dapat ditentukan bangun mana yang lebih baik.
Misalkan P adalah peluang atau probabilitas akses
(pengambilan), yakni peluang bahwa nama N akan dicari, Ni
adalah salah satu nama record pada pohon cari. Jika peluang
pengambilan suatu record tertentu Ni di atas diketahui, maka:

Pada pencarian yang dianggap selalu sukses, panjang
cari yang diharapkan untuk setiap pohon cari didefinisikan,
sebagai :
h, adalah banyaknya perbandingan untuk mencapai N i.
Sebagai contoh, pandang ketiga nama 1, 2, 3 dengan 5
buah pohon cari pada Gambar 7.40. Jika peluang
pengambilan nama record pada suatu pohon cari adalah
diketahui sebagai berikut :
Untuk nama 1 = P1 = 1/7
maka panjang cari yang diharapkan untuk masing-
masing pohon cari dapat dilihat pada Tabel (2).

Dari Tabel (2) tersebut terlihat bahwa panjang cari
bernilai minimum dari masing-masing pohon cari adalah
pohon cari (a). Jadi bangun cari pohon cari (a) adalah pohon
cari yang terbaik dari 5 bangun pohon cari yang ada. Agar
panjang cari yang diharapkan minimum, maka pohon cari
yang bersangkutan dibuat dengan cara menaruh nama yang
sering diakses, sedekat mungkin dengan akar. Untuk
melaksanakan hal tersebut, kita harus meletakkan nama-
nama tersebut berurutan sesuai aturan pohon cari binar.
Namun, cara di atas tidak selalu menjamin bahwa
pohon cari yang kita dapatkan adalah yang terbaik. Karena
panjang jalur dari suatu pohon cari akan berubah, bila kita
lakukan penyisipan atau penghapusan sebuah nama pada
pohon yang bersangkutan. Bila kita perhatikan, bahwa untuk
pencarian suatu record dengan nama X dalam pohon cari,
dapat terjadi kegagalan, yang disebabkan record yang kita
cari atau inginkan itu tidak terdapat pada pohon cari
tersebut. Untuk keadaan tersebut, dapat kita letakkan suatu
simpul bayangan pada pohon cari. Simpul bayangan
disisipkan pada pohon cari, dengan maksud agar pencarian

yang gagal berakhir pada simpul tersebut. Letak dari record
dengan nama X adalah di antara Ni < X < Ni+1, i =1, 2, …, n.
Bila kita gambarkan dalam suatu bangun pohon cari
binar, letak simpul bayangan tersebut terdapat di setiap
bagian subpohon yang hampa. Andaikan peluang kegagalan
dalam menemukan sebuah record tertentu pada pohon cari
adalah q, maka peluang kegagalan secara keseluruhan
adalah :
Perhatikan bangun pohon cari binar pada Gambar 7.41.
Di sini himpunan (Ni) adalah himpunan record dengan nama
1, 2, 3, 4 dan 5.

Terlihat bahwa pada setiap bagian subpohon yang
hampa, terdapat simpul bayangan. Simpul bayangan tersebut
dikatakan sebagai external simpul (digambarkan sebagai
bujursangkar) dan simpul lainnya dikatakan sebagai internal
simpul. Jika pada suatu pohon cari terdapat N buah internal
simpul, maka banyaknya external simpul adalah N+1 buah.
Setiap external simpul menampilkan pencarian yang berakhir
dengan kegagalan. Jika pencarian sukses berakhir pada
sebuah simpul dan hi adalah banyaknya perbandingan yang
dilakukan untuk mencapai nama Ni, maka panjang cari yang
diharapkan adalah :
Jika kita perhatikan kembali pada pencarian yang
gagal, maka letak dari nama X akan terdapat pada salah satu
dari (N+1) buah external simpul. Selanjutnya (N+1) buah
external simpul tersebut dinotasikan sebagai Ei, dengan i =
0,1,..., n.

E0 adalah external simpul yang mengandung nama X
untuk E0, E0 < N1 maka X terletak pada X < Ni,
E1 adalah external simpul yang mengandung nama X
untuk Ei, Ni < Ei < Ni+1, maka X terletak pada Ni < X < Ni+1,
dengan i = 1, 2, ..., n-1.
En adalah external simpul yang mengandung nama X,
untuk Xn, Nn < En, maka X terletak pada X > Nn.
Jika pencarian yang gagal berakhir pada sebuah simpul
dan hi adalah banyaknya perbandingan yang dilakukan
untuk mencapai nama Ei, maka panjang cari yang
diharapkan adalah :
h, adalah banyaknya perbandingan untuk mencapai E.
Dari uraian di atas, kita dapatkan bahwa panjang cari yang
diharapkan (COST) untuk masing-masing pohon cari adalah,

Berarti untuk setiap pohon cari binar, yang memiliki
COST terendah (minimum) di antara bangun pohon cari
lainnya (dengan himpunan record yang sama) adalah pohon
cari binar yang optimal. Sebagai contoh, himpunan record
dengan nama 1, 2 dan 3 yang lalu dapat kita buat menjadi
beberapa bangun pohon cari dengan simpul eksternal, seperti
terlihat pada Gambar 7.42 di bawah ini, dengan :
Panjang cari yang diharapkan, (COST), dari masing-
masing pohon cari adalah (sambil melihat Gambar 7.42).
Terlihat bahwa COST yang minimum dari pohon cari
tersebut dimiliki oleh pohon cari (c). Jadi bangun pohon cari
(c) adalah bangun pohon cari yang terbaik (optimal) dari 5
bangun pohon cari yang ada. Cara yang kita gunakan di atas
cukup mudah dan sederhana. Di sini kita menggunakan

pendekatan try of posibilites, maksudnya kita harus
menghitung semua kemungkinan yang ada pada setiap
pohon cari. Cara ini sukar sekali kita terapkan untuk
mencari pohon Cari optimal pada pohon berorder besar. Pada
bagian berikut ini, kita ketengahkan cara yang lebih umum,
meskipun dengan pendekatan matematika yang rumit.
10.15 Tambahan : Lebih Lanjut Tentang Pohon Cari

Optimal
Telah kita lihat pada bagian terdahulu, bahwa pohon
cari yang optimal mempunyai sifat bahwa semua subpohon
yang ada harus optimal pula. Berdasarkan sifat tersebut,
terdapat suatu cara untuk menyelesaikan masalah optimasi

dari pohon binar, khususnya bila kita harus mengevaluasi
suatu pohon cari yang besar. Karena setiap subpohon harus
optimal, evaluasi pada pohon cari dimulai dari masing-
masing simpul daun. Berikutnya, evaluasi dilakukan pada
subpohon yang lebih besar lagi, hingga mencapai bangun
pohon cari keseluruhan.
Perhatikan suatu bangun pohon cari binar T yang
optimal pada Gambar 7.43 dengan akar a k.
Pendekatan yang kita lakukan adalah bahwa setiap ai
dapat diangkat sebagai akar dari bangun pohon cari. Jika
kita pilih ak sebagai akar dari pohon cari, maka simpul
internal a1, a2, a3, ..., ak+1 terletak di subpohon kiri dari akar
ak. Begitu pula simpul eksternal E1, E2, …, Ek+1 terletak di
subpohon kiri. Sedangkan simpul lainnya yaitu ak+1, ..., an
dan Ek, Ek+1, ..., En terletak di subpohon kanan.

Ditentukan :
dan
COST(R) = Pihi + qi(hi-1)
Diketahui bahwa COST untuk masing-masing pohon
cari binar adalah :
COST = Pihi + qi(hi-1)
= Pihi + Pkhk + Pihi + qi(hi-1) + qi(hi-1)
hk adalah banyaknya perbandingan yang dilakukan
untuk mencapai akar ak. Banyaknya perbandingan untuk
mencapai akar ak adalah sebanyak 1.
= Pihi + Pk + Pihi + qi(hi-1) + qi(hi-1)
= Pk + Pihi + qi(hi-1) + Pihi + qi(hi-1)
= Pk + COST(L) + COST(R)
Kita dapatkan COST sebenarnya dari bangun pohon
cari binar T, untuk semua simpul internal. Sedangkan COST
yang dihitung, termasuk juga simpul eksternal, untuk

menentukan suatu pohon cari T yang optimal. Untuk
menghitung COST dari simpul eksternal, kita gunakan :
W(i,j) = qi + (q+p)
sebagai bobot dari pohon T.
Bobot(L) = Bobot T(0, k-1) = W(0, k-1)
Bobot(R) = Bobot T(k,n) = W(k,j)
W(i,j) = W(0, k-1) + W(k,n)
= Q0 + (q+p) qk + (q+p)
Kita peroleh COST dari pohon cari T,
Pk + COST(L) + COST(R) + W(0, k-1) + W(k, n) ………(1)
adalah COST keseluruhan dari pohon cari optimal T. Jika
pohon cari T optimal, COST dari persamaan (1) harus
minimum. Akibatnya COST(L) harus minimum pula, untuk
pohon cari yang mengandung a1, a2, a3, …, ak - 1 dan E0 , E1,
E2, …, Ek-1. Begitu pula COST(R) harus minimum pula untuk
ak+1, …, an dan Ek, Ek+1, …, En. Jika C(i,j) adalah COST untuk
pohon cari T yang optimal, berarti COST untuk subpohon
yang optimal adalah COST(L) = C(0, k-1). Sedangkan COST
untuk subpohon kanan yang optimal adalah COST(R) =
C(k,n). Persamaan (1) menjadi :

Pk + C(0,k-1) + X(k,n) + W(0, k-1) + W(k, n) ……………… (2)
Pohon cari T adalah suatu pohon cari yang optimal, kita
tentukan harga k sedemikian rupa sehingga persamaan (2)
minimum
C(0,n) = min C(0, k-1) + C(k, n) + Pk + W(0, k-1) +W(k,n)
................(3)
i<=k<=n
Dalam bentuk umum persamaan (3) dapat dituliskan
sebagai berikut :
C(i,j) = min C(i, k–1) + C(k, j) + Pk + W(i, k–1) +W(k,j)
= min C(I, k–1) + C(k,j) +
W(I,j)…….……………..(4) i<=k<=n
Persamaan (4) dapat diselesaikan dengan menghitung
semua kemungkinan C(i,j) sedemikian sehingga j–1= 0.
Selanjutnya menghitung semua kemungkinan C(i,j)
sedemikian sehingga j–i = 1, kemudian j–i = 2 dan
seterusnya.
Selama perhitungan kita akan mendapatkan akar R(i,j)
dari setiap pohon T. Selanjutnya dapat dibentuk suatu harga
bangun pohon cari binar yang optimal dari root R(i,j) tersebut.

R(i,j) adalah suatu harga (sebut k) yang meminimumkan
persamaan (4).
Contoh 7.4
Misalkan n = 4
(a1,a2,a3,a4) = (do, if, read, write)
Misalkan P(1,2,3,4) = (3,3,1,1)
Q(0,1,2,3,4) = (2,3,1,1,1)
Pada perhitungan awal, W(i,j) = Q(i)
C(i,j) =0
R(i,j) = 0 untuk 0 <= i <= 4
Dengan mempergunakan persamaan (4) dan W(i,j) = P(j) + W(i,
j–1), kita lakukan :
Langkah 1.
i = 0, Q(0) = 2; C(0,0) = 0; R(0,0) = 0
i = 1, Q(1) = 3; C(1,1) = 0; R(1,1 = 0
i = 2, Q(2) = 1; C(2,2) = 0; R(2,2) = 0
i = 3, Q(3) = 1; C(3,3) = 0; R(3,3) = 0
i = 4, Q(4) = 1; C(4,4) = 0; R(4,4) = 0

didapat :
Langkah 2 :
W(0,1) = P(j) + Q(j) + W(i, j-1)
= P(1) + Q(1) + W(0,0) = 3 + 3 + 2 = 8
C(0,1) = min(C(0,0) + C(1,1) + W(0,1))
0 <= k <= 1
=0+0+8=8
R(0,1) = 1, harga k yang minimum C(0,1) adalah i (k=1)
W(1,2) = P(2) + Q(2) + W(1,1) = 3 + 1 + 3 = 7
1 < k <= 2
= 0+0+7=7
R(1,2) = 2
W(2,3) = P(3) + Q(3) + W(2,2) = 1 + 1 + 1 = 3
C(2,3) = min C(2,2) + C(3,3) + W(2,3)
2 <k <=3
=0+0+3=3

Langkah 3
W(0,2) = P(2) + Q(2) + W(0,1) = 3 + 1 + 8 = 12
C(0,2) = min(C(0,0) + C(1,2) + W(0,2))
0 <= k <= 2
= 0 + 7 + 12 = 19
= min(C(0
,1) +
C(2,2) +
W(0,2))
0 <= k
<= 2
= 8 + 0 + 12 = 20
R(0,2) = 1
W(1,3) = P(3) + Q(3) + W(1,2) = 1 + 1 + 7 = 9
C(1,3) = min(C(1,1) + C(2,3) + W(1,3))
1 <= k <= 3
= 7 + 3 + 9 = 19
R(1,3) = 2
W(2,4) = P(4) + Q(4) + W(2,3) = 1 + 1 + 3 = 5

C(2,4) = min C(2,2) + C(3,4) + W(2,4)
2 <k <= 4
=0+3+5=8
C(2,4) = min C(2,3) + C(4,4) + W(2,4)
2 <k <= 4
= 3+0+5=8
R(,4) = 3
Didapat :
Langkah 4
W(0,3) = P(4) + Q(3) + W(0,2) = 1 + 1 + 12 = 14
C(0,3) = min(C(0,0) + C(1,3) + W(0,3))
0 <= k <= 3
= 0 + 12 + 14 = 26
C(0,3) = min(C(0,1) + C(2,3) + W(0,3))
0 <= k <= 3
= 8 + 3 + 14 = 25
C(0,3) = min(C(0,2) + C(3,3) + W(0,3))

0 <= k <= 3
= 19 + 0 + 14 = 33
R(0,3) = 2
W(1,4) = P(4) + Q(4) +
W(1,3) = 1 + 1 + 9 = 11
C(1,4) = min(C(1,1) +
C(2,4) + W(1,4))
1 <= k <= 3
= 7 + 3 + 9 = 19
C(1,4) = min(C(1,2) + C(3,4) + W(1,4))
1 <= k <= 4
= 7 + 3 + 11 = 21
C(1,4) = min(C(1,3) + C(4,4) + W(1,4))
1 <= k <= 4
= 12 + 0 + 11 = 23
Didapat :

Langkah 5
W(0,4) = P(4) + Q(4) + W(0,3) = 1 + 1 + 14 = 16
C(0,4) = min(C(0,0) + C(1,4) + W(0,4))
0 <= k <= 4
= 0 + 19 + 16 = 35
C(0,4) = min(C(0,1) + C(2,4) + W(0,4))
0 <= k <= 4
= 8 + 8 + 16 = 32
= min(C(0,
2) +
C(3,4) +
W(0,4))
0 <= k
<= 4
= 19 + 3 + 16 = 38
= min(C(0,3) + C(4,4) + W(0,4))
0 <= k <= 4
= 25 + 0 + 16 = 41
R(0,4) = 2

Didapat :
Kita dapatkan :
Dari tabel di atas, C(0,4)=32 adalah COST minimum
yang dimiliki oleh pohon cari binar dengan (a1,a2,a3,a4)
(do,if,read,while). Akar dari pohon binar T04 adalah a2.
Subpohon kiri adalah T01 dan subpohon kanan adalah T24.

T24 mempunyai akar a3; dengan subpohon kiri T22 dan
subpohon kanan T34. Jadi dengan data dari tabel di atas,
kita dapat membentuk sebuah pohon dengan akar T04.
Bangun dari pohon cari binarnya terlihat pada Gambar 7.44.
Bangun pohon cari binar di atas adalah bangun pohon
cari optimal yang kita dapatkan.
10.16 Heap
Kita tengok kali ini, salah satu bentuk khusus dari
pohon binar lengkap. Seperti telah dibahas terdahulu, pohon
binar lengkap adalah pohon binar yang seluruh simpul
lengkap, kecuali pada level terakhir, dengan catatan pula
bahwa simpul pada level terakhir tersebut terletak sekiri

mungkin dari pohon. Gambar 7.45 menunjukkan contoh
pohon binar lengkap.
Pada Gambar 7.45, pohon binar berlevel 0, 1, 2 dan 3.
Hanya 4 simpul terdapat pada level 3. Di sini ke empat
simpul tersebut berada di bagian kiri. Gambar 7.46
merupakan contoh pohon binar tidak lengkap.
Pada pohon binar yang simpulnya berisi elemen anggota
himpunan terurut total, seperti himpunan bilangan atau

untai alfabet, kita dapat mendefinisikan struktur heap. Suatu
pohon binar adalah heap, jika nilai setiap simpul lebih besar
atau sama dengan nilai anaknya. Heap seperti didefinisikan
di atas disebut juga “maxheap”. Kalau nilai setiap simpul
lebih kecil atau sama dengan nilai anaknya maka pohon
tersebut disebut “minheap”. Gambar 7.47 menunjukkan
contoh suatu heap.
Ke- 20 elemen heap tersebut dapat kita sajikan sebagai
daftar berurutan TREE[ ], sebagai berikut :
Urutan dari elemen TREE[ ] adalah berdasarkan level
dari simpul, dibaca dari kiri ke kanan, level demi level. Dapat
dicatat bahwa bila kita memiliki himpunan data, heap yang

dapat kita bentuk adalah tidak tunggal. Perhatikan saja
himpunan data kita [20,16,19,24]. Tiga buah heap yang dapat
kita bentuk terlihat pada gambar 7.48.
Kita dapat memasukkan elemen baru ke dalam sebuah
heap. Misalkan elemen 84 hendak kita masukkan ke dalam
heap pada gambar 7.47. Mula-mula elemen tersebut kita
letakkan sebagai elemen terakhir dari heap, dalam hal ini
sebagai elemen TREE[21] pada daftar berurutan. Langkah
selanjutnya adalah memeriksa apakah elemen tersebut lebih
besar dari ayahnya. Bila lebih besar, kita lakukan penukaran;
elemen tersebut sekarang menjadi ayah. Demikian seterusnya
sampai kondisi ini tidak tercapai. Gambar 7.49 menunjukkan
proses pemasukan elemen 84 ke dalam heap.

Proses kita hentikan, karena 84 < 87, sehingga heap
setelah memasukkan elemen 84 menjadi seperti gambar 7.50.
Proses pemasukkan satu simpul seperti dijelaskan di
atas dapat kita manfaatkan pula untuk membentuk sebuah
heap dari himpunan data yang diberikan. Proses dimulai dari

pohon hampa. Sebagai contoh kita hendak membentuk heap
dari himpunan [6,4,3,1,2,5]. Prosesnya sebagai berikut :
 Masukkan elemen 6
 Masukkan elemen 4 sebagai anak kiri. Karena 4 < 6,
tidak dilakukan pertukaran
 Masukkan elemen 3 sebagai anak kanan dari 6.
Karena 3 < 6, tidak dilakukan per-tukaran
 Masukkan elemen 1 sebagai anak kiri elemen 4.
Karena 1<4 tidak dilakukan per-tukaran.

10.17 Heapsort
Setelah kita membahas mengenai suatu bentuk khusus
dari Pohon binar, yaitu bentuk heap, maka pada bagian ini
kita perkenalkan salah satu aplikasi dari bentuk heap
tersebut. Aplikasi tersebut adalah dalam rangka melakukan
sortir atau pengurutan suatu larik (array). Metode
pengurutan ini, dikenal sebagai metode heapsort.
Pandang bahwa kita mempunyai sebuah array A
dengan N elemen. Algoritma heapsort untuk melakukan
pengurutan terhadap elemen dari A terdiri atas 2 fase. Pada
fase pertama kita membentuk sebuah heap H terhadap
elemen A. Selanjutnya pada fase kedua secara berulang-ulang
kita menghapus akar dari heap H. Karena akar dari heap H
selalu mengandung simpul dengan nilai terbesar di H, maka
fase pelaksanaan fase kedua akan menghapus elemen dari A
secara urutan menurun.
Secara formal algoritma ini memanfaatkan prosedur
pembentukan heap, seperti yang telah dibicarakan pada
bagian 7-16 yang lalu.

Algoritma Heapsort (A,N)
(Diberikan sebuah array A dengan N elemen. Algoritma
ini dimaksudkan untuk melakukan pengurutan terhadap
elemen A).
1. [Kita bentuk sebuah heap H dengan cara yang biasa
dilakukan] Repeat untuk J = 1 sampai N-1
Call insheap(A,J,a(j+1))
[end dari loop]
2. [Urutkan elemen A dengan menghapus berulang-
ulang akar dari H] Repeat while N > 1;
a) Call Delheap(A,N,ITEM)
b) A[CN+1] := ITEM
[end dari loop]
3. Exit
Maksud langkah 2b dari algoritma adalah untuk
mengefisienkan tempat. Artinya, seseorang dapat
menggunakan array lain B untuk menampung elemen terurut
dari A dan menggantikan langkah 2b dengan menetapkan :
B[N+1] := ITEM

Kompleksitas Algoritma Heapsort.
Sekarang kita tinjau waktu kompleksitas dari heapsort.
Pandang bahwa algoritma heapsort akan kita gunakan
terhadap array A dengan n elemen. Algoritma mempunyai 2
fase dan kita melakukan analisis kedua fase tersebut secara
terpisah.
Fase pertama
Pandang sebuah heap H. Periksa bahwa banyaknya
perbandingan untuk mencari posisi yang sesuai dari sebuah
elemen baru ITEM di H tidak boleh melebihi kedalaman dari
H. Karena H adalah pohon lengkap, kedalamannya terbatas
oleh fungsi log2 m, di sini m adalah banyaknya elemen dari
H. Karena itulah jumlah perbandingan keseluruhan g(n)
untuk memasukkan n buah elemen dari A ke dalam H
terbatas oleh :
g(n) <= n log2n
Oleh karena itu, waktu pelaksanaan fase pertama dari
heapsort adalah berbanding sebagai n log 2n

Fase Kedua
Pandang H adalah pohon lengkap dengan m elemen.
Juga pandang subpohon kanan dari H, adalah heap, dan L
adalah akar dari H. Dapat dilihat bahwa pengulangan
pembentukan heap membutuhkan 4 perbandingan untuk
memindahkan simpul L satu tingkat ke bawah dari pohon H.
Karena kedalaman dari H tidak melebihi log2 m, pem-
bentukan kembali heap membutuhkan paling banyak 4 log2n
perbandingan. Untuk mendapatkan posisi yang tepat dari L
di dalam pohon H. Ini berarti bahwa jumlah perbandingan
keseluruhan h(n) untuk menghapus n buah elemen array A
dari pohon H, yang membutuhkan pengulangan
pembentukan n kali, terbatas :
h(n) <= 4 log2n
Oleh karena itu, waktu pelaksanaan fase kedua dari
heapsort adalah juga berbanding sebagai n log2m. Karena
masing-masing fase membutuhkan waktu berbanding sebagai
n log2m, maka waktu pelaksanaan untuk pengurutan n
elemen array A menggunakan heapsort adalah berbanding
sebagai n log2n, yaitu f(n) = O(n log2n)

Sebagai perbandingan dapat kita lihat 2 metode
pengurutan yang lain, yaitu bubble-sort dan quicksort. Di sini,
waktu pelaksanaan rata-rata untuk bubble- sort adalah lebih
lambat, yakni O(n2). Sedangkan untuk quicksort adalah O(n
log2n); sama seperti heap-sort. Namun, waktu pelaksanaan
terburuk dari quicksort mencapai O(n2), sama seperti bubble-
sort.

BIODATA
Nama : Firman Sulfikar
Tempat/Tgl Lahir : Ujung Pandang,
19 Oktober 1996
Agama : Islam
No. Hp : 082349185139
Alamat : Jl. KH. Jabbar Asyiri, Makassar
E-mail : firmansulfikar1910@gmail.com
Motto Hidup : Orang yang selalu menyalahkan orang
lain tidak akan pernah mendapatkan
hidup yang lebih baik, jadi ubahlah
pemikiran menyalahkan orang lain
dan kau akan mengubah dunia mu
menjadi lebih baik.

Buku Ku

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Buku Ku

Judul Asli:

Diunggah oleh

Hak Cipta:

Format Tersedia

Kata Pengantar

Puji syukur alhamdulillah kami panjatkan ke hadirat Tuhan Yang

Maha Esa, karena telah melimpahkan rahmat-Nya berupa kesempatan dan

pengetahuan sehingga buku ini bisa selesai pada waktunya.

Terima kasih juga kami ucapkan kepada teman-teman yang telah

berkontribusi dengan memberikan ide-idenya sehingga buku ini bisa disusun

dengan baik dan rapi.

Kami berharap semoga buku ini bisa menambah pengetahuan para

saran yang bersifat membangun demi terciptanya buku selanjutnya yang

lebih baik lagi.

Makassar, 21 Juli 2018

Kata Pengantar ...................................................................................... i

Dalam istilah ilmu komputer, sebuah struktur data

adalah cara penyimpanan, penyusunan dan pengaturan data

di dalam media penyimpanan komputer sehingga data

tersebut dapat digunakan secara efisien.Sedangkan 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.

Konstanta digunakan untuk menyatakan nilai tetap

sedangkan variable digunakan dalam program untuk

menyatakan nilai yang dapat berubah-ubah selang eksekusi

Ada empat istilah data, yaitu:

1. Type data adalah jenis atau macam data di dalam suatu

variable dalam bahasa pemrograman.

2. Objek data mengacu kumpulan elemen, D (domain).

Pengantar Struktur Data 1

ke suatu set ke struktur data ‘e’ (d===e) misal bolean di

representasikan dalam 0 dan 1.

4. Struktur data biasa dipakai untuk mengelompokan

beberapa informasi yang terkait menjadi sebuah

Dalam teknik pemrograman, struktur data berarti tata

tampak oleh pengguna (user) atau pun kolom yang hanya

digunakan untuk keperluan pemrograman yang tidak tampak

oleh pengguna.Setiap baris dari kumpulan kolom-kolom

tersebut dinamakan catatan (record). Lebar kolom untuk data

dapat berubah dan bervariasi. Ada kolom yang lebarnya

berubah secara dinamis sesuai masukan dari pengguna, dan

juga ada kolom yang lebarnya tetap. Dengan sifatnya ini,

sebuah struktur data dapat diterapkan untuk pengolahan

database (misalnya untuk keperluan data keuangan) atau

untuk pengolah kata (word processor) yang kolomnya

berubah secara dinamis. Contoh struktur data dapat dilihat

pada berkas-berkas lembar-sebar (spreadsheet), pangkal-data

Pengantar Struktur Data 2

(dikompres), juga pemampatan berkas dengan teknik tertentu

yang memanfaatkan struktur data.

Secara garis besar type data dapat dikategorikan menjadi:

Type data sederhana.

Type data sederhana tunggal, misalnya Integer, real, boolean

Type data sederhana majemuk, misalnyaString

Struktur Data, meliputi:

Struktur data sederhana, misalnya array dan record.

Struktur data majemuk, yang terdiri dari:

a) Linier : Stack, Queue, sertaList dan Multilist

b) Non Linier : Pohon Biner dan Graph

Pemakaian struktur data yang tepat didalam proses

pemrograman akan menghasilkan algoritma yang lebih jelas

dan tepat, sehingga menjadikan program secara keseluruhan

lebih efisien dan sederhana.

Struktur data yang standar yang biasanya digunakan