Makalah ini membahas tentang algoritma dan struktur data 'stack', menjelaskan pengertian, operasi dasar seperti push dan pop, serta implementasinya dalam pemrograman. Stack merupakan struktur data yang mengikuti prinsip Last In First Out (LIFO), di mana elemen hanya dapat ditambahkan dan dihapus dari satu ujung. Contoh penggunaan stack ditunjukkan melalui program yang membalik urutan kalimat dan angka.

1. MAKALAH
Algoritma dan Struktur Data
Tentang
“STACK”
Kelompok 2
1. RAMADHANI (1650401093)
2. WAHYU
3. KIRAN
4. WINDA
5. TIARA
DOSEN PEMBIMBING:
Lita Sari Muklis, M.Kom
FAKULTAS EKONOMI DAN BISNIS ISLAM
JURUSAN MANAJEMEN INFORMATIKA
INSTITUT AGAMA ISLAM NEGRI BATUSANGKAR
2017

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, 18 MEI
2017
Penulis,
Kelompok 2

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. Piring-piring 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.
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

6. 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. 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:

7. 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 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

8. 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 );
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:

9. 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 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

12. B. Definisi
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
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. Data-data dapat dimasukan
sekaligus dengan menuliskan beberapa angka dan dipisahkan dengan spasi. Setelah selesai

13. 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
Begin
Pop (X ,S ) ; write (X , ‘ ‘ ) ;
End ;
Writeln ;
Write (‘coba lagi dengan data yang lain (Y /N) ? [ ] ‘) ;
Gotoxy (wherex-2 , wherey) ; temp : = readkey
until upcase (temp) = ‘N’
End.

14. 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 Prefix
A + B + A B
A + B – C - + A B C
(A + B) * (C – D) * + A B – C D
A – B / (C * D $ E) - A / B * C $ D E
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:
[+ 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).

15. 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:
A B + C D - *
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 Postfix
A + B – C A B + C –
(A + B) / (C * D $ E) A B + C D - *
A – B / (C * D $ E) A B C D E $ * / -
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
Kurung tutup : pop dan tuis sema isi tumpukan sampai ujung tumpukan =’(‘.
Pop juga tanda ‘(‘ ini, tetapi tidak usahditulis.
Operator : 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.
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:

16. Proses
ke
Karakter
dibaca
Isi
Tumpukan
Karakter
tercetak
Notasi postfix
Yang terbentuk
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
(
A
+
B
)
/
(
(
C
-
D
)
*
E
$
F
)
(
+ (
+ (
/
( /
( ( /
( ( /
-( ( /
-( ( /
( /
*( /
*( /
$ * ( /
$ * ( /
*( /
( /
/
A
B
+
C
D
-
E
F
$
*
/
A
A B
A B +
A B + C
A B + C D
A B + C D –
A B + C D – E
A B + C D – E F
A B + C D – E F $
A B + C D – E F $ *
A B + C D – E F $ *
Ujung tumpukan
Dari ilustrasi diatas dapat dilihat notasi posfix darii ungkapan:
(A + B) / ( (C – D) * E $ F)
adalah
A B + C D – E F $ * /
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.