STACK (Tumpukan)

Tumpukan Koin Tumpukan Kotak

DEFINISI STACK
 Stack atau tumpukan adalah suatu struktur data yang
seolah-olah terlihat seperti data yang tersusun secara
‘menumpuk’, dimana ada data yang terletak diatas
data yang lainnya.

 Secara sederhana, tumpukan bisa diartikan sebagai suatu

kumpulan data yang seolah-olah ada data yang diletakan diatas
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).

Stack S terdiri dari n elemen

S = ( ao , a1 , … , ai , ai+1 , …, an-1 )

Elemen paling bawah Elemen paling atas TOP

ILUSTRASI STACK
 Gambar dibawah menunjukkan
bahwa dalam tumpukan hanya
 Dari gambar di bawah kita
bisa menambah atau mengambil
bisa mengatakan bahwa
sebuah kotak lewat satu ujung,
kotak B ada diatas kotak A
yaitu ujung bagian atas
dan ada dibawah kotak C.

Maximum
Isi [5]
D 4

3 Isi [4]
C 2 Isi [3]
B 1 Isi [2]

0 Isi [1]
A
Stack S
Pengertian STACK
 STACK berarti tumpukan.
 Konsep STACK digunakan dalam struktur
data.
IN OUT

TOP D

C Berlaku prinsip
LIFO (Last In First Out)
B

A
STACK (TUMPUKAN)
 Stack Termasuk ADT (Abstrak Data Type)
 Bentuk khusus dari Ordered List
 Struktur data linier dimana hanya bagian TOP-nya saja yang bisa
diakses.
 Bisa diimplementasikan menggunakan array atau Linked List.
 Bersifat LIFO: Last In First Out, berarti benda yang terakhir masuk
ke dalam stack akan menjadi yang pertama keluar dari stack.
 Operasi pada Stack :
 IsFull : mengecek apakah STACK sudah penuh
 IsEmpty : mengecek apakah STACK sudah kosong
 Push : menambahkan item pada posisi paling atas (TOP).
 Pop : mengeluarkan item pada posisi paling atas (TOP).
 Clear : digunakan untuk mengosongkan stack
 Print : Mencetak stack
Jenis Stack
Single Stack: dapat direpresentasikan
STACK ada 2 jenis : 
menggunakan array satu dimensi.
 Single Stack Gambar di bawah ini adalah gambaran
single stack.
 Double Stack

0 1 2 3 4 5 6 7 8 9
S[10] 25 12 17 15 33

TOP

4 33

TOP X
Konsep dan Proses Single Kondisi Single Stack
Stack

 Prinsip proses Single Stack  Kondisi Stack ditentukan oleh

adalah : posisi atau isi TOP.
LIFO (Last In First Out)
Kondisi Posisi TOP
 Proses pada Single Stack :
 AWAL (Inisialisasi)
Stack
 PUSH (Insert, Masuk, KOSONG Top = -1
Simpan, Tulis) PENUH Top = n-1
 POP (Delete, Keluar,
Ambil, Baca/Hapus) BISA DIISI Top < n-1
ADA ISINYA Top > -1
PENGGUNAN STACK
 History pada web browser.
 Undo Log pada text editor.
 Pemrosesan struktur bersarang (nested) :
loop, rekursi, fungsi, dll.
 Algoritma back tracking – Artificial
