Makalah ini membahas tentang algoritma stack. Terdapat penjelasan mengenai pengertian stack, definisi stack, deklarasi stack, dan operasi-operasi dasar pada stack seperti inisialisasi, push, pop, size, empty, dan full. Contoh pemakaian stack untuk membalik kalimat juga dijelaskan.

1. MAKALAH
Algoritma
Tentang
“STACK”
Kelompok 1
Fernando P. Busman
:12205060
Riki Rinaldi
:10205057
Intan wahyuli
:13205055
Indah suci antika
:13205053
Istiqlal
:13205058
Halim taufik
:13205049
Khairul Ikhwan
:13205059
DOSEN PEMBIMBING:
Lita Sari Muklis, M.Kom
PROGRAM STUDIMANAJEMEN INFORMATIKA
JURUSAN SYARIAH STAIN
BATUSANGKAR
2013

2. Kata Pengantar
Segala puji bagi Allah SWT, atas limpahan rahmat dan kasih sayangnya.
Dan shalawat dan salam kepada nabi Muhammad SAW. Rasa syukur yang
mendalam ini muncul dari hari sanubari yang sangat mendalam, karena telah
dapat membuat makalah Algoritma ini tentang Stack.
Makalah ini sangat dibutuhkan, karena dijadikan sebagai panduan dalam
pembelajaran dan sebagai wujud dalam pengembangan pembelajaran.
Dalam kesempatan ini, ucapan terima kasih kami aturkan bagi penyusun
makalah ini. Disamping itu, kami juga menyadari bahwa makalah ini tidak luput
dari sisi-sisi kelemahannya. Oleh karena itu, kami mengharapkan kritik dan saran
demi pencapaian yang maksimal terhadap makalah ini.
Batusangkar, 20 November 2013
Penulis,
Kelompok 1

3. Daftar isi
Kata pengantar.................................................................................
i
Daftar isi .......................................................................................................ii
Bab 1. Pendahuluan
A.Latar belakang ........................................................................
1
B.Rumusan masalah ...................................................................
1
Bab 2. Isi
A. Stack ……………………………………………………………. 2
Bab 3. Penutup
1. Kesimpulan ................................................................................... 21
2. Saran ................................................................................................21
Daftar pustaka ……………………………………………………….… 22

4. BAB I
PENDAHULUAN
I.1 Latar Belakang
Salah satu konsep yang sangat berguna didalam ilmu komputer adalah satu
bentuk struktur data yang di sebut dengan tumpukan. Dalam hal ini kita coba
mengenali mengapa stack (tumpukan) sangat berguna dan memainkan peranan
penting dalam pemograman dan bahasa pemograman.
I.2 Rumusan Masalah
A. Pengertian Stack (Tumpukan)
B. Definisi Stack
C. Deklarasi Stack
D. Operasi Pada Stack (Tumpukan)
1. Inisialisasi
2. Push
3. pop
4. Size
5. Empty/kosong
6. Full/penuh

