TUMPUKAN (STACK)

Oleh :
Dahlan Susilo

Universitas Sahid Surakarta

Maret 2023
 Pengertian STACK
• Struktur data pada umumnya berisi kumpulan
terurut dari elemen.
• Jumlah elemen di dalam list dapat berubah-ubah.
• Linier list A yang terdiri dari T elemen pada
waktu t, dinotasikan sebagai : A = [ A1, A2, ...,
AT]
• Jika T = 0, maka A disebut “Empty List” atau
“Null List”
• Elemen dapat dihapus dari posisi dalam tumpukan,
dan dapat pula dimasukkan elemen baru sebagai
anggota tumpukan.

Contoh :
1. File, dengan elemennya berupa record
2. Buku telepon
3. Stack
4. Queue
5. Linear link list
 Definisi STACK
Suatu struktur data yang seolah-olah
terlihat seperti data yang tersusun secara
‘menumpuk’, dimana ada data yang
terletak di atas data yang lainnya.
 OPERASI STACK
Bersifat LIFO (Last In First Out), berarti data yang
masuk terakhir akan keluar pertama.
Operasi pada Stack :
 IsFull : mengecek apakah STACK sudah penuh
 IsEmpty : mengecek apakah STACK sudah kosong
 Init : mengaktifkan STACK
 Push : menambah data pada STACK
 Pop : mengambil data pada STACK
 Print : mencetak STACK
 Clear : mengosongkan STACK
 KONDISI SINGLE STACK
• Kondisi Stack ditentukan oleh posisi atau
isi TOP.
Kondisi Stack Posisi TOP
KOSONG Top = -1
PENUH Top = n-1
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
 • Dari gambar di samping
kita bisa mengatakan
bahwa kotak B ada di atas
D kotak A dan ada di bawah
C kotak C.
• Gambar di samping
B menunjukkan bahwa dalam
tumpukan, kita hanya bisa
A menambah atau
mengambil sebuah kotak
lewat satu ujung, yaitu
ujung bagian atas
 • Gambar dibawah hanya menunjukkan dalam tumpukan hanya
bisa menambah atau mengambil sebuah kotak lewat satu
ujung, yaitu ujung bagian atas

Deklarasi Struktur Data

Maximum Stack = Record
4 Isi [5]
Isi : array[1..n] of Tipe Data
3 Isi [4]
Atas : integer
2 Isi [3]
Status : boolean
1 Isi [2]
End
0 Isi [1]

Stack S
 STACK WITH ARRAY
• Definisikan Stack dengan menggunakan
suatu struct
• Definisikan konstanta MAX_STACK untuk
menyimpan maksimum isi stack
• Elemen struct Stack adalah array data dan
top untuk menadakan posisi data teratas
• Buatlah variabel tumpuk sebagai
implementasi dari struct Stack
• Deklarasikan operasi-operasi/function di
atas dan buat implemetasinya
 PROGRAM STACK
• Contoh deklarasi MAX_STACK
#define MAX_STACK 10
• Contoh deklarasi STACK dengan struct dan
array data
typedef struct STACK{
int top;
int data[10];
int status
};
• Deklarasi/buat variabel dari struct
STACK tumpuk;
 Program Stack (2)
Inisialisasi Stack
• Pada mulanya isi top dengan -1, karena array dalam
bahasa C dimulai dari 0, yang berarti bahwa data stack
adalah KOSONG!
• Top adalah suatu variabel penanda dalam Stack yang
menunjukkan elemen teratas data Stack sekarang.
• Top Of Stack akan selalu bergerak hingga mencapai
MAX of STACK yang menyebabkan stack PENUH!
• Status diisi TRUE
 Inisialisasi stack
9 Max_Stack
8
7
6
5
4
3
2
1
0 Top = -1
Status=1
Ilustrasi Stack pada saat inisialisasi!
Operasi Push adalah menambah elemen kedalam
stack S, dimana penambahan dapat dilakukan jika
stack itu belum penuh.
Stack dikatakan penuh Jika posisi Top sudah
berada pada posisi n
(If s.top = n then stack penuh)
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
top = 0
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] = 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
Write (“stack sudah penuh”)
Endif
stack s
 POP(s)
• Pop(s) adalah menghapus elemen dari stack, elemen yang
dihapus adalah elemen terakhir masuk (LIFO=Last In First
Out) proses penghapusan dapat dilakukan jika stack tidak
dalam keadaan Kosong

• If s.top > 0 then stack tidak kosong

• Dimana setiap melakukan penghapusan, maka posisi yang
paling atas akan berkurang 1 (s.top = s.top -1)