Intelegence.
STACK WITH ARRAY OF STRUCT
1. Definisikan Stack dengan menggunakan  Buatlah variabel array data (tumpuk)
struct/record (Elemen struct Stack adalah sebagai implementasi struct Stack.
array data dan top untuk menadakan posisi
data teratas). Contoh deklarasi STACK
dengan struct dan array data: Deklarasi/buat variabel stack dari struct
STACK tumpuk; // tumpuk: STACK
typedef struct STACK{ // STACK=record
int top; // top: integer;  Deklarasikan operasi-operasi/ function di
int data[10]; // data: array of int atas dan buat implemetasinya.
}; //end Fungsi Push ()
Fungsi Pop ()
2. Definisikan konstanta MAX_STACK untuk Fungsi IsFull ()
menyimpan maksimum isi stack. Contoh
deklarasi MAX_STACK: Fungsi IsEmpty ()
Fungsi Clear ()
#define MAX_STACK 10 Fungsi Print ()
(Keterangan: //ConstMax_Stack=10)
 INISIASI STACK Void inisialisasi ()
{
tumpu,top=-1
 Pada mulanya isi top dengan - }
1, karena array dalam bahasa
C/C++ dimulai dari 0, berarti
bahwa data stack adalah  MAX _ STACK
4
KOSONG! (dalam Pascal isi
top dengan 0). 3
 Top adalah variabel penanda 2
dalam Stack yang
menunjukkan elemen teratas 1
data Stack sekarang.
0
 Top Of Stack akan selalu
bergerak hingga mencapai TO P = - 1
MAX of STACK sehingga
menyebabkan stack PENUH!
Ilustrasi Stack pada saat inisialisasi!
FUNGSI PUSH
Digunakan untuk memasukkan elemen  Algoritma PUSH
ke stack, Data yang diinputkan selalu
menjadi elemen teratas Stack (yang if (Top < n-1)
ditunjuk oleh To S) { Top = Top + 1;
S[Top] = x;
Dengan cara:
}
1) Jika data belum penuh: else
 Tambah satu (increment) nilai top cout<<“Stack Penuh”;
of stack lebih dahulu setiap kali
ada penambahan ke dalam array
data Stack.
 Isikan data baru ke stack  Algoritma PUSH dalam c
berdasarkan indeks top of stack
yang telah diincrement (ditambah) def push (data )
sebelumnya. if @top == @maxsize-1 #stack is full
2) Jika tidak, outputkan “Penuh” printf("\nERROR: the stack is full!");
else
@top = @top + 1;
@items[@top] = data;
printf("\nPUSH SUCCEED");
end
end
ILUSTRASI PUSH
 Operasi Push adalah menambah void Push(char d[10])
elemen kedalam stack S, dimana {
penambahan dapat dilakukan tumpuk.top++;
jika stack itu belum penuh. strcpy (tumpuk.data
[tumpuk.top],d);
 Stack dikatakan penuh Jika }
posisi Top sudah berada pada
posisi n, (If s.top = n then stack
penuh)

 MAX _ STACK
Pada mulanya:
4
TOP = -1 3 PUSH ELEMEN Radio

Selanjutnya 2 Radio
Top = Top+1=2
TOP = TOP+1
= -1 +1 1 VCD Jika Top mula-mula=1
=0 0 TV
Push( x,s) adalah Memasukkan x kedalam Stack S

PUSH(X,S)
Procedure Push(x :Tipe
data, s : stack)
If s.top< n then
s.top= s.top+1
s.isi[s.top] = x
Else
stack sudah penuh top = 0

Endif

stack s
PUSH(X,S)
Procedure Push(x :Tipe
data, s : stack)
If s.top< n then
s.top = s.top + 1
s.isi[s.top] = x
top = 1
Else
stack sudah penuh
endif

stack s
PUSH(X,S)
Procedure Push(x :Tipe
data, s : stack)
If s.top< n then
s.top= s.top+1
s.isi[s.top] = k
top = 1
Else
stack sudah penuh
endif

stack s
PUSH(X,S)
Procedure Push(x :Tipe
data, s : stack)
If s.top< n then
s.top = s.top + 1 top = 2
s.isi[s.top] = x
Else
stack sudah penuh
endif

Stack s
PUSH(X,S)
Procedure Push(x :Tipe
data, s : stack)
If s.top< n then
s.top= s.top+1 top = 2

s.isi[s.top] = k
Else
stack sudah penuh
endif

stack s
PUSH(X,S)
Procedure Push(x :Tipe
data, s : stack)
top = 3
If s.top< n then
s.top = s.top + 1
s.isi[s.top] = x
Else
stack sudah penuh
endif

stack s
PUSH(X,S)
Procedure Push(x :Tipe
data, s : stack)
top = 3
If s.top< n then
s.top= s.top+1
s.isi[s.top] = k
Else
stack sudah penuh
Endif

stack s
PUSH(X,S) top = 5