5. BAB II
PEMBAHASAN
2.1 PENGERTIAN STACK (TUMPUKAN)
A. Pengertian Stack (Tumpukan)
STACK (tumpukan) dapat di katakan sebagai list yang operasi
penghapusan dan penyisipan elemennya dilakukan di satu ujung. atau bisa juga di
artikan sebagai suatu kumpulan data yang seolah-olah ada data yang di letakkan di
atas data yang lain. Satu hal yang perlu kita ingat adalah bahwa kita bisa
menambah (menyisipkan) data, dan mengambil (menghapus) data lewat ujung
yang sama, yang disebut sebagai ujung atas tumpukan (top of stack).
Dalam kehidupan sehari-hari terdapat banyak kejadian yang mempunyai sifat
seperti stack, untuk lebih memahami pengertian stack kita ambil contoh sebagai
berikut:
Perhatikan sebuah tumpukan piring di sebuah warung makan. Piringpiring tersebut tersusun rapat dari atas ke bawah (membentuk barisan beruruntan).
Setiap kali ada pembeli datang, maka iring yang paling atas akan di ambil
(menghapus elemen) yang berarti mengurangi jumlah piring dalam tumpukan.
Bila tumpukan itu sudah habis atau tinggal sedikit, maka pegawai warung akan
menambahkan piring lain yang masih bersih (menambah elemen). Piring yang
terakhir kali dimasukan pasti akan terletak ditumpukan paling atas dan piring yang
terletak paling atas dalam tumpukan itu pasti merupakan piring yang terakhir kali
dimasukan.
Kesimpulannya adalah penambahan dan penghapusan elemen hanya dapat di
lakukan di ujung atas tumpukan piring. Proses seperti ini biasa disebut Last In
Firts Out (LIFO).
Tumpukan hanya bisa menambah atau mengambil dari sebuah kotak lewat
satu ujung, yaitu ujung bagian atas. Tumpukan merupakan kumpulan data yang
sifatnya dinamis, artinya kita bsa menambah dan mengambil data darinya.
Sebuah contoh:
Misalnya kita mempunyai dua buah kotak yang kita tumpuk, sehinga kotak kita
letakan di atas kotak yang lain. jika kemudian tumpukan dua buah kotak itu kita
tambah dengan kotak ketiga, keempat dan seterusnya, maka akan kita peroleh
sebuah tumpukan kotak, yang terdiri dari N kotak.

6. Dari gambar ini kita bisa mengatakan bahwa kotak B ada di atas kotak A
dan ada di bawah kotak C. Gambar ini menunjukan bahwa dalam Tumpukan kita
hanya bisa menambah atau mengambil sebuah kotak lewat satu ujung, yaitu ujung
bagian atas. Dapat dilihat pula bahwa Tumpukan merupakan kumpulan data yang
sifatnya dinamis, artinya kita bisa menambah dan mengambil data darinya.
Kotak F adalah bagian atas dari tumpukan tersebut, jika ada kotak lain yang akan
di sisipkan maka ia akan di letakan di atas kotak F, dan jika ada kotak yang akan
diambil maka kotak F yang akan di ambil pertama kali.
Dengan memperhatikan ilustrasi tersebut maka kita bisa melihat bahwa
tumpukan merupakan suatu senarai (list) yang mempunyai watak “masuk terakhir
keluar pertama” (last in firts out – LIFO).
B. Penyajian Tumpukan (stack)
Seperti di jelaskan di atas Tumpukan adalah kumpulan data. Dalam pasca
kita sudah mengenal tipe data terstruktur yang di sebut larik (array). Dengan
demikian kita bisa menggunakan larik ini untuk menyajikan sebuah tumpukan.
Tetapi bisa segera kita lihat bahwa penyajian tumpukan menggunakan larik adalah
kurang tepat. Alasannya adalah bahwa banyaknya elemen dalam larik sudah
tertentu (statis), sedangkan dalam tumpukan banyaknya elemen bisa sangat
bevariasi (dinamis).
Meskipun demikian larik bisa kita gunakan untuk menyajikan sebuah
tumpukan, dengan anggapan bahwa banyaknya elemen maksimum dari tumpukan
tersebut tidak akan melebihi batas maksimum banyaknya elemen dalam larik.

