LAPORAN RENCANA PRAKTIKUM

STRUKTUR DATA

Nama

: YOPI LALA

NIM

: DBC 113 016

Kelas

: G

Modul

: I (STACK)

JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNIK
UNIVERSITAS PALANGKA RAYA
2014

BAB I
TUJUAN DAN LANDASAN TEORI
A. Tujuan praktikum
1. Mahasiswa mampu memahami konsep stack.
2. Mahasiswa mampu mengimplementasikan stack untuk memecahkan masalah
tertentu.
B. Landasan teori
Stack atau tumpukan bisa di artikan sebagai kumpulan data seolah-olah di
letakan di atas data yang lain. Satu hal yang perlu di ingat bahwa kita bisa
menambah (menyisipkan) data dan mengambil (menghapus) data melalui ujung
yang sama, yang di sebut sebagai ujung atas stack. Secara sederhana, sebuah stack
bisa di ilustrasikan seperti gambar di bawah ini :
F
E
D
C
B
A

Atas (Top)

Dari gambar di atas, bisa di lihat bahwa kotak B terletak di atas kotak A
dan di bawah kotak C. Kotak D terletak di atas kotak C, kotak E terletak di atas
kotak D dan seterusnya sampai kotak terakhir. Dari gambar di atas menunjukkan
bahwa kotak lewat satu ujung, yaitu bagian atas. Apabila ada kotak lain yang akan
di sisipkan, maka kotak tersebut akan di letakan di atas kotak F, dan jika ada kotak
yang akan di ambil, maka kotak F yang di ambil untuk pertama kali.
Dengan demikian stack adalah struktur data yang menggukan konsep Last In First
Out (LIFO) dan bersifat dinamis dimana data bisa di tambah maupun diambil.
Stack dapat dideklarasikan dengan sebuah record yang mempunyai elemen sebuah
array tabelemen untuk menyimpan elemen stack dan sebuah variabel top untuk
menunjuk sebuah elemen stack teratas. Deklarasi sebagai berikut :
Const
NMAX=. . . .;

{ukuran maksimum stack}

NULL= 0;

{penunjuk stack kosong}

Type
Tipedata = . . . .; {tipe data yang di simpan dalam
stack}
Stack = record
Tabelelemen : array [1 . . NMAX] of tipedata
Top : NULL . . . NMAX;

{top dari stack}

End;
Operasi pada stack
1. Operasi Push
Perintah push digunakan untuk memasukkan data ke dalam stack Untuk
lebih jelasnya perhatikan ilustrasi berikut ini. Misalkan kita mempunyai data-data
3, 25 dan 9 dalam stack dengan posisi 3 paling bawah dan 9 paling atas. Dan kita
akan memasukkan data 34 ke dalam stack tersebut. Tentu saja data 34 akan
diletakkan diatas data 9.
Push (34)
34

25

25

Prosesnya dari opersi push dapat dilihat pada penggalan program berikut
ini :
Procedure PUSH (var T : Tumpukan; X : integer);
begin
if T.Atas = MaxElemen then
writeln (TUMPUKAN SUDAH PENUH)

else
begin
T.Atas := T.Atas + 1;
T.Isi[T.Atas] := X
end
end;
2. Operasi Pop
Operasi pop adalah operasi untuk menghapus elemen yang terletak pada
posisi paling atas dari sebuah tumpukan. Sama halnya dengan operasi push, maka
dengan deklarasi tumpukan seperti diatas, prosedur untuk operasi pop bisa dengan
mudah kita implementasikan, yaitu :
Procedure POP (var T : Tumpukan);
begin
if T.Atas = 0 then
writeln (TUMPUKAN SUDAH KOSOSNG)
else
T.Atas := T.Atas 1
end;

Pemanfaatan Stack
Salah satu pemanfaatan stack adalah untuk menulis ungkapan dengan

menggunakan notasi tertentu. Seperti kita ketahui, dalam penulisan ungkapan

numeris, kita selalu menggunakan tanda kurung untuk mengelompokkan bagian
mana yang akan dikerjakan terlebih dahulu.
Sebagai contoh, perhatikan ungkapan berikut ini :
(C+D) *(E-F)
Dari contoh diatas (C+D) akan dikerjakan lebih dahulu, kemudian baru (E-F) dan
hasilnya akan dikalikan.
Lain halnya dengan contoh berikut ini : C+D*E-F