Procedure Push(x :Tipe

data, s : stack)
If s.top< n then
s.top= s.top+1
s.isi[s.top] = k
Else
stack sudah penuh
Endif

stack s
FUNGSI POP
 Algoritma POP
 Digunakan untuk mengambil/ menghapus
elemen yang berada pada posisi paling if (Top > -1)
atas dari stack. { x = S[Top];
Top = Top - 1;
}
Dengan cara : else
1) Tampilkan terlebih dahulu nilai cout<<“Stack Kosong”;
elemen teratas stack dengan mengakses
TOP of STACK (indeknya).
2) Baru dilakukan decrement nilai TOP of  Function POP dalam C
STACK, sehingga jumlah elemen stack
void Pop()
berkurang 1. {
printf("Data yang di POP = %s\n",
Fungsi Peek tumpuk.data[tumpuk.top]);
tumpuk.top--;
Digunakan untuk melihat top of stack: }

int peak{
Return tumpuk.data[tumpuk.top];
}
POP(S)
 Pop(s) adalah menghapus elemen dari
 Setiap melakukan penghapusan, maka
stack, elemen yang dihapus adalah posisi yang paling atas akan berkurang 1
elemen terakhir masuk (LIFO=Last (s.top = s.top -1)
In First Out)
 Proses penghapusan dapat dilakukan Procedure Pop( s: stack)
jika stack tidak dalam keadaan If s.top>0 then
Kosong. (If s.top > 0 then stack tidak Write s.isi[s.top]
kosong) s.top= s.top – 1
Else
stack Kosong
endif
POP(S) atas = 5

Procedure Pop( s: stack)

If s.atas>0 then
Write s.isi[s.atas]
s.atas= s.atas – 1
Else
stack kosong
Endif

stack s
POP(S)
Procedure Pop( s: stack) atas = 4

If s.atas>0 then
Write s.isi[s.atas]
s.atas= s.atas – 1
Else
stack kosong
Endif

stack s
POP(S)
Procedure Pop( s: stack)
If s.atas>0 then atas = 3
Write s.isi[s.atas]
s.atas= s.atas – 1
Else
stack kosong
Endif

stack s
POP(S)
Procedure Pop( s: stack)
If s.atas>0 then
Write s.isi[s.atas]
s.atas= s.atas – 1
Else
stack kosong
endif atas = 0

stack s
 Fungsi IsFull Fungsi IsEmpty
 Untuk memeriksa apakah stack sudah
penuh?
 Untuk memeriksa apakah stack masih
kosong?
 Dengan cara memeriksa TOP of Stack.
Jika TOP of STACK = MAX_STACK-1
 Dengan cara memeriksa top of stack,
maka FULL (Penuh). Jika TOP of jika masih -1 maka berarti stack
STACK < MAX_STACK-1 maka belum masih kosong!
penuh.

int IsFull() int IsEmpty()

{ {
if(tumpuk.top == MAX_STACK-1) if(tumpuk.top == -1)
return 1; return 1;
else return 0; else return 0;
} }

Ilustrasi Stack pada kondisi Full

 Fungsi Print Fungsi CLEAR
 Digunakan untuk mengosangkan stack/
 Untuk menampilkan semua elemen-
elemen data Stack membuat stack hampa sehingga kembali di
 Dengan cara looping semua nilai array posisi Top=-1
secara terbalik, karena kita harus
mengakses dari indeks array tertinggi Void clear ()
terlebih dahulu baru ke indeks yang {
kecil! tumpuk.data=tumpuk.top=-1;
void TampilStack() printf(“Data clear”);
{ }
for(int i=tumpuk.top;i>=0;i--)
{
printf("Data : %s\n",tumpuk.data[i]);
}
}