7. Pada suatu saat ukuran tumpukan akan sama dengan ukuran larik. Kalau kita
teruskan menambah data lagi, akan terjadi overflow. Dengan demikan perlu data
tambahan
untuk
mencatat
posisi
ujung
tumpukan.
Dengan kebutuhan seperti ini kita bisa menyajikan tumpukan menggunakan tipe
data terstruktur yang lain, yaitu tipe rekaman (record)yang terdiri dari dua medan.
Medan pertama bertipe larik untuk menyimpan elemen tumpukan, Medan kedua
bertipe integeruntuk mencatat posisi ujung tumpukan.
Dengan anggapan ini maka kita bisa mendeklarasikan tumpukan seperti ini:
Const MaxElemen = 255;
Type Tumpukan = record
Isi : array [1. . . MaxElemen ] of integer;
Atas : 0. . . MaxElemen
Var T : Tumpukan ;
Deklarasi di atas kita menganggap bahwa elemen tumpukan T, yang
tersimpan dalam larik T. Isi, adalah bertipe integerdan banyaknya elemen
tumpukan maksimum adalah sebesar MaxElemen =255 elemen.
Sesungguhnya elemen tumpukan tidak harus berupa integer, tetapi bisa
berupa data dengan tipe yang lain, misalnya real atau cher.Tetapi, tipe data dari
medan atas harus bilangan bulat antara 0 sampai MaxElemen, karena nilainya
menunjukan banyaknya elemen yang ada dalam suatu tumpukan, yang sekaligus
menunjukan posisi elemen teratas dalam tumpukan yang di maksud.
Contoh:
jika T.Atas = 5, berarti dalam tumpukan ada 5 elemen, yaitu T.Isi[1],...,
T.Isi[5]. Jika ada data yang diambil, maka nilai medan T.Atas dikurangi 1menjadi
4,
yang
berarti
T.Isi[4]adalah
elemen
teratas.
Sebaliknya, jika kedalam tumpukan ditambahkan sebuah elemen, maka nilai
T.Atas ditambah dengan 1 menjadi 6, sehingga T.Isi[6]adalah elemen teratas.
A. Operasi Pada Tumpukan (stack)
Ada dua operasi dasar yang bisa digunakan pada sebuah tumpukan, yaitu
operasi menyisipkan data atau memPush data dan operasi menghapus data atau
memPop data.
Operasi Push
Dengan penyajian tumpukan seperti diatas, maka operasi Push dapat
diimplementasikan, yaitu:
Procedure PUSH (var T : Tumpukan; X : integer);
Begin
T.Atas := T.Atas + 1;
T.Isi [T.Atas] := X
End;
Prosedur diatas akan menyiapkan tempat untuk X yang akan diPush kedalam
tumpukan, yaitu dengan menambah nilai medanT.Atasdengan 1 dan kemudian
menyisipkan
X
kedalam
larik
T.Isi.
tetapi jika suatu saat nilai T.Atas sama dengan MaxElemen dan kita akan

8. memPush lagi, maka akan terjadi overflow pada larik T.Isiberhubung deklarasi
banyaknya elemen larik tidak mencukupi .
Pada proseur diatas perlu ditambahkan dengan testing untuk memastikan
bahwa sebelum suatu data diPush nilai T.Atas belum mencapai MaxElemen.
Prosedure diatas perlu diubah menjadi:
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;
Dengan ditambahnya testing untuk mencetak nilai T.Atas, maka prosedur di atas
menjadi lebih sempurna.
Kita juga bisa mengubah pesan yang ditampilkan mengunakan statemen
writelndengan kata lain yang bertipe boolean, sehingga pesan salahnya kita
letakkan pada program utama . Dengan menggunakan kontrol berupa data bertipe
boolean, maka prosedur diatas bisa diubah menjadi seperti terlihat pada program
ProgramProsedur PUSH
Pemanggilan prosedur diatas dari program utama atau dari bagian lain
dilaksanakan dengan:
PUSH (T, Penuh, X);
Dengan T adalah perubah bertipe tumpukan, penuh bertipe boolean dengan X
bertipe integer. Berdasarkan nilai perubah penuh bisa ditentukan langkah
selanjutnya yang perlu diambil.
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 di atas prosedur untuk operasi Pop bisa diimplementasikan, yaitu:
Prosedure Pop (var T : Tumpukan );

