1
STACK & QUEUE
(TUMPUKAN & ANTRIAN)
I. STACK (TUMPUKAN)
A. Tujuan
1. Mengerti dan memahami fungsi Stack dan Queue dalam Pemrograman.
2. Dapat membuat program dengan menggunakan Stack dan Queue.
3. Memahami tentang konsep pemrograman menggunakan struktur tumpukan dan
antrian.
4. Dapat mengetahui implemetasi Tumpukan dan antrian.
B. Teori Dasar
Stack (tumpukan) sebenarnya secara mudah dapat diartikan sebagai list
(urutan) dimana penambahan dan pengambilan elemen hanya dilakukan pada
satu sisi yang disebut top (puncak) dari stack.
Dengan melihat definisi tersebut maka jelas bahwa pada stack berlaku aturan
LIFO (Last In First Out), yaitu elemen yang terakhir masuk akan pertama kali
diambil atau dilayani. Salah satu analogi yang dapat dikemukakan di sini adalah
tumpukan piring atau barang lain. Pada saat kita hendak menumpuk piring-piring
tersebut tentulah yang kita lakukan adalah meletakkan piring pertama pada
tempatnya, selanjutnya meletakkan piring kedua di atas piring pertama dan
demikian seterusnya. Pada saat kita hendak mengambil satu piring dari tumpukan
tersebut, tentu yang diambil adalah piring teratas (yang terakhir kali ditaruh),
bukan yang terbawah (yang pertama kali diletakkan).
Dua operasi dasar pada stack adalah PUSH (operasi pemasukan elemen ke
dalam stack) dan POP (operasi pengambilan satu elemen dari dalam stack). Di
bawah ini diberikan contoh pemakaian operasi PUSH dan POP dan isi stack
untuk setiap selesai eksekusi satu operasi. (Untuk mempermudah penulisan, di
bawah ini isi stack tidak dituliskan secara bertumpuk, tetapi dengan kesepakatan:
1. elemen paling kanan adalah elemen yang ada pada TOS (Top Of the Stack)
2. stack yang dipakai bernama S
3. PUSH(S,B) berarti memasukkan elemen B ke dalam stack S
4. POP(B,S) berarti mengambil elemen dari stack S dan menaruhnya ke dalam
variabel B
2
Operasi yang dilakukan Isi Stack Keterangan
Kondisi Awal kosong -
PUSH('A',S) A -
PUSH('B',S) AB -
PUSH('C',S) ABC -
POP(Data,S) AB Variabel Data berisi 'C'
PUSH('D',S) ABD -
POP(Data,S) AB Data berisi 'D'
POP(Data,S) A Data berisi 'B'
Implementasi dalam bahasa Pascal dapat dilakukan dengan memanfaatkan
struktur data record dan array. Array dipergunakan untuk menyimpan elemenelemen
yang dimasukkan. Selain itu diperlukan pula suatu variabel untuk
mencatat banyaknya elemen yang ada di dalam array yang sekaligus menunjukkan
TOS. Pada implementasi di bawah ini:
1. konstanta maxelm menyatakan banyaknya elemen maksimum yang dapat
ditampung oleh stack
2. typeelemen adalah tipe data yang akan disimpan di dalam stack (bisa integer,
word, real, boolean, char , string atau lainya)
3. banyak adalah field yang menyatakan banyaknya elemen dalam stack saat itu,
yang sekaligus menyatakan TOS
Deklarasi tipe untuk tumpukan (stack):
type tumpukan = record
banyak :0..maxelm;
elemen : array[1..maxelm] of typeelemen;
end;
Selain prosedur untuk POP dan PUSH, kita dapat pula menambahkan sejumlah
fungsi untuk membantu penanganan kesalahan diantaranya adalah fungsi PENUHS
(untuk mengecek apakah stack penuh) fungsi KOSONGS (untuk mengecek apakah
stack kosong) dan fungsi SIZES (untuk mengetahui banyaknya elemen di dalam
stack).
Masing-masing sub program di atas dapat disajikan pseudocode-nya sebagai berikut:
Procedure Inisialisasi(var S : tumpukan);
begin
3
S. banyak¬ 0
end;
Function PENUHS(S : tumpukan): boolean;
begin
Jika S.banyak = maxelm maka PENUHS ¬ true
else PENUHS ¬false
end;
Function KOSONGS(S : tumpukan):boolean;
begin
If S.banyak = 0 then KOSONGS ¬ true
else KOSONGS¬false
end;
Procedure PUSH(data : tipeelemen; var S : tumpukan);
begin
If not KOSONGS(S) then
begin
1. S.banyak ¬ S.banyak +1
2. S.elemen[S.banyak]¬data
end
else
Tampilkan pesan kesalahan "Stack Penuh"
end;
Procedure POP(var S : tumpukan; var data : typeelemen);
begin
If not KOSONGS(S) then
begin
1. data¬S.elemen[S.banyak]
2. S.banyak ¬ S.banyak - 1
end
else
Tampilkan pesan kesalahan "Stack kosong"
End;
Alat dan Bahan
1. Alat
a. Komputer / Aplikasi Pascal
b. Printer
c. Flash Disc
2. Bahan
a. Kertas
b. Pulpen
II. QUEUE (ANTRIAN)
4
A. Teori Dasar
Queue atau antrian sebenarnya juga merupakan suatu list. Salah satu sifat yang
membedakan queue dengan stack adalah bahwa pada queue penambahan elemen
dilakukan pada salah satu ujung (ujung depan) dan pengambilan dilakukan pada
ujung yang lain (ujung belakang) . Dengan demikian queue menggunakan prinsip
FIFO (First In First Out), yaitu elemen yang pertama masuk akan pertama kali pula
dikeluarkan.
Seperti pada stack, operasi-operasi dasar pada queue adalah operasi penambahan
elemen ( sebut "ADDQ") dan operasi pengambilan elemen (sebut DELQ). Di bawah
ini diberikan contoh pemakaian operasi PUSH dan POP dan isi stack untuk setiap
selesai eksekusi satu operasi.
(Untuk mempermudah penulisan, di bawah ini isi queue tidak dituliskan secara
bertumpuk, tetapi dengan kesepakatan:
 elemen paling kanan adalah elemen yang ada pada ujung belakang (yang
terakhir kali masuk)
 queue yang dipakai bernama Q
 ADDQ(Q,B) berarti memasukkan elemen B ke dalam queue Q
 DELQ(B,Q) berarti mengambil elemen dari queue Q dan menaruhnya ke
dalam variabel B
Operasi yang dilakukan Isi Queue Keterangan
Kondisi Awal kosong -
ADDQ('A',Q) A -
ADDQ('B',Q) AB -
ADDQ('C',Q) ABC -
DELQ(Data,Q) BC Variabel Data berisi 'A'
ADDQ('D',Q) BCD -
DELQ(Data,Q) CD Data berisi 'B'
POP(Data,S) D Data berisi 'C'
IMPLEMENTASI QUEUE DALAM BAHASA PASCAL
Implementasi dalam bahasa Pascal dapat dilakukan dengan memanfaatkan struktur
data record dan array. Array dipergunakan untuk menyimpan elemen-elemen yang
dimasukkan. Selain itu diperlukan pula suatu variabel untuk mencatat banyaknya
elemen yang ada di dalam array. Pada implementasi di bawah ini:
 konstanta maxelm menyatakan banyaknya elemen maksimum yang dapat
ditampung oleh queue
 typeelemen adalah tipe data yang akan disimpan di dalam queue(bisa integer,
word, real, boolean, char , string atau lainya)
 banyak adalah field yang menyatakan banyaknya elemen dalam queue saat itu
 queue diimplementasikan sebagai array linier dengan memandang bahwa
elemen terdepan selalu berada pada sel pertama (implementasi fisik), sehingga
bila terjadi pengambilan satu elemen maka semua elemen di belakang elemen
terambil (bila ada) harus digeser ke depan satu langkah
Deklarasi tipe untuk antrian (queue):
type antrian= record
5
banyak :0..maxelm;
elemen : array[1..maxelm] of typeelemen;
end;
Selain prosedur untuk ADDQ dan DELQ, kita dapat pula menambahkan sejumlah
fungsi untuk membantu penanganan kesalahan diantaranya adalah fungsi PENUHQ
(untuk mengecek apakah antrian penuh) fungsi KOSONGQ (untuk mengecek apakah
antrian kosong) dan fungsi SIZEQ (untuk mengetahui banyaknya elemen di dalam
queue). Masing-masing sub program di atas dapat disajikan pseudocode-nya sebagai
berikut:
Procedure Inisialisasi(var q : antrian);
begin
Q. banyak ¬ 0
end;
Function PENUHQ(q : antrian): boolean;
begin
Jika Q.banyak = maxelm maka PENUHQ ¬ true
else PENUHQ¬false
end;
Function KOSONGQ(q : antrian):boolean;
begin
If Q.banyak = 0 then KOSONGQ ¬ true
else KOSONGQ ¬ false
end;
Procedure ADDQ(data : tipeelemen; var q : antrian);
begin
If not PENUHQ(Q) then
begin
1. Q.banyak¬ Q.banyak+1
2. Q.elemen[Q.banyak] ¬ data
end
else
Tampilkan pesan kesalahan "Antrian Penuh"
end;
Procedure DELQ(var q : antrian; var data : typeelemen);
begin
If not KOSONGS(Q) then
begin
1. data ¬Q.elemen[1]
2. for i:= 2 to Q.banyak
Q.elemen[i-1] ¬ Q.elemen[i]
3. Q.banyak ¬ Q.banyak- 1
end
else
Tampilkan pesan kesalahan "Antrian kosong"
End;
6
Dengan melihat implementasi di atas kita dapat merasakan adanya ketidakefisienan,
yaitu bahwa untuk mengambil satu elemen dari queue kita harus menggeser sisa
elemen yang sebenarnya tidak menjadi perhatian kita. Untuk data yang sedikit
mungkin ini tidak terasa, tetapi untuk data yang banyak maka ketidakefisienan ini
akan tampak jelas.
Untuk mengatasi permasalahan di atas kita dapat menggunakan implementasi queue
berputar, yaitu dengan membiarkan sel tetap kosong bila elemen pada sel tersebut
baru saja diambil. Bagaimanakah implementasi queue berputar? Perhatikan
implementasi di bawah ini.
type antrian_putar= record
depan,belakang,banyak :0..maxelm;
elemen : array[1..maxelm] of typeelemen;
end;
Field depan dan belakang masing-masing adalah untuk mencatat lokasi elemen
terdepan (yang akan diambil berikutnya) dan lokasi elemen paling belakang (elemen
terakhir kali masuk)
Procedure ADDQ(data : tipeelemen; var q : antrian_putar);
begin
If not PENUHQ(Q) then
begin
1. Q.belakang ¬ (Q.belakang mod maxelm)+1
2. Q.elemen[Q.belakang] ¬ data
end
else
Tampilkan pesan kesalahan "Antrian Penuh"
end;
Procedure DELQ(var q : antrian_putar; var data :
typeelemen);
begin
If not KOSONGS(Q) then
begin
1. data ¬ Q.elemen[Q.depan]
2. Q.banyak ¬ Q.banyak- 1
3. Q.depan ¬ (Q.depan mod maxelm)+1
end
else
Tampilkan pesan kesalahan "Antrian kosong"
End;
B. Langkah Kerja
Stack (tumpukan)
1. Pertama persiapakan alat dan bahan : berupa laptop dan aplikasi Pascal, serta
modul maupun literature yang berhubungan dengan materi Stack;
2. Nyalakan Laptop dan klik Aplikasi Pascal yang telah tersedia di Desktop;
7
3. Kemudian klik ‘new’; untuk memulai menulis isi program;
4. Program Stack atau tumpukan umumnya memiliki susunan pola sebagai
berikut :
a. Deklarasi tipe untuk tumpukan (stack): type tumpukan : record, banyak: 0
(nol) sampai dengan maksimal element; elemen berupa tipe array yang
berisi 1 (satu) sampai maksimal elemen yang kita kehendaki;
b. Fungsi data masih Kosong;
c. Fungsi data Sudah Penuh;
d. Membuat Procedure PUSH (memasukan tumpukan) yang didalamnya
berisi data : tipe elemen; variabel tumpukan);
e. Membuat Procedure Pop (mengambil satu elemen di dalam Stack /
tumpukan) dimulai dari yang terakhir diinputkan.
f. Memulai program utama
g. Menghentikan program apabila sudah penuh atau kondisi yang diinginkan
user.
Queue (antrian)
1. Pertama persiapakan alat dan bahan : berupa laptop dan aplikasi Pascal,
serta modul maupun literature yang berhubungan dengan materi Queue;
2. Nyalakan Laptop dan klik Aplikasi Pascal yang telah tersedia di Desktop;
3. Kemudian klik ‘new’; untuk memulai menulis isi program;
4. Program Queue atau antrian umumnya memiliki susunan pola sebagai
berikut :
a. Deklarasi tipe untuk antrian (queue):
type antrian= record
banyak :0..maxelm;
elemen : array[1..maxelm] of typeelemen;
end;
b. Procedure Inisialisasi(var q : antrian);
begin
Q. banyak ¬ 0
end;
c. Function PENUHQ(q : antrian): boolean;
begin
Jika Q.banyak = maxelm maka PENUHQ ¬ true
else PENUHQ¬false
end;
d. Function KOSONGQ(q : antrian):boolean;
begin
If Q.banyak = 0 then KOSONGQ ¬ true
else KOSONGQ ¬ false
end;
e. Procedure ADDQ(data : tipeelemen; var q : antrian);
begin
8
If not PENUHQ(Q) then
begin
Q.banyak¬ Q.banyak+1
Q.elemen[Q.banyak] ¬ data
end
else
Tampilkan pesan kesalahan "Antrian Penuh"
end;
f. Procedure DELQ(var q : antrian; var data : typeelemen);
begin
If not KOSONGS(Q) then
begin
data ¬Q.elemen[1]
for i:= 2 to Q.banyak
Q.elemen[i-1] ¬ Q.elemen[i]
Q.banyak ¬ Q.banyak- 1end
else
Tampilkan pesan kesalahan "Antrian kosong"
End;
5. Selanjutnya latihan membuat program yang telah tersedia di “Jobsheet”
seperti source code dibawah ini :
D. Hasil Praktikum
1. Percobaan 1
- Source Code
Praktikum 1
Program Tumpukan (Stack). Pascal
{contoh program tumpukan}
Program pop_push;
uses wincrt;
const elemen =255; {batas maximum karakter}
type S255 = string [elemen];
tumpukan = record
isi : s255;
atas : 0..elemen;
end;
var
T : tumpukan;
W : char;
kalimat : s255;
i,j : integer;
procedure awalan (var T : tumpukan);
begin
T.Atas := 0;
end;
procedure push (var T : tumpukan; X : char);
begin
T. Atas := T.Atas+1;
T.Isi[T.Atas] := X;
end;
9
function pop (var T : tumpukan): char;
begin
pop := T.Isi[T.Atas];
T.atas := T.atas-1;
end;
begin {program utama}
{melakukan proses push}
writeln('Masukkan Kalimat : ');
read(kalimat);
writeln;
for i := 1 to length (kalimat) do
push (T, kalimat [i]);
write('Elemen yang di-push : ', kalimat);
writeln;
readln;
{melakukan proses pop}
for i := 1 to length (kalimat) do
push (t, kalimat [i]);
writeln;
writeln('Hasil akhir push dibaca dengan pop: ;
{menampilkan hasil proses pop}
for j := 1 to length (kalimat) do
begin
w := pop (T);
write (w);
end;
readln;
end;
- Tampilan Hasil Program
Praktikum 1
Program Tumpukan (Stack). Pascal
10
Gambar 1. Hasil Scrip Praktikum 1 pop-push
Gambar 2. Hasil RUN Praktikum 1 pop-push
Analisa Percobaan 1
Praktikum 1
Program Tumpukan (Stack). Pascal
{contoh program tumpukan}
11
mendeklarasikan konstanta elemen = 255 yang merupakan batas maksimal
Karakter; mendefinisikan tipe data record yang memiliki 0 sampai nilai max
elemen bertipe string;
Variabel Global yang digunakan disetiap Sub Program, baik Prosedur, dan
fungsi yang berisi nama tumpukan, kalimat yang dibalik.
Prosedur sebagai Insialisasi tumpukan / stack; dan T.Atas merupakan elemen
teratas;
Prosedur untuk memasukkan elemen ke dalam tumpukan; Untuk
memasukkan elemen ke stack, selalu menjadi elemen teratas stack, Tambah
satu (increment) nilai top of stack terlebih dahulu setiap kali ada penambahan
elemen stack, asalkan stack masih belum penuh, kemudian isikan nilai baru
ke stack berdasarkan indeks top of stack setelah ditambah satu (diincrement).
12
fungsi untuk mengambil elemen dari tumpukan; Untuk mengambil elemen
teratas dari stack. Ambil dahulu nilai elemen teratas stack dengan mengakses
top of stack, tampilkan nilai yang akan diambil terlebih dahulu, baru
didecrement nilai top of stack sehingga jumlah elemen stack berkurang
melakukan proses push / memasukan kalimat yang akan dibalik,
{melakukan proses pop}
for i := 1 to length (kalimat) do
{mempush kalimat ke dalam tumpukan}
push (t, kalimat [i]);
writeln;
writeln('Hasil akhir push dibaca dengan pop: );
{menampilkan hasil proses pop}
for j := 1 to length (kalimat) do
(mempop isi tumpukan sehingga terlihat kalimat yang terbalik)
begin
w := pop (T);
write (w);
end;
readln;
end;
Kalimat yang akan dibalik disimpan dalam suatu perubah. Kemudian dengan
menggunakan proses kalang, setiap karakter diambil dan dimasukkan dalam
tumpukan. Dengan cara ini, karakter pertama dari kalimat tersebut akan
menempati bagian bawah tumpukan dan karakter terakhir akan menempati
bagian atas tumpukan. Dengan demikian, jika semua karakter dalam
tumpukan di pop, kalimat akan terbalik.
2. Percobaan 2
Source Code
Praktikum 2
program tigastack;
uses crt;
type tumpukan = record
isi : array[1..25] of byte;
top : 0..25;
end;
13
var t1,t2,t3 : tumpukan;
x,n,angka,bantu : byte;
procedure tumpuk(var t : tumpukan;angka : byte);
begin
inc(t.top);
t.isi[t.top] := angka;
end;
procedure keluarkan(var t : tumpukan;var angka :
byte);
begin
angka := t.isi[t.top];
dec(t.top);
end;
{procedure atur(var t : tumpukan; angka : byte);
begin
repeat
keluarkan(t,bantu);
tumpuk(t3,bantu);
until (t.isi[t.top] > angka) or (t.top = 0);
tumpuk(t,angka);
repeat
keluarkan(t3,bantu);
tumpuk(t,bantu);
until t3.top = 0;
end;}
procedure cetak(t : tumpukan);
begin
repeat
keluarkan(t,angka);
write(angka:3);
until t.top = 0;
end;
begin
t1.top := 0; t2.top := 0; t3.top := 0;
repeat
clrscr;
writeln('PROGRAM APLIKASI STACK(tumpukan data)':50);
write('Banyaknya angka acak ?? [5 sampai 25]:');
readln(n);
until n in[5..25];
for x := 1 to n do
begin
write('Angka ke ',x,' : ');readln(angka);
if angka mod 2 = 0 then
tumpuk(t1,angka)
else
tumpuk(t2,angka);
end;
repeat
keluarkan(t1,angka);
if t3.top = 0 then
tumpuk(t3,angka)
else
begin
14
if angka > t3.isi[t3.top] then
tumpuk(t3,angka)
else
begin
repeat
keluarkan(t3,bantu);
tumpuk(t2,bantu);
until (t3.isi[t3.top] < angka) or (t3.top = 0);
tumpuk(t3,angka);
repeat
keluarkan(t2,bantu);
tumpuk(t3,bantu);
until t2.isi[t2.top] mod 2 = 1;
end;
end;
until t1.top=0;
repeat
keluarkan(t3,angka);
tumpuk(t1,angka);
until t3.top = 0;
writeln;
write('Angka genap = ');
if t1.top = 0 then
write('Tidak ada angka genap !')
else
cetak(t1);
writeln;
write('Angka ganjil = ');
if t2.top = 0 then
write('Tidak ada angka ganjil !')
else
cetak(t2);
readkey;
end.
- Tampilan Hasil Program
Praktikum 2
program stack2;
15
Gambar 3. Hasil Scrip Praktikum 2, Stack 2
16
Gambar 4. Hasil RUN Praktikum 2/ Stack 2
ANALISA DATA
Percobaan 2
Source Code
Praktikum 2
judul Program tigastack, mendeklarasikan tipe data record, isi berupa array
yang memiliki nilai1 sampai 25 angka bertipe byte dengan bagian atas Top
berisi nilai 0 sampai 25;
var t1,t2,t3 : tumpukan;
x,n,angka,bantu : byte;
Mendefinisikan variabel inisialisasi (t) sebagai tumpukan yang akan
dideklarasikan sebagai t1 (angka ganjil), t2 (angka gnap) t3 (tampilan seluruh
angka), sedangkan var z,n,angka,bantu bertipe byte (tipe bulat);
Membuat Prosedur tumpukan/stack, dan Stack nantinya akan diinputkan
angka (bilangan bulat) yang artinya increment sebagai penambah angka di isi
tumpukan;
17
prosedur untuk mengambil elemen teratas dari tumpukan, jika stack kosong
maka tidak dapat dilakukan pengambilan, jika isi maka dapat dilakukan
pengambilan, untuk mengambil elemen teratas dari stack tumpukan. Ambil
dahulu nilai elemen teratas stack dengan mengakses t.top, tampilkan nilai
yang akan diambil terlebih dahulu, baru didecrement nilai t.top sehingga
jumlah elemen tumpukan(stack) berkurang
Prosedur bantuan untuk mengatur tumpukan yang berguna untuk
menampilkan deretan angka dari yang kecil ke besar sehingga mempermudah
operasi pengeluaran / pengambilan tumpukan (LIFO).
Prosedur untuk mencetak tumpukan, dengan cara menampilkan nilai (t)
tumpukan dan angka sampai tumpukan atas bernilai kosong.
18
Pengerjaan program utama yang berawal dari tumpukan (t) bernilai kosong
pada bagian teratas (top). Kemudian menginput angka acak 5 s/d 25 yang
nantinya sebagai jumlah tumpukan yang diinginkan, pengerjaan ini akan
memproses jumlah tumpukan, jumlah bilangan genap, jumlah bilangan ganjil
serta pengambilan tumpukan dari ke tiga jenis pengerjaan tersebut dari yang
paling akhir akan diambil duluan.
Memasukan jumlah angka acak (n), percabangan jika angka pembagian 2
sama dengan 0 atau habis di tumpukan (t1,angka) ini adalah bilangan Genap
dan tumpukan (t2,angka) adalah bilangan ganjil;
19
Ini adalah proses pengerjaan pada tumpukan bilangan ganjil (t2), t3 adalah
inputan deret angka, apabila nilainya lebih besar (‘angka ke” >besar)’ maka
akan di letakan duluan di deret ganjil / pembagiannya masih menyisakan
bilangan;
Pencetakan/menampilkan hasil dari pengambilan tumpukan LIFO pada stack
yaitu t1.top akan mengurutkan tumpukan teratas sampai ke bawah pada
tampilan angka genap, sedangkan t2.top akan akan mengurutkan tumpukan
teratas sampai ke bawah pada tampilan angka ganjil, dan apabila tidak ada
salah satu bilangan ganjil/genap (‘tidak ada angka genap/ganjil’);
3. Percobaan 3
Source Code
Praktikum 3 : QUEUE
20
Antrian2.Pascal
PROGRAM Contoh 2;
Uses crt;
Type
Pointer = ^TypeData;
TypeData = Record
norek : string;
nama : string;
alamat : string;
next : pointer;
End;
Var
List : Pointer;
pil,pil2 : char;
procedure menu(var b : integer);
begin
writeln(' MENU ANTRIAN ');
writeln('----------------------------------');
writeln('Sisa Antrian : ',b);
writeln(' 1. Tambahkan Antrian [1]');
writeln(' 2. Tampil Antrian [2]');
writeln(' 3. Panggil Antrian [3]');
writeln(' 4. Keluar [4]');
write('Masukkan Pilihan Menu : '); readln(pil);
writeln;
end;
{MASUK DATA}
Procedure Masuk_data(Var L : Pointer);
Var
Baru : Pointer;
norek, nama, alamat : string;
Begin
write('No Rekening : '); readln(norek);
write('Nama Nasabah : '); readln(nama);
write('Alamat Nasabah : '); readln(alamat);
writeln('--------------------------------------');
New(Baru);
Baru^.norek := norek;
Baru^.nama := nama;
Baru^.alamat:= alamat;
Baru^.next := Nil;
if L = Nil then L := Baru
else
Begin
Baru^.next :=L;
L :=Baru;
End;
End;
{PROCEDURE CETAK}
Procedure Cetak(L : Pointer);
Var
Bantu : Pointer;
c : integer;
Begin
Bantu := L;
c := 4;
While Bantu <> Nil Do
21
Begin
Writeln('Data Nasabah ke ',c);
Writeln('No Rekening : ',Bantu^.norek);
writeln('Nama Nasabah : ',Bantu^.nama);
Writeln('Alamat Nasabah : ',Bantu^.alamat);
writeln('------------------------------------');
Bantu:=Bantu^.next;
dec(c);
End;
write('Tekan ENTER untuk kembali');
End;
Procedure Hapus(Var L : Pointer);
Var
Baru,bantu : Pointer;
Begin
Bantu := L;
if Bantu = Nil then Writeln('List Kosong...')
else
Begin
While Bantu^.next^.next <> nil do
Bantu := Bantu^.next;
New(Baru);
Baru := Bantu^.next;
Bantu^.next:=nil;
Writeln('Data Nasabah');
Writeln('No Rekening : ',Baru^.norek);
writeln('Nama Nasabah : ',Baru^.nama);
Writeln('Alamat Nasabah : ',Baru^.alamat);
writeln('------------------------------------');
dispose(Baru);
End;
End;
{PROGRAM UTAMA}
Var
Bil,Bil1,i,a : integer;
JB : Char;
Begin
clrscr;
a:=0;
Menu(a);
clrscr;
while pil<>'4' do
begin
if (pil='1') then
begin
for i := 1 to 4 do
begin
inc(a);
Masuk_data(List);
end;
end;
readkey;
clrscr;
menu(a);
clrscr;
if (pil='2') then
begin
cetak(List);
end;
22
if (pil='3') then
begin
dec(a);
hapus(List);
end;
end;
End.
- Tampilan Hasil Program
Praktikum 3
program antrian2; Queue
23
Gambar 5. Hasil Scrip Praktikum 3 antrian2. pascal
24
Gambar 6. Hasil RUN Praktikum 3 antrian2. pascal
25
ANALISA Percobaan 3
Praktikum 3 : QUEUE
Antrian2.Pascal
Deklarasi tipe untuk antrian (queue), menggunakan Pointer bertipe yang
akan menunjuk dan menyimpan memori (record) , dengan inputan type
data string;
Var
List : Pointer;
pil,pil2 : char;
variabel berupa pointer dengan nama List, pil, pil2 dalam bentuk char
untuk pilihan prosedur yang merupakan Variabel Global
Prosedur yang memproses dan menampilkan antrian berupa pilihan Menu
antrian yang dapat menampilkan pilihan, cukup dengan menekan angka
1,2,3,4 pada keyboard, yang nanti dapat dipanggil pada pemrosesan
program utama yang disimpan di (List) sebagai pointer. Dan nilai sisa
antrian adalah jumlah imputan ketika memasukan data, dan akan berkurang
jika menekan angka 3 panggil antrian.
26
Prosedur untuk memasukan data Baru yang merupakan pointer digunakan
untuk menyimpan data yang dinputkan var :string : bisa angka maupun
huruf. Pointer yang bernilai.NILmerupakan kata tercadang dan dianggap
tidak menunjuk alamat memori manapun dan digunakan untuk menambah
data Baru;
Prosedur untuk menampilkan data nasabah yang telah diinputkan
sebelumnya di procedure masuk_data, nilai decrement digunakan untuk
mengurangi nilai variabel bilangan (c);
27
Prosedur yang menampilkan dan menghapus data yang disimpan pada
Pointer : Baru, Bantu. Disini ada type pointer New yang digunakan untuk
menampung data (Baru); dan Dispose (Baru) yang digunakan untuk
melepasnya atau menghapus;
Pengerjaan pada program utama, memanggil prosedur Menu (' MENU
ANTRIAN '); yang nilainya masih kosong, dan angka 4 adalah
batasan pengulangan, sehingga apabila menginputkan angka 4 maka
akan keluar dari program;
28
begin
if (pil='1') then
begin
for i := 1 to 4 do
begin
inc(a);
Masuk_data(List);
end;
end;
readkey;
clrscr;
menu(a);
clrscr;
if (pil='2') then
begin
cetak(List);
end;
if (pil='3') then
begin
dec(a);
hapus(List);
end;
end;
End.
Pada program utama selanjutnya user dapat menginputkan data dengan cara
memanggil setiap procedure yang memiliki penyimpanan/pointer bernama (list),
jika menekan tombol (1) kita akan memasukan data, tiap 4 data dan bisa
ditambahkan lagi sesuai keinginan user, jika menekan tombol (2) kita akan
menampilkan data yang telah diinputkan tadi, jika menekan tombol (3) kita akan
memanggil antrian yang pertama diinputkan, dan sisa antrian akan berkurang 1
setiap kali dipanggil, jika menekan tombol (4) kita akan keluar dari program.
4. Percobaan 4
Source Code
Praktikum 4; antrian dengan dequeue dan enqueue
program antrian;
uses wincrt;
const max=5;
type queue=record
elemen:array[1..max]of string;
head,tail,count:integer;
end;
var
Q:queue;
i:integer;
data:string;
temp:string;
jawab:char;
procedure inisialisasi(var A:queue);
begin
29
A.head:=0;
A.tail:=0;
end;
function empty:boolean;
begin
if Q.tail=0 then
empty:=true
else
empty:=false;
end;
function full:boolean;
begin
if Q.tail=max then
full :=true
else
full :=false;
end;
procedure Enqueue (var A:queue; x:string);
begin
if empty then
begin
A.head:=1;
A.tail:=1;
A.elemen[A.tail]:=x;
end
else if not Full then
begin
A.tail:=A.tail+1;
A.elemen[A.tail]:=x;
end
else
writeln ('antrian sudah penuh');
end;
function dequeue(var A: queue) : string;
var
j:integer;
begin
if not empty then
begin
dequeue:=A.elemen[A.head];
for j:=A.head to (A.tail-1) do
begin
A.elemen[j]:=A.elemen[j+1];
end;
A.tail :=A.tail-1;
end;
end;
procedure tampil (A:queue);
var
k:integer;
begin
30
if A.tail<> 0 then
for k:= 1 to A.tail do
writeln ('pasien ke-',k,' : ' ,A.elemen[k])
else
writeln ('antrian Kosong');
end;
begin
writeln ('program antrian Pasien');
writeln ('----------------------');
writeln;
inisialisasi (Q);
for i:= 1 to max do
begin
write ('entry nama pasien ke-',i,' :');
readln (data);
enqueue (Q,data);
end;
writeln;
writeln('proses...');
writeln;
tampil (Q);
writeln;
jawab:='Y';
while ((jawab='Y') or (jawab='y')) and (not empty) do
begin
jawab:='T';
write ('ambil data antrian pasien [Y/T] :');
readln(jawab);
if (jawab='Y') or (jawab='y') then
begin
temp :=dequeue (Q);
tampil (Q);
end;
writeln;
end;
end.
- Tampilan Hasil Program
Praktikum 4; antrian dengan dequeue dan enqueue
31
Gambar 7. Hasil Scrip Praktikum 4, Dequeue, Enqueue
32
Gambar 8. Hasil Run Praktikum 4, Dequeue, Enqueue
33
Analisa Praktikum 4; antrian dengan dequeue dan enqueue
Deklarasi tipe untuk antrian (queue), menggunakan konstanta max
menyatakan banyaknya elemen berjumlah 5 yang dapat ditampung oleh
queue dengan menggunkan struktur data record, dengan inputan elemen yang
akan disimpan dalam array bertipe string, serta inisialisasi, elemen data awal
dan akhir yang akan diinputkan bertipe integer;
Variabel global yang akan dipergunakan pada program utama
Prosedur inisialisai / penamaan / penyebutan variabel A sebagai antrian, yang
diketahui A. head sebagai kepala/awal dan A.tail sebagai ekor/akhir, masih belum
ada datanya;
function empty:boolean;
sub program fungsi untuk membantu penanganan kesalahan diantaranya
adalah fungsi empty (untuk mengecek apakah antrian kosong) apabila elemen
ada yang dikeluarkan;
34
function empty:boolean;
sub program fungsi untuk membantu penanganan kesalahan diantaranya
adalah fungsi full (untuk mengecek apakah antrian penuh), apabila elemen
sudah menempati batas maximal, dan tidak ada elemen yang dikeluarkan dari
antrian;
Prosedur untuk menambahkan elemen baru ke dalam antrian, jika antrian
masih kosong, elemen dapat dimasukan yaitu no antrian 1 sampai ke 5, yaitu
yang pertama dimasukan menjadi kepala (A.head) kemudian elemen yang
dimasukan berikutnya menjadi ekor (A.tail) sampai memasukan elemen
keantrian kelima, dan ketika memasukan lagi elemen maka akan keluar
tulisan 'antrian sudah penuh';
Fungsi mengurangkan/mengeluarkan antrian, jika antrian tidak kosong/penuh,
maka elemen yang didepan dan yang pertama masuk harus dikeluarkan yaitu
dengan operasi depan dikeluarkan (A.tail-1)
35
Prosedur menampilkan hasil antrian pasien ke 1 s/d 2 dan pengambilan
antrian sampai habis sehingga keluar tulusan ‘antrian kosong’;
Program utama, untuk memproses serta menampilkan semua prosedur dan fungsi
yang dipanggil dari antrian (Q);
36
F. KESIMPULAN
1. Stack (tumpukan)
a. Pada stack berlaku aturan LIFO (Last In First Out), yaitu elemen yang
terakhir masuk akan pertama kali diambil atau dilayani;
b. Dua operasi dasar pada stack adalah PUSH (operasi pemasukan elemen ke
dalam stack) dan POP (operasi pengambilan satu elemen dari dalam stack)
2. Queue (antrian)
a. Elemen yang pertama kali masuk ke antrian akan keluar pertama kalinya
First In First Out(FIFO);
b. Antrian dapat dibuat dengan menggunakan: Liniear Array dan Circular
Array;
c. Operasi Pada Queue (antrian) : isEmpty (untuk mengecek antrian apakkah
masih kosong), IsFull (untuk mengecek antrian apakah sudah penuh),
Enqueue (untuk menambahkan data) , dequeue (untuk mengeluarkan data
dari antrian).
G. DAFTAR REFERENSI
Antonie Pranata, Algoritma dan Pemrograman, J&J Learning Yogyakarta, 2000
P. Insap Santosa, Struktur Data Menggunakan Turbo Pascal 6.0, Andi Offset,
Yogyakarta, 2001
Materi dari internet :
1. Program Impementasi Stack dalam Pascal; noor fitriani hastuti
blogspot.com ditulis tanggal 7 Novemver 2009, diakses pada tanggal 3
Maret 2015;