4  MAX _ STACK
Jika kita ingin mengeprint elemen
3 stack, kita harus membaca elemen
Array dari indeks yang ada isinnya
2 Radio  Top
tertinggi, yaitu Top down to 0
1 VCD
Sehingga kita akan menampilkan
0 TV elemen: Radio, VCD dan TV.
PSEUDOCODE STACK
Algoritma Stack
{algoritma stack / tumpukan} procedure
createEmpty(input/output s :
Deklarasi stack)
type NilaiKuliah = record <
nama : string Deklarasi
nilai : integer {tidak ada}
>
Deskripsi
const MAX = 10 s.top  -1
type stack = record <
top : integer
data : array [1 .. MAX] of NilaiKuliah function isEmpty (input s : stack)  boolean
>
St : stack Deklarasi
hasil : boolean
Deskripsi
procedure createEmpty(input/output s : stack) hasil  false
function isEmpty (input s : stack)  boolean
function isFull(input s : stack)  boolean if s.top=-1 then
procedure push(input nama : string, input nilai hasil true
:integer , input/output end if
s : stack)
procedure pop (input/output s: stack) return hasil
procedure printStack (input s: stack)
 PSEUDOCODE STACK
procedure pop (input/output s: stack)
function isFull(input s : stack)  boolean {menghapus elemen di dalam stack}
Deklarasi Deklarasi
hasil : boolean {tidak ada}
Deskripsi Deskripsi
hasil  false if s.top = 1 then
if s.top=MAXthen s.top  -1
hasil true else
end if if s.top <> -1 then
return hasil s.top  s.top – 1
else
write(‘Stack Kosong’)
procedure push(input nama : string, input
nilai :integer , input/output s : stack) endif
{menambah elemen di dalam stack} end if
Deklarasi
{tidak ada} procedure printStack (input s: stack)
Deskripsi {Menampilkan isi Stack ke layar}

if isFull(S) =TRUE then Deklarasi

write(‘STACK PENUH’) i : integer
else Deskripsi
if isEmpty (S) =TRUE then
s.top  1 if s.top = -1 then
s.nama[1]  nama write (‘STACK KOSONG’)
s.nilai[1]  nilai else
else for i1 to s.top do
s.top  s.top + 1 write(‘elemen ke- ’,i)
s.nama[s.top]  nama write(‘NAMA’ , s.data[i].nama)
s.nilai[s.top]  nilai write(‘NILAI’ , s.data[i].nilai)
endif endfor
end if end if
PROGRAM LENGKAP STACK DENGAN C
#include <stdio.h> int main()
#include <conio.h> {
#include <string.h> int pil;
#define MAX_STACK 10 inisialisasi();
char dt[10];
typedef struct STACK { int top; do{ printf("1. push\n");
char data[10][10]; printf("2. pop\n");
}; printf("3. print\n");
STACK tumpuk; printf("4. clear\n");
printf("5. exit\n");
void inisialisasi() printf("Pilihan : ");
{ tumpuk.top = -1;} scanf("%d",&pil);
switch(pil)
int IsFull() {
{ if(tumpuk.top == MAX_STACK-1) return 1; case 1: if(IsFull() != 1)
else return 0;} { printf("Data = ");scanf("%s",dt);
Push(dt); }
int IsEmpty() else printf("\nSudah penuh!\n");
{ if(tumpuk.top == -1) return 1; else return 0;} break;
case 2: if(IsEmpty() != 1)
void Push(char d[10]) Pop();
{ tumpuk.top++; else
strcpy(tumpuk.data[tumpuk.top],d); } printf("\nMasih kosong!\n");
break;
void Pop() case 3: if(IsEmpty() != 1)
{ printf("Data yang terambil = %s\ TampilStack();
n",tumpuk.data[tumpuk.top]); else
tumpuk.top--; } printf("\nMasih kosong!\n");
break;
void Clear() case 4: Clear();
{ tumpuk.top=-1; } printf("\nSudah kosong!\n");
break;
void TampilStack() }
{ for(int i=tumpuk.top;i>=0;i--) getch();
{ printf("Data : %s\n",tumpuk.data[i]); } } while(pil != 5);
} getch();
}
Double Stack
 Disebut juga Stack Ganda.

Double STACK : menggunakan 2 ujung STACK utk PUSH maupun POP

Konsep dan Proses Double Stack

 Prinsip proses :