9. Begin
T.Atas := T.Atas – 1
end;
Timbul pertanyaan, seandainya tumpukan sudah kosong lalu apa yang akan
diPop? Jawabannya tentu saja adalah tidak mungkin memPop suatu tumpukan jika
tumpukan
tersebut
sudah
kosong.
prosedur diatas perlu ditambah testing untuk mencetak kosong tidaknya sebuah
tunpukan sebelum proses memPop suatu elemen tumpukan dilaksanakan.
Tumpukan yang kosong ditunjukan dengan nilai T.Atas sama dengan 0.
Sehingga kita bisa melengkapi prosedur diatas menjadi:
Prosedur Pop (var T : Tumpukan);
Begin
if T.Atas = 0 then
writeln (‘TUMPUKAN SUDAH KOSONG’)
else
T.Atas : = T.Atas – 1
End;
Cara lain untuk melihat kosong tidaknya tumpukan adalah dengan
membuat suatu fungsi yang menghasilkan suatu data yang bertipe boolean. Cara
ini lebih disarankan dari cara di atas, karena dengan mengetahui nilai fungsi
tersebut kita segera bisa tahu kosong tidaknya suatu tumpukan. alasan lain adalah
supaya
sifat
modularitas
program
tetap
dijalankan.
Kecuali itu sering akli kita juga perlu mengetahui nilai data yang baru saja diPop.
Untuk itu prosedur di atas bisa diubah menjadi sebuah fungsi seperti:
Program fungsi Pop(dengan fungsi untuk mentest kosong tidaknya tumpukan)
end;
{* fungsi Pop *}
Dalam program utama kita bisa memanggil program di atas dengan:
X : = pop (T) ;
Dengan x (dalam contoh) adalah data bertipe integer.
B. Contoh Pemakaian Tumpukan
Untuk lebih memahami operasi yang terjadi pada tumpukan, berikut sajian
contoh program yang memanfaatkan tumpukan untuk membalik kalimat. Dalam
hal ini yang dibalik adalah seluruh kalimat, bukan perkata. Bisa dicoba dengan

10. mengacu pada program ini, membalik kalimat dengan melakukan pembalikan
perkata.
Sebagai contoh, jika kalimat yang di baca adalah:
BELAJAR PASCAL ADALAH MUDAH DAN MENYENANGKAN
Setelah dibalik maka kalimat diatas bisa menjadi:
NAKGNANEYNEM NAD HADUM HALADA LACSAP RAJALEB
Dalam program yang akan disajikan, kalimat yang akan dibalik disimpan
dalam suatu perubah. Kemudian dengan menggunakan proses kalang, setiap
karakter diambil dan dimasukan 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 dipop, kalimat akan terbalik.
Program selengkapnya tersaji di bawah ini.

11. Contoh hasil program tersebut:
MEMBALIK KALIMATT MENGGUNAKAN TUMPUKAN
-------------------------------------Isiskan sembarang kalimat:
SAAT INI SAYA SEDANG MENDENGARKAN ALUNAN PIANO DARI RICHARD
CLAYDERMAN
Kalimat asli:
SAAT INI SAYA SEDANG MENDENGARKAN ALUNAN PIANO DARI RICHARD
CLAYDERMAN
Setelah dibalik:
NAMREDYALD DRAHCIR IRAD ONAIP NANULA NAKRAGNEDNEM GNADES AYAS
INI TAAS
B. Definisi