Procedure Pop( s: stack)

If s.top>0 then
Write (s.isi[s.top])
s.top= s.top – 1
Else
Write(“stack Kosong”)
endif
 lanjut
• Untuk mengambil data stack yang terletak paling
atas (data yang ditunjuk oleh ToS), tampilkan
terlebih dahulu nilai elemen teratas stack
dengan mengakses indeksnya sesuai dengan
top of stacknya, baru dilakukan di-decrement
nilai top of stacknya sehingga jumlah elemen
stack berkurang.
 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) atas = 3

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
Write s.isi[s.atas]
s.atas= s.atas – 1
Else
atas = 0
stack kosong
endif
stack s
 Fungsi IsFull
• Untuk mengetahui stack sudah penuh

• Dengan membaca top of stack, jika

sudah sama dengan MAX_STACK-1
maka full, jika belum (masih lebih kecil
dari MAX_STACK maka belum full
 lanjut
Ilustrasi Stack pada kondisi Full
Max_Stack
9 HARDISK
Top
8 MOUSE
7 SPEAKER
6 MEJA
5 KEYBOARD
4 LAPTOP
3 PRINTER
2 MONITOR
1 VCD
0 TV
 Fungsi IsEmpty
• Untuk memeriksa apakah data Stack
masih kosong
• Dengan cara memeriksa top of stack,
jika masih -1 maka berarti data Stack
masih kosong!
 lanjut
• Data yang diinputkan selalu menjadi
elemen teratas Stack (yang ditunjuk oleh To
S)
• Jika data belum penuh
– Tambah satu (increment) nilai top of stack lebih
dahulu setiap kali ada penambahan ke dalam
array data Stack.
– Isikan data baru ke stack berdasarkan indeks
top of stack yang telah di-increment
sebelumnya.
• Jika tidak, outputkan “Penuh”
lanjut
 Fungsi Print
• Untuk menampilkan semua
elemen-elemen data Stack

• Dengan cara me-loop semua nilai

array secara terbalik, karena kita
harus mengakses dari indeks
array tertinggi terlebih dahulu baru
ke indeks yang lebih kecil!
Operasi Mencetak Elemen
 Fungsi Peek
• Digunakan untuk melihat top of stack
 Ungkapan Aritmatika
• Prefix adalah metode penulisan dengan
meletakkan operator di depan operand dan tanpa
menuliskan tanda kurung.
Contoh : +AB, – +ABC, * + AB – CD.
• Infix adalah cara penulisan ungkapan dengan
meletakkan operator di antara dua operand dalam hal
ini pemakaian tanda kurung sangat menentukan hasil
operasi.

Contoh : A+B, A+B-C, (A+B)*(C-D).

• Postfix adalah metode penulisan dengan
menuliskan operator setelah operand dan tanpa
menuliskan tanda kurung.
Contoh : A B +
 Contoh :
2. Infix A+B * C
1.Infix A+B+
C Prefix
Prefix A+*BC
+AB + C +A*BC
++ABC Postfix A+ BC*
Postfix ABC*+
AB+ +C Derajat Operator Operator Logika :
1. NOT
AB+C+ 1. (..)
2. AND
2. ^ 3. OR
3. * dan /
4. + dan -
 Infix A*B + C*D
Prefix Postfix
*AB + C * D AB* + C*D
*AB + *CD AB* + CD*
+*AB*CD
AB*CD*+
 Infix : A + B * (C – D) / E
Prefix Postfix
A + B * -CD / E A + B * CD- / E
A + *B-CD / E A + BCD-* / E
A + /*B-CDE A + BCD-*E/
+A/*B-CDE ABCD-*E/+

Contoh :
1. Infix (A+B)*C^D/E-F+G
2. Infix (A+B*C)*(D+E)/F*G
 Algoritma Mengubah Ekspresi Infix menjadi Postfix

• Proses konversi ekspresi infix menjadi bentuk postfix selalu dimulai

dari sebelah kiri ekspresi aritmatik.
1. Jika yang ditemukan adalah operan, maka cetak atau simpan
2. Jika yang ditemukan adalah kurung buka maka abaikan.
3. Jika yang ditemukan adalah operator maka push ke dalam stack.
4. Jika yang ditemukan adalah kurung tutup maka pop stack,
kemudian cetak atau simpan nilainya.
5. Jika ekspresi telah diperiksa semua tetapi ternyata stack belum
kosong, pop semua data dalam stack dan cetak atau simpan nilai
yang di pop.
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 yang
dijalankan, adalah nilai dicetak. Dalam contoh ini tidak
menyimpan hasil konversi melainkan langsung
mencetaknya di layar monitor.
15*(((3-2)*(4+10))/7)

2. Proses lanjutkan, ditemukan operator * maka aturan ke 3

dikerjakan, yaitu push operator tersebut ke dalam stack.

3. 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.
15*(((3-2)*(4+10))/7)

4. Selanjutnya ditemukan bilangan 3 (operan) maka aturan nomor 1 harus

dikerjakan yaitu mencetak bilangan 3 tersebut ke layar.

5. Proses selanjutnya, dan ditemukan operator - maka aturan ke 3 dikerjakan,

yaitu push operator tersebut ke dalam stack.
15*(((3-2)*(4+10))/7)

6. Selanjutnya ditemukan angka 2 (operan) maka aturan nomor 1 dikerjakan yaitu

mencetak angka 2 ke layar.

7. Kemudian ditemukan tanda kurung tutup ) sehingga aturan ke 4 dikerjakan

yaitu pop stack dan cetak data paling atas stack ke layar.
15*(((3-2)*(4+10))/7)

8. Proses kita lanjutkan, dan ditemukan operator * maka aturan ke 3

dikerjakan, yaitu push operator tersebut ke dalam stack.

9. Kemudian kurung buka ( ditemukan, sehingga abaikan saja. Selanjutnya kita

temukan angka 4 (operan) maka aturan nomor 1 dikerjakan yaitu mencetak
bilangan 4 tersebut ke layar.
15*(((3-2)*(4+10))/7)

10. Proses kita lanjutkan, dan ditemukan operator +, maka aturan ke 3

dikerjakan, yaitu push operator tersebut ke dalam stack.

11. Selanjutnya kita temukan bilangan 10 (operan) maka aturan nomor 1 harus
dikerjakan yaitu mencetak angka 10 ke layar.
15*(((3-2)*(4+10))/7)

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.

13. Satu lagi tanda kurung tutup ) kita temukan, sehingga aturan ke 4 dikerjakan.
15*(((3-2)*(4+10))/7)

14. Proses kita lanjutkan, dan kita menemukan operator / maka aturan ke 3
dikerjakan, yaitu push operator tersebut ke dalam stack.

15. Kemudian kita temukan bilangan 7 (operan) maka aturan nomor 1

dikerjakan yaitu mencetak bilangan 7 tersebut ke layar.
15*(((3-2)*(4+10))/7)
16. Kemudian 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.
 Algoritma Menghitung Nilai
Ekspresi Postfix
• Perhatikan contoh berikut.
( 3 - 2 ) * ( 4 + 10 )
A = 15 x ----------------------------
7

• Jika telah diperoleh ekspresi postfix

berikut ini:
15 3 2 - 4 10 + * 7 / *
15 3 2 - 4 10 + * 7 / *

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

2. Kemudian ditemukan kembali operan dengan nilai 3, maka aturan nomor 1

dikerjakan lagi, yaitu push nilai tersebut ke dalam stack.
15 3 2 - 4 10 + * 7 / *
3. Selanjutnya ditemukan kembali operan dengan nilai 2, maka aturan nomor 1
dikerjakan lagi, yaitu push nilai tersebut ke dalam stack.
15 3 2 - 4 10 + * 7 / *
4. Proses di lanjutkan, dan sekarang di temukan operator – oleh karena itu aturan
nomor 2 dikerjakan, yaitu 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.

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.
15 3 2 - 4 10 + * 7 / *

5. Kemudian ditemukan kembali operan dengan nilai 4, maka aturan nomor 1

dikerjakan lagi, yaitu push nilai tersebut ke dalam stack.

6. Selanjutnya ditemukan operan dengan nilai 10, maka kembali aturan nomor 1
dikerjakan lagi, yaitu push nilai tersebut ke dalam stack.
15 3 2 - 4 10 + * 7 / *

7. Proses dilanjutkan lagi, dan sekarang 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
di push kembali ke dalam stack.
15 3 2 - 4 10 + * 7 / *

8. Kemudian kita 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 / *

8. 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 / *

9. 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 di pop dan operator yang dijumpai. Hasil
perhitungan ini kemudian di push kembali ke dalam stack.
 15 3 2 - 4 10 + * 7 / *

10. Kemudian kita temukan operator * oleh karena itu aturan nomor 2
dikerjakan lagi.

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
 ( A + B ) / (( C – D ) * E ^ F)

notasi postfix A B + C D – E F ^ */
SELESAI
 TUGAS
• Tuliskan Stuktur Data STACK dengan
kasus yang anda tentukan sendiri!
• Struktur Data terdiri atas:
– Spesifikasi
– Implementasi
– Pemrograman