LIFO (Last In First Out) baik
untuk Stack1 maupun untuk Kondisi Double Stack
Stack2
Kondisi Stack Posisi TOP
 Proses pada Double Stack : Stack1 KOSONG Top1 = -1
 AWAL (Inisialisasi) Stack2 KOSONG Top2 = n
 PUSH1 (Push untuk Stack PENUH (baik Stack1 Top2 – Top1
Stack1) maupun Stack2 tidak BISA DIISI) =1
 POP1 (Pop untuk Stack1) Stack BISA DIISI (baik Stack1 Top2 – Top1
 PUSH2 (Push untuk maupun Stack2 BISA DIISI) >1
Stack2) Stack1 ADA ISINYA Top1 > -1
 POP2 (Pop untuk Stack2) Stack2 ADA ISINYA Top2 < n
Algoritma PUSH1 (mengisi Stack1) dan
Algoritma PUSH2 (mengisi Stack 2)
 Periksa apakah Stack1 BISA  Periksa apakah Stack2 BISA
DIISI DIISI

if (Top2 – Top1 > 1) if (Top2 – Top1 > 1)

{ Top1 = Top1 + 1;
S[Top1] = x; { Top2 = Top2 - 1;
}
S[Top2] = x;
else
cout<<“Stack Penuh”; }
else
cout<<“Stack Penuh”;
Algoritma POP1 (mengambil isi Stack1)
dan Algoritma POP2 (mengambil isi
Stack2)
 Periksa apakah Stack1 ADA  Periksa apakah Stack2 ADA
ISINYA ISINYA

if (Top1 > -1) if (Top2 < n)

{ x = S[Top1]; { x = S[Top2];
Top1 = Top1 - 1; Top2 = Top2 + 1;
} }
else else
cout<<“Stack Kosong”; cout<<“Stack Kosong”;
Contoh Penggunaan Stack

1. Untuk mencek kalimat Polindrom

2. Untuk ungkapan Aritmatika (membuat
kalkulator)
3. Untuk Mengubah Desimal ke Biner
Mencek Kalimat Polindrom
Operasi Push Operasi POP
K K Hasil =‘’
A A A A Hasil = K
Hasil = KA
K K K K K K
A Hasil = KAK
A A A A A A A
K K Hasil = KAKA
K K K K K K K K Hasil = KAKAK

Kalimat : KAKAK

Kalimat = hasil  Polindrom

Algoritma
Inisialisasi Struktur Data //modul utama
Stack = record i=1
isi : Array[1..255] of char While i<= length(kalimat)
atas : integer Do
End
Kalimat, Hasil : string Push(Kalimat[i],s)
i=i+1
Procedure push( x : Char, s : Stack) End-while
If s.atas < 255
Then
s.atas = s.atas+1 While S.atas>0 do
s.isi[s.atas] = x
Else pop(s)
stack sudah penuh End-while
End if

Procedure Pop(S:Stack) If kalimat = hasil

If S.atas>0 then Then
Write s.isi[s.atas] Polindrom
Hasil = hasil +s.isi[s.atas] Else
s.atas= s.atas-1 Tidak polindrom
Else End If
Stack Kosong
End If
 UNGKAPAN ARITMATIKA
Untuk menuliskan ungkapan Contoh :
aritmatika dapat dilakukan dengan
tiga metode: Infix Prefix Postfix

Infix  Operan Operator Operan +AB + C AB+ +C

A+B+
A+B C
Prefix  Operator Operan Operan ++ABC AB+C+
+AB
A+*BC A+ BC*
Postfix  Operan Operan Operator
A+B * C
AB+
+A*BC ABC*+
Derajat Operator
1. (..)
2. ^ Operator Logika :
3. * dan / 1. NOT
2. AND
4. + dan - 3. OR
EKSPRESI ARITMATIKA
 Ekspresi aritmatika umumnya
ditulis dalam bentuk infix.
Contoh:
A+B, A-C+B, A+((B*C)/D)
 Komputer lebih mudah
mengevaluasi ekspresi postfix,
karena tidak perlu
mengelompokkan subekspresi
kedalam tanda kurung.

Infix Postfix Prefix