12. Secara formal, sebuah Stack bersifat T didefinisikan sebagai sebuah barisan
berhingga atas elemen-elemen bersifat T, bersama-sama dengan operasi berikut:
1. Inisialisasi stack menjadi kosong.
2. Mencari tahu status stack kosong atau tidak.
3. Mencari tahu status stack penuh atau tidak.
4. Mencari panjang stack (jumlah elemen stack).
5. memasukan elemen baru pada ujung stack, yaitu top stack jika stack tidak
penuh.
6. Jika stack tidak kosong, mengambil elemen teratas (top stack).
C. Deklarasi
Stack dapat dideklarasikan dengan sebuah record yang mempunyai elemen
sebuah arraydata untuk menyimpan elemen stack dan sebuah variabel top untuk
menunjuk elemen stack teratas (top element).selengkapnya sebagai berikut:
Tipestack = record
Data : array [1. . maks_stack] of tipedata
Top : 0. .maks_stack ;
End ;
Var S : tipestack ;
Tipestack adalah nama pengenal tipe untuk stack.
maks_stack merupakan jumlah maksimum elemen stack.
data adalah array yang digunakan untuk menyimpan data-data stack.
tipedata adalah tipe data dari elemen-elemen stack.
top di pakai untuk menunjuk elemen teratas dari stack.
S adalah nama variabel yang bertipe stack.
D. Operasi Pada Stack
1. Inisialisasi. Proses untuk membuat stack dalam keadaan kosong. Proses
ini di lakukan untuk mengisi variabel top dengan nilai yang tidak
menunjuk salah satu elemen array. Pada model deklarasi di atas maka top
diisi dengan 0.
2. Push. Proses memasukan elemen baru kedalam stack. Prosesnya meliputi
mengalokasikan ruang dengan mengubah nilai top untuk menunjuk ruang
di sebelahnya, kemudian memasukan data ke dalam lokasi tersebut.
3. Pop. Proses untuk mengambil elemen dari stack. Prosesnya meliputi
mengambil adata dari elemen paling atas, kemudian menghapus elemen
tersebut dengan cara mengubah nilai top untuk menunjuk elemen
dibawahnya.
4. Size. Operasi untuk mengetahui jumlah elemen stack.
5. Empty/kosong. Operasi untuk mengetahui status stack, kosong atau tidak.
6. Full/penuh.Operasi untuk mengetahui status stack, penuh atau tidak.
E. Contoh program

13. Contoh : (program membalik urutan angka)
Proses pada program ini diawali dengan meminta input angka dari
keyboard. Proses ini akan terus dilakukan sampai data yang dibaca adalah 0. Datadata dapat dimasukan sekaligus dengan menuliskan beberapa angka dan
dipisahkan dengan spasi. Setelah selesai memasukan data, maka data-data tersebut
akan dituliskan kembali dengan urutan terbalik. Hal ini dapat dilakukan dengan
stack yang penjelasanya adalah setiap kali membaca angka, maka angka tersebut
dimasukan kedalam stack, dan setelah selesai membaca, maka tanda-tandan
diambil dari stack dan langsung dituliskan.
program Membalik_Urutan_angka;
uses crt;
const maks_stack = 10 ;
type tipedata = integer ;
tipestack = record
top
: 0. .maks_stack ;
data :
array [1. .maks_stack] of tipedata
end ;
var
S
: tipestack ;
X
: tipedata ;
Angka
: tipedata ;
Lanjut
: boolean ;
Temp
: char ;
Procedure errorl ;
Begin
Write („stack penuh , angka terlalu banyak‟);
Lanjut : = false ;
End ;
{Program utama}
Begin
Repeat
Clrscr ;
Writeln („Membalik urutan angka‟) ;
Writeln („Masukan barisan angka , pisahkan dengan spasi , akhiri
dengan
angka 0‟) ;
Write („ -> : „) ; read (angka) ;
Lanjut : = true ;
While lanjut and (angka <> 0) do
Begin
X : = angka ; push (X , S) ;
Read (angka)
End ;
Writeln ;
Writeln („barisan angka dengan urutan terbalik : „) ;
Write („ <- : „) ;
While not (kosong (S) ) do