D*E akan dikerjakan terlebih dahulu, kemudian diikuti yang lain. Dalam hal ini
pemakaian tanda kurung sangat penting karena akan mempengaruhi hasil akhir.
Cara penulisan ungkapan sering disebut dengan notasi infix, yang artinya
bahwa operator ditulis diantara 2 operand. Bisa dirubah kedalam notasi prefix,
yang artinya adalah bahwa operator ditulis sebelum kedua operand yang akan
disajikan.
Perhatikan contoh dari notasi infix dan prefix berikut ini :
Infix

Prefix

A+B

+AB

A+B-C

-+ABC

(A+B)*(C-D)

*+AB-CD

Secara sederhana, proses konversi dari infix dapat dijelaskan sebagai berikut :
Misalkan ungkapan yang akan dikonversikan adalah sebagai berikut : (A+B)*(CD)
Dengan menggunakan tanda kurung bantuan, ungkapan diatas dapat ditulis
menjadi :
(+AB)*(-CD)
Jika (+AB), kita umpamakan P dan (-CD) sebagai Q, maka ungkapan diatas dapat
ditulis : P*Q. Selanjutnya, notasi infix diatas diubah menajdi notasi prefix : *PQ.
Dengan mengembalikan P dan Q pada notasinya semula dan menghapus tanda
kurung bantuan, kita dapat memperoleh notasi prefix dari persamaan (A+B)*(CD), yaitu : *+AB-CD.
Notasi lain, yang merupakan kebalikan dari notasi prefix adalah notasi
postfix. Dalam hal ini operator ditulis sesudah operand. Sama halnya dengan
notasi prefix, maka notasi postfix dapat menggunakan tanda kurung bantuan.
Perhatikan contoh dari notasi infix dan postfix berikut ini :
Infix

Postfix

16 / 2

16 2 /

(2 + 14) * 5

2 14 + 5 *

2 + 14 * 5

2 14 5 * +

(6 2) * (5 + 4)

6254+*

Perhatikan ilustrasi yang menggambarkan penggunaan notasi postfix

dalam stack. Contohnya adalah 2 14 + 5 * = 80
Pop 14

push 5

pop 3

Push 2

Pop 2

pop 16

Push 14

Push 2 + 14 = 16

push 16 * 5 = 80

14
2

pop answer 80

12

16

80

Implementasi stack :
1. Inisialisasi, adalah proses untuk membuat stack dalam keadaan kosong.
Proses ini di lakukan dengan mengisi variabel top dengan nilai yang tidak
menunjuk salah satu elemen array.
Procedure inisialisasi ( var S : stack);
Begin
S. Top := Null;
End;
2. Empty/kosong, adalah operasi untuk mengetahui status stack, yaitu
kosong atau tidak .
Function empty (S : stack) : Boolean;
{mengirim nilai true jika S adalah stack kosong}
Begin
Empty := (S.Top=NMAX);
End;
3. Full/penuh, adalah operasi untuk mengetahui status stack , yang kosong
atau tidak.
Function full (S : stack) : Boolean;
{mengirim nilai true jika S adalah stack penuh}
Begin
full := (S.Top=NMAX);
End;

4. Pop, dengan mempertimbangkan seleksi awal terhadap kondisi stack yaitu

hanya berlaku untuk stack yang tidak kosong.
Procedure POP (var S : Stack; var data : tipedata);
{IS : s adalah stack yang tidak kosong}
{FS : elemen top dari stack S yang di hapus dan di
Simpan didata}
Begin
If Not empty (S) Then
Begin
data := S.tabelemen [S.Top];
S.Top := S.Top-1;
End;
Else
Data := . . ; {isi suatu nilai yang kemungkinan
bukan data}
End;
5. Push, dengan mempertimbangkan seleksi awal terhadap kondisi stack yaitu
menghindari overflow.
Procedure Push (var S : Stack; var data : tipedata);
{IS : S adalah stack yang belum penuh, data
terdefenisi}
{FS : data menjadi elemen top dari stack S}
Begin
If Not full (S) Then
Begin
S. Top := S.Top + 1;
S. tabelemen [S. Top] := data;
End;
End;
Tugas praktikum :

1. Buatlah program menggunakan prinsip tumpukan (stack) dan beri tiga