A*B AB* *AB
A*(B+C) ABC+* *A+BC
(A*B)+C AB*C+ +*ABC
A+((B*C)/D) ABC*D/+ +A/*BCD
(A^2+B^2)*(C-D) A2^B2^+CD-* *+^A2^B2-CD
ALGORITMA MENGUBAH EKSPRESI INFIX MENJADI POSTFIX DAN PSEUDOCODE NYA

String infix, postfix

Proses konversi ekspresi infix menjadi
s = stack kosong
bentuk postfix selalu dimulai dari String infix, postfix
while (seluruh infix belum dibaca)
s = stack kosong
sebelah kiri ekspresi aritmatik. {while (seluruh
baca simbol infix belum
selanjutnya dibaca)
pada infix (symb)
{ baca
if symb adalah operand tambahkaninfix
simbol selanjutnya pada pada (symb)
postfix
1) Jika yang ditemukan adalah operan, if symb adalah operand
else iftambahkan
symb adalah pada
‘(‘, ‘{‘, ‘[‘ PUSH symb
postfix
maka cetak atau simpan
else
else if symb
if symb adalah
adalah ‘)‘, ‘}‘,‘(‘,
‘]‘ ‘{‘, ‘[‘ PUSH symb
2) Jika yang ditemukan adalah kurung else
while(TopOp stack adalah‘}‘,
if symb adalah ‘)‘, ‘]‘
operator)
while(TopOp stack adalah operator)
buka maka abaikan. POP POP stackdan
stack dan tambahkan
tambahkan keke postfix
postfix
POP stack
POP stack
3) Jika yang ditemukan adalah else if symb adalah operator{
else if symb adalah operator{
if stack kosong PUSH symb ke stack
operator maka push ke dalam stack. ifelse{
stack kosong
TopOp PUSH
=bacasymb datakedistack
TOP stack
if(symb>TopOp)
else{ TopOp =baca data di TOP PUSH symb ke stack
stack
4) Jika yang ditemukan adalah kurung else if TopOp adalah ‘(‘, ‘{‘, ‘[‘
if(symb>TopOp) PUSH symb ke stack
tutup maka pop stack, kemudian PUSH symb ke stack else {
else ifPOP
TopOpstack
adalah ‘(‘, ‘{‘, ‘[‘
cetak atau simpan nilainya. dan PUSH
tambahkan
symb kepada stack postfix else {
PUSH symb ke stack }
5) Jika ekspresi telah diperiksa semua }
POP stack dan tambahkan pada postfix
tetapi ternyata stack belum kosong, }
} PUSH symb ke stack }
pop semua data dalam stack dan if stack tidak } kosong
POP stack dan tambahkan ke postfix
cetak atau simpan nilai yang di pop. }
}
if stack tidak kosong
POP stack dan tambahkan ke postfix
STACK UNTUK KONVERSI INFIX KE POSTFIX
Algoritma
Langkah 0: Inisialisasi struktur data dengan membuat sebuah
stack kosong, baca ungkapan dalam bentuk infix,
dan tentukan derajat operator misalnya
( : 0 ; + & - : 1;* & / : 2;^ : 3
Langkah 1: Lakukan pembacaan karakter dari Infix, berikan ke R
Langkah 2: Test Nilai R, Jika
a. ( Langsung di Push
b. Operand, Langsung di Tulis
c. ) lakukan Pop sampai ketemu buka kurung , tetapi
tanda kurung tidak perlu di tulis.
d. Operator, Jika stack dalam keadaan kosong atau
derajat R lebih tinggi dibandingkan dengan di ujung
stack, lakukan Push, jika tidak lakukan POP.
Langkah 3: Jika pembacaan terhadap infix sudah selesai,
namun stack belum kosong lakukan POP.
STUDI KASUS INFIX TO POSTFIX
Diketahui ekspresi infix spt
dibawah ini
15*(((3-2)*(4+10))/7)
1.Proses dimulai dari
sebelah kiri, pertama kali
nilai yang ditemukan yaitu
angka 15, maka aturan
nomor 1 dijalankan, yaitu
nilai dicetak ke layar.
2. Ditemukan operator * maka aturan
ke 3 dikerjakan, yaitu push operator
tersebut ke dalam stack.
3. 15*(((3-2)*(4+10))/7), Selanjutnya
kurung buka ( ditemukan, aturan
nomor 2 dikerjakan yaitu abaikan
tanda kurung buka tersebut.
Pengabaian tanda kurung ini
dilakukan 3 kali karena di temukan 3
buah tanda kurung buka.
4. Kemudian 15*(((3-2)*(4+10))/7). 6. Lanjut, ditemukan angka 2
Ditemukan bilangan 3 (operan) (operan) maka aturan nomor 1
maka aturan nomor 1 dikerjakan dikerjakan yaitu mencetak
yaitu mencetak bilangan 3 angka 2 ke layar.
tersebut ke layar.

7. Lalu 15*(((3-2)*(4+10))/7),
5. Proses selanjutnya, ditemukan ditemukan tanda kurung tutup )
operator - maka aturan ke 3 sehingga aturan ke 4
dikerjakan, yaitu push operator dikerjakan yaitu pop stack dan
tersebut ke dalam stack. cetak data paling atas stack ke
layar.
8. Proses kita lanjutkan, dan
ditemukan operator * maka
aturan ke 3 dikerjakan, yaitu
push operator tersebut ke
dalam stack.
9. 15*(((3-2)*(4+10))/7), kurung
buka ( ditemukan, jadi abaikan
saja. Selanjutnya kita temukan
angka 4 (operan) maka aturan
nomor 1 dikerjakan yaitu
mencetak bilangan 4 tersebut
ke layar.
10. Proses kita lanjutkan, dan
ditemukan operator +, maka aturan
ke 3 dikerjakan, yaitu push operator
tersebut ke dalam stack.
11. 15*(((3-2)*(4+10))/7), Ditemukan
bilangan 10 (operan) maka aturan
nomor 1 harus dikerjakan yaitu
mencetak angka 10 ke layar.
12. Kemudian tanda kurung
tutup ) kita temukan sehingga
aturan ke 4 harus dikerjakan yaitu
pop stack dan cetak data paling
atas stack (operator +) ke layar.
14. Proses kita lanjutkan, dan
kita menemukan operator /
maka aturan ke 3 dikerjakan,
yaitu push operator tersebut ke
dalam stack.

15. 15*(((3-2)*(4+10))/7), kita

13. 15*(((3-2)*(4+10))/7), Satu lagi temukan bilangan 7 (operan)
tanda kurung tutup ) kita temukan, maka aturan nomor 1
sehingga aturan ke 4 dikerjakan. dikerjakan yaitu mencetak
bilangan 7 tersebut ke layar.
16. 15*(((3-2)*(4+10))/7), Kemu-
dian ditemukan tanda kurung
tutup ), maka aturan ke 4
dikerjakan yaitu pop stack dan
cetak data paling atas stack ke
layar.
17. Karena ekspresi sudah
diperiksa semua sementara
stack masih belum kosong
maka aturan ke 5 harus di
kerjakan yaitu pop semua data
dalam stack dan cetak ke layar.
ALGORITMA MENGHITUNG NILAI
EKSPRESI POSTFIX
 Untuk menghitung nilai ekspresi aritmatik, maka ekspresi infix harus
diubah terlebih dahulu menjadi bentuk ekspresi postfix.
 Berikut algoritma untuk menghitung nilai ekspresi postfix:
1) Jika yang ditemukan adalah operan, maka push operan tersebut
ke dalam stack.
2) Jika yang ditemukan adalah operator, pop stack dua kali dan
hitung menggunakan nilai yang di pop dan operator yang
dijumpai. Hasil perhitungan ini kemudian di push kembali ke
dalam stack.
3) Jika ekspresi telah diperiksa semua maka nilai yang di pop
terakhir dari stack adalah jawaban dari ekspresi aritmatik
tersebut.
 Perhatikan contoh berikut. Jika telah diperoleh ekspresi postfix
berikut ini:
15 3 2 - 4 10 + * 7 / *
 STUDI KASUS MENGHITUNG NILAI EKSPRESI POSTFIX

15 3 2 - 4 10 + * 7 / * 3. Selanjutnya 15 3 2 - 4 10 + * 7 /, ditemukan kembali

operan dengan nilai 2, maka aturan nomor 1 dikerjakan
1. Dimulai dari sebelah kiri, ditemukan lagi, yaitu push nilai tersebut ke dalam stack.
pertama sekali adalah nilai 15 (operan)
maka aturan nomor 1 dijalankan, yaitu
push nilai tersebut ke dalam stack.

4. Proses di lanjutkan 15 3 2 - 4 10 + * 7 / *, di temukan

2. Kemudian ditemukan kembali operator – , sehingga aturan nomor 2 dikerjakan, yaitu
operan dengan nilai 3, maka aturan pop stack dua kali dan hitung menggunakan nilai yang di
nomor 1 dikerjakan lagi, yaitu push nilai pop dan operator yang dijumpai. Hasil perhitungan ini
tersebut ke dalam stack. kemudian di push kembali ke dalam stack.

Note: Urutan perhitungan harus 3–2 bukan 2–3 atau data yang kedua
yang di pop di kurang data yang pertama sekali di pop dari stack.

5. Ditemukan operan dengan
nilai 4, maka aturan nomor 1
dikerjakan lagi, yaitu push
nilai tersebut ke dalam stack.
15 3 2 - 4 10 + * 7 / *
6. Ditemukan operan dengan
nilai 10, maka aturan nomor
1 dikerjakan, yaitu push nilai
tersebut ke dalam stack.
15 3 2 - 4 10 + * 7 / *
7. Proses dilanjutkan, ditemukan operator + oleh
karena itu aturan nomor 2 harus dikerjakan. pop
stack dua kali dan hitung menggunakan nilai
yang di pop dan operator yang dijumpai. Hasil
perhitungan ini kemudian dipush kembali ke
dalam stack.
15 3 2 - 4 10 + * 7 / *
8. Di temukan lagi operator * oleh karena itu
aturan nomor 2 dikerjakan. pop stack dua kali
dan hitung menggunakan nilai yang di pop dan
operator yang dijumpai. Hasil perhitungan ini
kemudian di push kembali ke dalam stack.
15 3 2 - 4 10 + * 7 / *
9. Selanjutnya ditemukan kembali
operan dengan nilai 7, maka
aturan nomor 1 dikerjakan lagi,
yaitu push nilai tersebut ke dalam
stack.

15 3 2 - 4 10 + * 7 / *
10. Kemudian kita temukan operator *,
maka aturan nomor 2 dikerjakan lagi.

15 3 2 - 4 10 + * 7 / *

10. Proses kita lanjutkan lagi, dan

sekarang kita temukan operator /
oleh karena itu aturan nomor 2
harus dikerjakan. pop stack dua
kali dan hitung menggunakan
nilai yang dipop dan operator
yg dijumpai. Hasil perhitungan
ini kemudian di push kembali ke
dalam stack.
Karena ekspresi postfix telah diperiksa
semua dan bila data dalam stack sudah
di pop maka nilai 30 diperoleh, maka
dapat disimpulkan bahwa ekspresi infix:
15 * ( ( ( 3 - 2 ) * ( 4 + 10 ) ) / 7 ) = 30
LATIHAN SOAL STACK
1. Operasi Stack yang digunakan
untuk memeriksa apakah stack
sudah penuh, adalah …..
a. PUSH c. ISEMPTY
b. POP d. ISFULL
2. Menambah satu (increment) nilai
TOP of STACK setiap ada
penambahan elemen stack
selama stack masih belum
penuh, merupakan langkah awal
pada operasi STACK yaitu …..
a. PUSH c. ISEMPTY
b. POP d. ISFULL
3. Jika pada stack terdapat kondisi TOP of
STACK = MAX_STACK - 1 maka stack
berada dalam keadaan ...
a. ISEMPTY c. RETREIVE
b. CLEAR d. FULL
4. Pada saat awal, Top of Stack selalu bernilai :
a. Top = 0 c. Top = Max_Stack
b. Top = 1 d. Top = -1
5. Diberikan perintah/instruksi pada program C+
+, yaitu tumpuk.top++; Maksud dari
perintah/instruksi tersebut adalah ….
a. Top = Top + 1 c. Top = - 1
b. Top = Top - d. Top = 1
Terimakasih