14. Begin
Pop (X ,S ) ;
write (X , „
„);
End ;
Writeln ;
Write („coba lagi dengan data yang lain
Gotoxy (wherex-2 , wherey) ; temp
until upcase (temp) = „N‟
End.
(Y /N) ? [ ] „) ;
: = readkey
F. Penulisan Ungkapan Numeris
Salah satu pemanfaatan stack (tumpukan) adalah untuk menulis ungkapan
menggunakan notasi tertentu. Seperti yang telah diketahui dalam penulisan
ungkapan, khususnya ungkapan numeris, kita selalu menggunakan tanda kurung
untuk mengelompokan bagian mana yang harus di kerjakan lebih dulu. Sebagai
salah satu contoh, dalam ungkapan:
(A + B) * (C – D)
Suku (A + B) akan dikerjakan lebih dahulu, kemudian suku (C – D) , dan terakhir
mengalikan hasil yang diperoleh dari dua suku ini. Sedangkan pada ungkapan:
A+B * C–D
Maka B * C akan dikerjakan lebih dulu, dikuti yang lain. Dalam hal ini
memakaian tanda kurung akan sangat mempengaruhi hasil akhir. Cara penulisan
ungkapan sering disebut dengan notasi infix, yang artinya adalah bahwa operator
ditulis diantara dua operand.
Dalam ungkapan-ungkapan yang rumit, pemakaian tanda kurung ini tidak
bisa dihindari. Semakin rumit suatu ungkapan semakin banyak dibuthkan tanda
kurung. Hal ini membawa suatu konsekuensi bahwa penuisan tanda kurung itu
pun harus benar-benar terhindar dari kesalahan.
Seorang ahli matematika yang bernam Jan Lukasiewiez emudian
mengembangkan suatu car penulisan ungkapan numeris yang selanjunya disebut
notasi Polish atau notasi prefix, yang artinya adalah baha operator ditulis sebelum
kedua operand yang akan disajikan. Contoh notasi prefix dari notasi infix (simbol
$ adalah notasi perpangkatan):
Infix
A +B
A+B–C
(A + B) * (C – D)
A – B / (C * D $ E)
Prefix
+A B
-+ABC
*+AB–CD
-A/B*C$DE
Secara sederhana, proses konversi dari infix menjadi prefix dijelaskan
sebagai berikut. Misalnya ungkapan yang dkonversikan adalah:
(A + B) * (C – D)
Dengan menggunakan tanda kurung bantuan, ungkapan di atsa diubh
menjadi:

15. [+ A B] * [- C D]
Jika [- A B] dimisalkan P, dan [- C D] kita misalkan Q, maka ungkapan
diatas bisa diitulis sebagai:
P*Q
Selanjunya, notasi infix diatas diubah menjadi notasi prefix:
*P Q
Dengan mengembalikan P dan Q pada notasi semula dan menghpus tanda
kurung bantuan, diperoleh notasi prefix dari persamaan (A + B) * (C – D), yaitu:
*+ A B – C D
Dari contoh tersebut, bisa diperhatikan bahwa dalam penulisan ungkapan,
bahkan yang rumit sekalipun, tidak pernah digunakan tanda kurung untuk
pengelompokkan. Dalam hal ini urutan oenulisan oprator akan menentukan
operasi mana yang harus dikerjakan lebih dahulu.
Notasi lain yang merupakan kebalikan notasi prefix adalah notasi posifx
atua notasi suffix, atau lebih dikenal dengan notasi Polish terbalik (Reserve Polish
Notation atau RPN). Dalam hal ini oprasi ditulis sesudah operand. Sama halnya
dengan notasi prefix, maka dalam notasi postfix ini pun tidak diperlukan adanya
tanda kurung pengelopokkan.
Proses konversi dari notasi infix ke notasi postfix juga sama dengan
konversi dari infix ke prefix. Sebagai contoh, ungkapan:
( A + B) * (C – D)
Dengan kurung bantuan diperoleh:
[ A B +] * [ C D -]
Kemudian dengan memisalkan [ A B +] sebagai P, dan [ - C D ] sebagai
Q, dan kemudian dilakukan konversi dan subtitusi kembali, kita peroleh notasi
postfix untuk ungkapan diatas, yaitu:
AB+CD-*
Dalam hal ini pun rutan penlisan operator juga menentukan operasi mana
yang harus dikerjakan lebih dahulu. Beberapa contoh lain hasil konversi notasi
infix menjadi postfix.
Infix
A+B–C
(A + B) / (C * D $ E)
A – B / (C * D $ E)
Postfix
AB+C–
AB+CD-*
ABCDE$*/-
Algorima INFIX_KE_POSTFIX
Langkah 0 : Baca ungkapan dalan notasi infix, misalnya S; tentukan panjang
ungkapan tersebut. Misalnya N karakter; siapkan sebuah tumpukan kosong dan
siapkan derajat masing-masing operator, misalnya:$ berderajat 3, * dan /
berderajat 2, + dan – berdrajat 1 dan ( berderajat 0.
Langkah 1 : Dimulai dari 1=1 sampai N kerjakan langkah-langkah berikut:
a. R=S[I]
b. Test nilai R. Jika R adalah:
Operand
: langsung ditulis
Kurung buka
: push kedalam tumpukan

16. Kurung tutup
: pop dan tuis sema isi tumpukan sampai ujung
tumpukan =‟(„. Pop juga tanda „(„ ini, tetapi tidak
usahditulis.
: jika tumpuka kosong, atau derajat R lebih
tinggidbanding derajat ujung tumpukan, push
operator ke dalam tumpukan. Jika tidak, pop ujung
tumpukan dan tulis; kemudian ulangi pembandingan
R dengan ujung tumpukan, kemudian R di push.
Operator
Langkah 2 : Jika akhir notasi infix telah tercapai, dan tumpukan masih belum
kosong, pop semua isi tumpukan dan tulis hasilnya.
Untuk dapat memahami algoritma diatas ditulis menggunakan notasi infix
menjadi notasi postfix.
(A + B) / ( (C – D) * E $ F)
Ilustrasi pengubahan notasi infix diatas menjadi notasi postfi secara
lengkap tersaji dalam tabel berikut:
Proses
ke
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Karakter
dibaca
(
A
+
B
)
/
(
(
C
D
)
*
E
$
F
)
Isi
Tumpukan
(
+(
+(
Karakter
tercetak
Notasi postfix
Yang terbentuk
A
B
+
/
(/
((/
((/
-( ( /
-( ( /
(/
*( /
*( /
$*(/
$*(/
*( /
(/
/
A
AB
AB+
C
AB+C
D
-
AB+CD
AB+CD–
E
AB+CD–E
F
$
*
AB+CD–EF
AB+CD–EF$
AB+CD–EF$*
/
AB+CD–EF$*
Ujung tumpukan
Dari ilustrasi diatas dapat dilihat notasi posfix darii ungkapan:
(A + B) / ( (C – D) * E $ F)
adalah

17. AB+CD–EF$*/
Program konversi notasi infix menjadi notasi postfix disajikan sebagai
berikut.

20. Contoh hasil program diatas:
MENGUBAH NOTASI INFIX MENJADI POSTFIX
DENGAN MEMENFAATKAN STRUKTUR TUMPUKAN
Masukkan ungkapan infix: (A+B)/(C-D)
Ungkapan postfix: A B + C D - /
Akan mencoba lagi? Y(a)/T(idak): Y
Masukan ungkapan infix: ((A-B)/(C+D))/(A+C)*(B-D))
Ungkapan postfix: A B – C D + / A C + B D - * /
Akan mencoba lagi? Y(a)/T(idak): Y
Masukan ungkapan infix: (A+B) / ((C-D)* E $ F)
Ungkapan postfix: A B + C D – E F $ * /
Akan mencoba lagi? Y(a)/T(idak): T

21. BAB III
A. Kesimpulan
1. Stack adalah list yang operasi penyisipan dan penghapusan elemennya
dilakukan di satu ujung atau biasa juga disebut tumpukkan.
2. Stack dapat dideklarasikan dengan sebuah record yang mempunyai
elemen sebuah array data untuk menyimpan elemen stack dan sebuah
variabel top untuk menunjuk elemen stack teratas (top element).
3. Operasi pada stack adalah: Inisialisasi, push pop, size, empty, full.
B. Saran
1. Pelajarilah Stack dalam struktur data sebagai materi dalam sistem
pembelajaran.

22. DAFTAR PUSTAKA
1. SismoroHeri, Iskandar Kusrini. 2004 Struktur data dan Pemograman
dengan PASCAL.Yogyakarta: ANDI Yogyakarta.
2. Santosa, Insap. P. Ir. 1992 Struktur data menggunakan TURBO PASCAL
6.0 Yogyakarta : ANDI yogyakarta.