pilihan : push. pop, dan quit. Jika di pilih push program akan meinta user
menginput sebuah kata, di mana maksimal 6 karakter jika lebih dari 6
karakter akan muncul pesan kesalahan. Jika di pilih pop maka karakter
teratas akan di keluarkan, bila belum ada kata yang dimasukan waktu
memilih pop akan tampil pesan kesalahan. Jika di pilih quit maka program
selesai.
Output :
Pilihan :
1. Push
2. Pop
3. Quit
Pilihan [1/2/3] = 1
Masukan Kata = Data
Hasil Push : Data`

BAB II
LANGKAH KERJA
Buatlah program menggunakan prinsip tumpukan (stack) dan beri tiga
pilihan

: push. pop, dan quit. Jika di pilih push program akan meinta user

menginput sebuah kata, di mana maksimal 6 karakter jika lebih dari 6 karakter
akan muncul pesan kesalahan. Jika di pilih pop maka karakter teratas akan di
keluarkan, bila belum ada kata yang dimasukan waktu memilih pop akan tampil
pesan kesalahan. Jika di pilih quit maka program selesai.
Output :
Pilihan :
4. Push
5. Pop
6. Quit
Pilihan [1/2/3] = 1
Masukan Kata = Data

Hasil Push : Data`

Coding program :
program stack;
uses crt;
const Topmax = 6;
var
top, i : byte;
pil

: char;

temp, e : string;
stack1 : array[1..Topmax] of string;
procedure pushAnim;
begin
for i:= 1 to 2 do
begin
gotoxy(i,6);
write('Hasil Push :',temp);
delay(1);
gotoxy(i,6);
clreol;
end;
for i:= 1 to 2 -top do
begin
delay(1);
gotoxy(1, 7+i); write ('Hasil Push : ',temp);
end;
end;
procedure popAnim(temp:string);
begin
for i := 1 to 2-top do

