 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 linier list,
dan dapat pula dimasukkan elemen baru sebagai
anggota list.
Contoh :
1. File, dengan elemennya berupa record
2. Buku telepon
3. Stack
4. Queue
5. Linear link list
 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.
 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
 Push : menambah data pada STACK
 Pop : mengambil data pada STACK
 Clear : digunakan untuk mengosongkan stack
 Print : Mencetak 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
 History pada web browser.
 Undo Log pada text editor.
 Pemrosesan struktur bersarang (nested) :
loop, rekursi, fungsi, dll.
 Algoritma back tracking – Artificial
Intelegence
 • Dari gambar disamping kita bisa
mengatakan bahwa kotak B ada
diatas kotak A dan ada dibawah
kotak C.

D • Gambar di samping
menunjukkan bahwa dalam
tumpukan, kita hanya bisa
C menambah atau mengambil
sebuah kotak lewat satu ujung,
B yaitu ujung bagian atas

A
 • 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]
3 Isi : array[1..n] of Tipe Data
Isi [4]
2 Atas : integer
Isi [3]
End
1 Isi [2]

0 Isi [1]

Stack S
 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
 Contoh deklarasi MAX_STACK
#define MAX_STACK 10
 Contoh deklarasi STACK dengan struct dan array data
typedef struct STACK{
int top;
int data[10];
};
 Deklarasi/buat variabel dari struct
STACK tumpuk;
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!
 9 Max_Stack
8
7
6
5
4
3
2
1
0 Top = -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
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
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
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
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
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
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
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
 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
 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
stack Kosong
endif
 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.
 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
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
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
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
 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
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
 Untuk memeriksa apakah data Stack
masih kosong
 Dengan cara memeriksa top of stack, jika
masih -1 maka berarti data Stack masih
kosong!
 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”
 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!
 Digunakan untuk melihat top of stack
 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 :
1. Infix A + B + C 2. Infix A+B * C
Prefix Prefix
+AB + C
++ABC A+*BC
Postfix +A*BC
AB+ +C
Postfix A+ BC*
AB+C+
Derajat Operator Operator Logika :
ABC*+
1. NOT
1. (..)
2. AND
2. ^ 3. OR
3. * dan /
4. + dan -
Prefix Postfix
*AB + C * D
AB* + C*D
*AB + *CD
+*AB*CD AB* + CD*
AB*CD*+
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
 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.
 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 / *
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 ^ */