begin
delay(30);
gotoxy(1, 2-i-top); write('

');

gotoxy(1, 2-i-top); write('Hasil Pop : ',temp);

end;
for i := 1 to 2 do
begin
clreol;
gotoxy(1, 8); writeln('Hasil Pop : ',temp);
clreol;
end;
end;
procedure hapus;
begin
gotoxy(1,10); write('Tekan enter untuk melakukan Pop');
gotoxy(22,8); write(' ');
gotoxy(20,5); write('

');

gotoxy(21,8); write(' '); readln;

gotoxy(20,8); write(' '); readln;
gotoxy(19,8); write(' '); readln;
gotoxy(18,8); write(' '); readln;
gotoxy(17,8); write(' '); readln;
gotoxy(16,8); write(' '); readln;
gotoxy(15,8); write(' ');
gotoxy(1, 8); write(' Stack Telah Kosong ') ; readln;
gotoxy(1, 7); clreol;
gotoxy(1, 8); clreol;
gotoxy(1, 9); clreol;
gotoxy(1,10);clreol;
end;
procedure push(e : string);

begin
inc(top);
stack1[top] := e;
pushanim;
end;
procedure pop (e : string);
begin
if top <> 0 then
begin
e := stack1[top];popanim(e);
dec(top);
hapus;
end
else
begin
gotoxy(1, 8); write(' Stack Telah Kosong ');
readkey;
gotoxy(1, 8); clreol;
end;
end;
begin
clrscr;
writeln('PILIHAN : ');
writeln('1. Push');
writeln('2. Pop');
writeln('3. Quit');
writeln('Pilihan [1/2/3] = ');
top := 0;
gotoxy (15,20);
writeln('Nama : Yopi Lala ');
gotoxy (15,21);
writeln('Nim : DBc 113 018');

repeat
gotoxy(19, 5); clreol;
pil := readkey; write(pil);
if pil = '1' then
begin
if top <> Topmax then
begin
gotoxy(1, 7); write('Masukkan Kata = ');
temp:=readkey; readln(temp);
i:= length(temp);
if i > 6 then
begin
gotoxy(1, 9); writeln('Karakter Huruf Penuh'); readkey;
end
else
push(temp);
gotoxy(1, 9); clreol;
gotoxy(1, 7); clreol;
end else
begin
gotoxy(1, 7);write('Stack Telah Penuh');
readkey;
gotoxy(1, 7); clreol;
end;
end else
if pil ='2' then pop(temp);
until pil = '3';
end.

BAB III
PEMBAHASAN
Procedure inisialisasi ( var S : stack);
Begin
S. Top := Null;
End;
Inisialisasi, adalah proses untuk membuat stack dalam keadaan kosong.
Proses ini di lakukan dengan mengisi variabel top dengan nilai yang tidak
menunjuk salah satu elemen array, pada program di atas variabel top di isi dengan
null dimana Null harus telebih dahulu di beri nilai Constant atau yang sering di
singkat const, seperti di bawah ini
program stack;
uses crt;
const

nmax=6;
null=0;

constant atau const adalah nilai konstanta yang tetap di mana nilai tersebut tidak
akan berubah sampai program berakhir dan pada program di atas nilai konstanta
untuk nmax adalah 6 dan untu null di beri nilai 0.
Untuk memeriksa operasi stack empty/kosong atau penuh kita harus
membuat terlebih dahulu fungsi empty dan full dengan koding seperti di bawah
ini :
Function empty (S : stack) : Boolean;
{mengirim nilai true jika S adalah stack kosong}
Begin
Empty := (S.Top=NMAX);
End;
Function full (S : stack) : Boolean;
{mengirim nilai true jika S adalah stack penuh}
Begin
full := (S.Top=NMAX);
End;
Di mana nilai NMAX telebih dahulu di beri nilai tetap sesuai kebutuhan.
Pop adalah operasi pengambilan elemen yang di lakukan pada Top, di
mana keadaan Top harus terisi terlebih dahulu atau tidak boleh kosong, untuk
melakukan menyeleksi Top kosong kita menggunakan statement fungsi If Not
seperti di bawah ini :
Procedure POP (var S : Stack; var data : tipedata);
{IS : s adalah stack yang tidak kosong}
{FS : elemen top dari stack S yang di hapus dan di
Simpan didata}
Begin
If Not empty (S) Then
Begin
data := S.tabelemen [S.Top];
S.Top := S.Top-1;
End;
Else
Data := Stack kosong ; {isi suatu nilai yang
kemungkinan
bukan data}

Maksud dari program di atas adalah jika S.Top tidak kosong maka
program akan melakukan Pop pada data := S.tabelemen [S.Top]; S.Top :=
S.Top-1; daan sebaliknya jika S.Top masih kosong atau sudah kosong maka
program akan memberi peringatan Stack telah Kosong.
Push adalah operasi pengisian elemen yang di lakukan pada Top, di mana
keadaan Top harus terlebih dahulu kosong atau tidak boleh penuh sehingga untuk
meyeleksinya keadaan tersebut kita menggunakan statement If Not full (S) then
seperti di bawah ini :
Procedure Push (var S : Stack; var data : tipedata);
{IS : S adalah stack yang belum penuh, data terdefenisi}
{FS : data menjadi elemen top dari stack S}
Begin
If Not full (S) Then
Begin
S. Top := S.Top + 1;
S. tabelemen [S. Top] := data;
End;
End;
Maskud dari program di atas adalah jika top belum terisi atau tidak penuh
maka program akan menyuruh kita mengisi Top dengan S. Top := S.Top + 1; S.
tabelemen [S. Top] := data; dan sebaliknya jika Top sudah penuh maka kita
tidak bisa menambah atau mengisi tumpukan lagi pada elemen top.
Buatlah program menggunakan prinsip tumpukan (stack) dan beri tiga
pilihan

: push. pop, dan quit. Jika di pilih push program akan meinta user

menginput sebuah kata, di mana maksimal 6 karakter jika lebih dari 6 karakter
akan muncul pesan kesalahan. Jika di pilih pop maka karakter teratas akan di
keluarkan, bila belum ada kata yang dimasukan waktu memilih pop akan tampil
pesan kesalahan. Jika di pilih quit maka program selesai.
Output :
Pilihan :
1. Push

2. Pop
3. Quit
Pilihan [1/2/3] = 1
Masukan Kata = Data
Hasil Push : Data`
Koding program :
program stack;
uses crt;
const Topmax = 6;
var
top, i : byte;
pil

: char;

temp, e : string;
stack1 : array[1..Topmax] of string;
procedure pushAnim;
begin
for i:= 1 to 2 do
begin
gotoxy(i,6);
write('Hasil Push :',temp);
delay(1);
gotoxy(i,6);
clreol;
end;
for i:= 1 to 2 -top do
begin
delay(1);
gotoxy(1, 7+i); write ('Hasil Push : ',temp);
end;
end;

procedure popAnim(temp:string);
begin
for i := 1 to 2-top do
begin
delay(30);
gotoxy(1, 2-i-top); write('

');

gotoxy(1, 2-i-top); write('Hasil Pop : ',temp);

end;
for i := 1 to 2 do
begin
clreol;
gotoxy(1, 8); writeln('Hasil Pop : ',temp);
clreol;
end;
end;
procedure hapus;
begin
gotoxy(1,10); write('Tekan enter untuk melakukan Pop');
gotoxy(22,8); write(' ');
gotoxy(20,5); write('

');

gotoxy(21,8); write(' '); readln;

gotoxy(20,8); write(' '); readln;
gotoxy(19,8); write(' '); readln;
gotoxy(18,8); write(' '); readln;
gotoxy(17,8); write(' '); readln;
gotoxy(16,8); write(' '); readln;
gotoxy(15,8); write(' ');
gotoxy(1, 8); write(' Stack Telah Kosong ') ; readln;
gotoxy(1, 7); clreol;
gotoxy(1, 8); clreol;
gotoxy(1, 9); clreol;

gotoxy(1,10);clreol;
end;
procedure push(e : string);
begin
inc(top);
stack1[top] := e;
pushanim;
end;
procedure pop (e : string);
begin
if top <> 0 then
begin
e := stack1[top];popanim(e);
dec(top);
hapus;
end
else
begin
gotoxy(1, 8); write(' Stack Telah Kosong ');
readkey;
gotoxy(1, 8); clreol;
end;
end;
begin
clrscr;
writeln('PILIHAN : ');
writeln('1. Push');
writeln('2. Pop');
writeln('3. Quit');
writeln('Pilihan [1/2/3] = ');
top := 0;
gotoxy (15,20);

writeln('Nama : Yopi Lala ');

gotoxy (15,21);
writeln('Nim : DBc 113 018');
repeat
gotoxy(19, 5); clreol;
pil := readkey; write(pil);
if pil = '1' then
begin
if top <> Topmax then
begin
gotoxy(1, 7); write('Masukkan Kata = ');
temp:=readkey; readln(temp);
i:= length(temp);
if i > 6 then
begin
gotoxy(1, 9); writeln('Karakter Huruf Penuh'); readkey;
end
else
push(temp);
gotoxy(1, 9); clreol;
gotoxy(1, 7); clreol;
end else
begin
gotoxy(1, 7);write('Stack Telah Penuh');
readkey;
gotoxy(1, 7); clreol;
end;
end else
if pil ='2' then pop(temp);
until pil = '3';
end.

Jika program di atas di jalankan maka Outputnya adalah sebagi berikut

Di mana jika kita memasukan pilihan 1 atau Push maka program akan
meminta kita memasukan sebuah kata di mana kata tersebut tidak boleh lebih dari
6 karakter. Jika lebih dari 6 karakter maka program akan memberikan kita
peringatan karakter huruf penuh dan kita akan di minta melakukan pilihan
sekali lagi seperti di bawah in i :

Kata yang di masukan

Kata yang di masukan

menampilakn hasil

lebih dari 6 karakter

tidak lebih dari 6 karakter

Push

setelah menampilkan hasil Push, maka program kembali meminta kita

measukan pilihan kembali jika kita pilih 2 atau Pop maka Program akan
menghapus kata yang kita inputkan tadi di dalam Push dari kanan kekiri satu
persatu dengan menekan enter, jika sudah habis maka ada peringatan stack telah
kosong. Dan program akan di ulang lagi dari awal. (dengan catatan Push harus
terlebih dahulu terisi, jika belum terisi maka kita akan di minta
menginputkan kata terlebih dahulu di Push)

Melakukan proses Pop

Peringatan Bahwa Pop

kembali ke Program

Dengan menekan enter.

sudah habis.

Awal

BAB IV
Kesimpulan
Dari pembahasan di atas dapat di simpulkan bahwa :

Stack atau tumpukan bisa di artikan sebagai kumpulan data seolah-olah di

letakan di atas data yang lain dan data tersebut bisa di ambil atau di

tambahkan melalui ujung yang sama.

Push adalah operasi menambahkan data di atas data yang lain
Pop adalah pengambilan data dari yang paling terkahir.
LIFO (Last In First Out) konsep dimana data yang terakhir masuk itu yang
akan duluan keluar konsep ini adalah konsep yang di gunakan pada Stack
atau tumpukan

DAFTAR PUSTAKA

LAMPIRAN