Anda di halaman 1dari 26

MAKALAH STRUKTUR DATA

STACK (TUMPUKAN)

Disusun oleh :
Kelas B
1. OKTA CITRA ZULYANTI (KETUA) 2015-31-033
2. IRSANDI NUGRAHA S. (MAKALAH) 2015-31-005
3. NOER ARBIAN NISYA (PPT ) 2015-31-019
4. NUR AMALYA R. (MAKALAH ) 2015-31-021
5. MUHAMMAD SUHARTO (PPT) 2015-31-025
6. RIZZAL IKHSAN M. (PPT ) 2015-31-062
7. TITIS FAYA Q. (PPT) 2015-31-073
8. RAMA DESI W. S. (PPT) 2015-31-081
9. HENNY HALIMAH L. (MAKALAH) 2015-31-087
10. AHMAD RIYANA S. (PPT) 2015-31-103

SEKOLAH TINGGI TEKNIK PLN


TAHUN AJARAN 2016/2017
KATA PENGANTAR

Puji syukur kehadirat Tuhan Yang Maha Esa yang telah memberikan rahmat

dan hidayah kepada penulis, sehingga penulis dapat menyelesaikan makalah

mengenai STACK (Tumpukan). Makalah ini dibuat untuk memenuhi tugas mata

kuliah Struktur Data.

Besar harapan penulis jika makalah ini dapat bermanfaat bagi semuanya

agar bisa menambah pengetahuan dan wawasan pembaca di bidang teknologi,

informasi dan komunikasi.

Kami sadar bahwa makalah ini masih jauh dari kata sempurna, oleh karena

itu kritik dan saran yang membangun sangat diperlukan untuk membuat makalah

ini menjadi lebih baik.

Jakarta, 9 November 2016

Penulis,

Kelompok 2
DAFTAR ISI
Halaman
KATA PENGANTAR ....................................................................................... i

DAFTAR ISI ...................................................................................................... ii

BAB I PENDAHULUAN

1.1 Latar Belakang ................................................................................ 1

1.2 Rumusan Masalah........................................................................... 1

1.3 Tujuan Pembelajaran ..................................................................... 2

BAB II PEMBAHASAN

2.1 Pengertian Stack ............................................................................. 3

2.2 Operasi pada Stack ......................................................................... 3

2.3 Deklarasi Stack Dalam Pascal ........................................................ 4

2.4 Aplikasi Stack ................................................................................. 5

2.4.1 Notasi Postfix ........................................................................ 5

2.4.2 Notasi Infix ........................................................................... 6

2.5 Contoh Program Stack Dalam Pascal ............................................ 7

BAB III PENUTUP

3.1 Kesimpulan ..................................................................................... 20

3.2 Saran ............................................................................................... 20

3.3 Pertanyaan ....................................................................................... 21

DAFTAR PUSTAKA ......................................................................................... 22


BAB I
PENDAHULUAN

1.1 Latar Belakang


Struktur data adalah karakteristik yang terkait dengan sifat dan cara
penyimpanan sekaligus penggunaan atau pengaksesan data. Karakteristik
tersebut mengikat dan sekaligus secara timbal balik dipengaruhi oleh
algoritma yang mengakses data tersebut, sehingga disebutkan Algoritma
dan Struktur Data merupakan satu kesatuan. Salah satu teknik dasar tentang
struktur data adalah stack (tumpukan) yang lebih lanjut akan dibahas dalam
makalah ini.
1.2 Rumusan Masalah
Dari latar belakang masalah di atas, maka muncul rumusan masalah
sebagai berikut.
1. Apa pengertian Stack?
2. Apa saja operasi pada Stack?
3. Bagaimana pendeklarasian Stack?
4. Apa saja aplikasi pada Stack?
5. Apa contoh program Stack dalam pascal?
1.3 Tujuan Penulisan
Sejalan dengan rumusan masalah di atas, makalah ini disusun
dengan tujuan untuk mengetahui:
1. Definisi Stack
2. Operasi pada Stack
3. Pendeklarasian Stack
4. Aplikasi pada Stack
5. Contoh program Stack dalam Pascal
BAB II
PEMBAHASAN

2.1 Pengertian Stack


2.1.1 Daftar linear
Daftar linear atau linear list, merupakan suatu struktur
data umum yang terbentuk dari barisan hingga (yang terurut) dari
satuan data ataupun dari record. Untuk mudahnya, elemen yang
terdapat di dalam daftar disebut dengan simpul atau node. Daftar
disebut linear (lurus), karena elemen tampak seperti berbaris,
yakni bahwa setiap simpul, kecuali yang pertama dan yang
terakhir, selalu memiliki sebuah elemen penerus langsung
(suksesor langsung) dan sebuah elemen pendahulu langsung
(predesesor langsung).
Di sini, banyak simpul atau elemen, tersebut dapat
berubah-ubah, berbeda dengan array yang banyak elemennya
selalu tetap. Kita menyatakan linear list A yang mengandung T
elemen pada suatu saat, sebagai A = [A1, A2, AT]. Jika T = 0,
maka A disebut list hampa atau null list.
Suatu elemen dapat dihilangkan atau dihapus (deletion)
dari sembarang posisi dalam linear list, dan suatu elemen baru
dapat pula dimasukkan (insertion) sebagai anggota list pada
posisi sembarang (di mana saja).

2.1.2 Stack atau tumpukan

Stack atau tumpukan adalah bentuk khusus dari linear list.


Pada stack, penghapusan serta pemasukan elemennya hanya
dapat dilakukan di satu posisi, yakni posisi akhir dari list. Posisi
ini disebut puncak atau top dari stack. Elemen stack S pada posisi
ini dinyatakan dengan TOP(S).
Jelasnya, bila stack S [S1, S2, , ST], maka TOP(S)
adalah ST. Banyaknya elemen stack S pada suatu saat tertentu
biasa kita sebut sebagai NOEL(S). Jadi untuk stack kita di atas,
NOEL(S) = T. Seperti halnya pada semua linear list, pada stack
dikenal operasi penghapusan dan pemasukan.
Operator penghapusan elemen pada stack disebut POP,
sedangkan operator pemasukan elemen, disebut PUSH. Untuk
menggambarkan kerja kedua operator di atas, berikut ini suatu
contoh bermula dari stack hampa S[ ], yang kita gambar sebagai:

S NOEL(S) = 0, TOP(S) tidak terdefinisi

Mula-mula kita PUSH elemen A, diperoleh Stack S = [A]

A S NOEL(S) = 1, TOP(S) = A

Apabila kemudian kita PUSH elemen B, diperoleh Stack S = [A,B]

B NOEL(S) = 2, TOP(S) = B
A S

Selanjutnya bila PUSH elemen C, diperoleh Stack S = [A,B,C]

C
B S NOEL(S) = 3, TOP(S) = B
A

Kemudian bila kita POP elemen C, diperoleh Stack S = [A,B]


B S NOEL(S) = 2, TOP(S) = B
A

Kita dapat pula PUSH 2 elemen D dan E. Akan dihasilkan


Stack S = [A,B,D,E]

E
D
B
S NOEL(S) = 4, TOP(S) = E, dan seterusnya.
A

Terlihat bahwa kedua operasi di atas, pada stack adalah


bersifat terakhir masuk pertama keluar atau last in first out
(LIFO). Pada hakekatnya kita tidak membatasi berapa banyak
elemen dapat masuk ke dalam stack. Untuk suatu stack S[S1,
S2,..., SNOEL], kita katakan bahwa elemen Si, berada di atas
elemen Sj, jika i lebih besar dari j. Suatu elemen tidak dapat kita
POP ke luar, sebelum semua elemen di atasnya dikeluarkan.

2.2 Operasi pada Stack


Terdapat empat operasi pada stack, yakni CREATE(stack),
ISEMPTY(stack), PUSH(elemen, stack), dan POP (stack).
1. CREATE
Adalah operator yang menunjukkan suatu stack kosong
dengan nama S. Jadi : NOEL(CREATE(S)) = 0
TOP(CREATE(S)) adalah TIDAK TERDEFINISI.
2. ISEMPTY
Adalah operator yang menentukan apakah stack S kosong.
Operandnya terdiri dari type data stack. Hasilnya merupakan type
data Boolean: ISEMPTY(S) = True. Jika S hampa, yakni bila
NOEL(S) = 0.
3. PUSH
Adalah operator yang menambahkan elemen E pada
puncak stack S. Hasilnya merupakan stack yang lebih
besar.
PUSH(E,S). E ditempatkan sebagai TOP(S).
4. POP (stack)
Adalah operator yang menghapus sebuah elemen dari
puncak stack S. Hasilnya merupakan stack yang lebih
kecil.
POP(S) mengurangi NOEL(S)
POP(CREATE(S)) kondisi error
POP(PUSH(E,S)) = S
Kesalahan overflow akan terjadi jika kita melakukan operasi
pemasukan data (PUSH) pada stack yang sudah penuh (dalam hal ini
jika banyaknya elemen yang kita masukkan ke dalam sebuah stack
sudah melampaui batas kemampuan memori atau telah didefinisikan
sebelumnya).
Sebaliknya, kesalahan underflow akan terjadi jika stack sudah
dalam keadaan hampa, kita lakukan operasi pengeluaran atau
penghapusan (POP).

2.3 Deklarasi Stack dalam Pascal


Meskipun stack amat luas digunakan, banyak bahasa
pemrograman tidak mempu-nyai tipe data stack secara built-in. Dalam
hal ini, Pemrogram harus memanipulasi sendiri fasilitas yang dimiliki
bahasa pemrograman tersebut, untuk dapat melakukan operasi stack
terhadap variabel stack.
Mungkin cara yang paling sederhana adalah membentuk stack
dalam bentuk se-macam array. Jelas kita harus membedakan suatu
stack dengan suatu array yang sesungguhnya. Pemrogram harus
memaksakan berlakunya aturan LIFO bagi stack. Selain itu juga,
penempatan stack dalam bentuk array mengakibatkan suatu
keterbatasan, yakni bahwa elemen stack harus homogen. Keterbatasan
lain yang timbul adalah keharusan Pemrogram untuk menentukan
batas atas dari subscript array, walaupun stack secara teori tidak
memiliki batas maksimum dalam jumlah elemen. Jika diinginkan,
seharusnya kita dapat membuat stack yang panjangnya takhingga.
Satu hal yang nyata membedakan stack dengan array adalah
banyaknya elemen stack yang dapat bertambah atau berkurang setiap
waktu, sementara banyaknya elemen sebuah array selalu tetap.
Sekarang marilah kita bicarakan deklarasi dari variabel S yang
bertipe data stack. Diasumsikan bahwa elemen dari S masing-masing
bertipe data integer dan panjang stack maksimum adalah 100 elemen.
Kita mendeklarasikan sebuah array yang dilengkapi dengan variabel
TOP-PTR.
Variabel TOP-PTR ini menyatakan subscript dari elemen
TOP(S) dari stack. Kita menamakan kombinasi dari array dan
indikator untuk TOP tersebut dengan nama STACK-STRUC. Dengan
penyajian seperti ini, berlaku bahwa NOEL(S) = TOP-PTR,
ISEMPTY(S) adalah true bila TOP-PTR = 0, dan false bila TOP-PTR
lebih besar dari 0.
Dalam Pascal
type stackstruct;
record stack: array[1..100[of integer;
top-ptr : integer
end
var S : stackstruct;

Kompilator tidak dapat mengerti aturan LIFO yang kita


inginkan. Untuk itu Pem- rogram harus berhati-ati dan tidak memberi
indeks pada S di sembarang tempat, selain dengan nilai TOP-PTR.

Operasi PUSH dan POP dapat kita program sebagai berikut :


kita gunakan EON untuk menyatakan elemen yang di-PUSH ke dalam
S dan EOFF untuk elemen yang di-POP ke luar S. NOEL-MAX
menyatakan panjang maksimum stack. Jadi di sini NOEL-MAX =
100.

Dalam procedure Pascal :

procedure PUSH (eon : integer); begin

if (s.topptr < noelmax) then

begin s.topptr <= s.topptr + 1; s.stack [s.topptr] := eon

end

else OVERFLOW-CONDITION

end;

procedure POP (var eoff : integer); begin

if (s.topptr > 0) then

begin eoff := s.Stack(s.topptr);

s.topptr := s.topptr-1

end

else UNDERFLOW-CONDITION

end;

2.4 Aplikasi Stack

Stack sangat luas pemakaiannya dalam menyelesaikan berbagai


macam problema. Kompilator, sistem operasi, dan berbagai program
aplikasi banyak menggunakan konsep stack tersebut. Salah satu contoh
adalah problema Penjodohan Tanda Kurung atau matchingparantheses.
Sebuah kompilator mempunyai tugas, salah satu di antaranya
adalah menyelidiki apakah Pemrogram telah dengan cermat mengikuti
aturan tata bahasa, atau sintaks dari bahasa pemrograman yang
bersangkutan. Misalnya untuk parantheses kiri (tanda kurung buka)
yang diberikan, harus dipastikan adanya parantheses kanan (tanda
kurung tutup) yang bersangkutan.
Stack dapat digunakan dalam prosedur matchin yang digunakan.
Algoritmanya sederhana, kita amati barisan elemen dari kiri ke kanan.
Bila kita bertemu dengan suatu parantheses kiri, maka parantheses kiri
tersebut kita PUSH ke dalam sebuah stack. Selanjutnya bila kita bertemu
dengan suatu parantheses kanan, kita periksa stack, apakah hampa atau
tidak. Kalau stack hampa, berarti terdapat parantheses kanan tanpa
adanya parantheses kiri. Suatu kesalahan, atau error, apabila stack tidak
hampa, berarti tidak diperoleh sepasang parantheses kiri, dan kanan, kita
POP elemen ke luar stack.
Jika sampai berakhirnya barisan elemen, stack tidak hampa
berarti terdapat parantheses kiri yang tidak tertutup dengan
parantheses kanan. Lagi suatu kesalahan. Kita akan membuat
programnya dalam COBOL. Barisan elemen yang diamati kita
tampung karakter demi karakter dalam variabel array bernama
STRING. Stack ditempatkan dalam array STACK. Kita asumsikan
bahwa jumlah maksimum karakter dalam barisan elemen adalah 80 dan
barisan berakhir dengan karaktertitik-koma.
Struktur datanya didefinisikan sebagai berikut :

01 STACK-STRUCT.

02STACK PICX

OCCURS 80 TIMES.

02TOP-PTR PIC 99 VALUE0.


01 STRING

02CHAR PICX

OCCURS 80 TIMES

01NEXT-CHAR PIC 99

Struktur di atas kita manipulasi dengan prosedur sebagai berikut :

PERFORM SCAN-NEXT-CHAR

VARIYING NECT CHAR


FROM 1 BY 1 UNTIL
NEXT-CHAR >80

OR CHAR(NEXT-CHAR) = ;.

IF TOP-PTR NOT = 0 THEN invalid syntax.

parenthesis kiri tak tertutup


ELSE valid syntax

SCAN NEXT-CHAR

IF CHAR(NEXT-
CHAR) = (
PERFORM
PUSH

ELSE

IF CHAR(NEXT-
CHAR) = )

PERFORM
POP

PUSH

COMPUTE TOP-PTR = TOP-PTR + 1


MOVE CHAR (NEXT-CHAR)TO STACK (TOP-
PTR).

IF TOP-PTR > 0

COMPUTE TOP-
PTR 1

ELSE invalid syntax, tak ada parenthesis

2.4.1 Notasi Postfix


Aplikasi lain dari stack adalah pada kompilasi dari
ekspresi dalam bahasa pemrograman tingkat tinggi. Kompilator
harus mampu menyerahkan bentuk yang biasa, misalnya
((A+B)*C/D+E^F)/G ke suatu bentuk yang dapat lebih mudah
dipergunakan dalam pembentukan kode objeknya.
Cara yang biasa kita lakukan dalam menulis ekspresi
aritmetik seperti di atas, dikenal sebagai notasi infix. Untuk
operasi binar seperti menjumlah, membagi, mengurangi,
mengalikan ataupun memangkatkan, operator tampil di antara
dua operand, misalnya operator + tampil di antara operand A dan
B pada operasi A + B.
Stack dapat digunakan untuk mentransformasikan notasi
infix ini menjadi notasi posfix. Pada notasi posfix, kedua operand
tampil bersama di depan operator, misalnya AB+ atau PQ* dan
sebagainya. Kompilator akan lebih mudah menangani ekspresi
dalam notasi posfix ini.
Berikut contoh melakukan pengalihan ekspresi infix ke
postfix secara manual. Ekspresi infix = A + B / C * D akan
dialihkan menjadi ekspresi postfix.
1. Pilih sub-ekspresi yang berisi dua operand dan satu operator
yang memiliki level tertinggi di ekspresi di atas. Didapat B / C
dan C * D. Pilih yang paling kiri, maka kita peroleh : B /C.
2. Ubah sub-ekspresi tersebut menjadi sebuah operand, misalkan
B / C menjadi E, maka ekspresi semula menjadi : A + E *D.
3. Lakukan langkah ke (2) hingga ekspresi di atas menjadi dua
operand dan satu operator saja. Didapat : A + F
4. Alihkan menjadi bentuk postfix : operand-operand-operator,
diperoleh A F+
5. Kembalikan setiap operand menjadi ekspresi semula. F tadinya
adalah E * D, maka nilai F = E * D. Satukan dengan ekspresi
yang telah menjadi postfix. Hasilnya = A * E +D
6. Ulangi langkah ke (5) hingga terbentuk ekspresi postfix.
Didapat A * B + C / D
Dengan demikian, ekspresiinfix : A+B/C*D akan menjadi
ABC/D*+ dalam notasi postfix. Perhatikan dan pelajari tabel
berikut ini :
Tabel Postfix-Infix

Ekspresi Ekspresi
A+B A+B
Infix Postfix
A+B* A+B*C
(A + B) A+B*C
C
A*B+ A+B*C
*C
Bila ada sub-ekspresi
C di dalam tanda kurung, maka sub-ekspresi
tersebut harus dikerjakan terlebih dahulu.
Berikut ini diberikan sebuah algoritma untuk mengubah
notasi infix ke dalam notasi posfix. Sebuah stack digunakan untuk
keperluan ini. Ekspresi diamati satu persatu dari kiri ke kanan.
Pada algoritma ini terdapat 4 aturan dasar, sebagai berikut :
1. Jika simbol adalah ''('' (kurung buka), maka ia kita PUSH
ke dalam stack

2. Jika simbol adalah '')'' (kurung tutup), POP dari stack


elemen-elemen stack, sampai pertama kali kita POP simbol
''(''. Semua elemen stack yang di POP tersebut merupakan
output, kecuali ''(''tadi.

3. Jika simbol adalah sebuah operand, tanpa melakukan


perubahan elemen stack, operand tersebut langsung
merupakan output.
4. Jika simbol adalah sebuah operator, maka jika TOP stack
adalah operator dengan level lebih tinggi atau sama, maka
elemen TOP kita POP, sekaligus keluar sebagai output,
dilanjutkan proses seperti ini sampai TOP merupakan ''(''
atau operator dengan level lebih rendah. Kalau hal ini terjadi,
operator (yang diamati) kita PUSH ke dalam stack. Biasanya
ditambahkan simbol ; (titik-koma) sebagai penutup ekspresi.
Dalam keadaan ini, kita POP semua elemen stack, sehingga
stack menjadi hampa.
Dapat dicatat bahwa terdapat 3 level operator, yakni
pemangkatan (level tertinggi), level menengahnya adalah
perkalian (*) dan pembagian (/) dan level terendah adalah
penjumlahan (+) dan pengurangan (-). Tabel berikut
menunjukkan pelaksanaan algoritma di atas untuk mengubah
ekspresi ((A+B)*C/D+E^F)/G; ke dalam notasi postfix.

Tabel

Simbol ( ( A + B ) * C / D + E ^ F ) / G ;
yang
TOP(S) ( ( ( + + ( * * / / + + ^ ^ /
diamati ( ( ( ( ( ( ( ( + +
( ( ( ( ( (
Output A B + C * D / E F ^+ G /

Jadi, ((A+B)*C/D+E^F)/G akan menjadi AB+C*D/EF^+G/


dalam notasi postfix.
Algorithma:
1. Amati ekspresi dari kiri ke kanan satu persatu.
2. Sampai seluruh ekspresi selesai diamati:

1. Jika ekspresi merupakan angka, maka push ekspresi ke


dalam stack.

2. Jika ekspresi merupakan operator, maka:

1. Pop 2 operand dari dalam stack:

1. Jika stack kosong sebelum pop, maka terjadi


error.

2. Jika jumlah elemen di dalam stack sebelum


pop < 2, maka terjadi error.

2. Lakukan perhitungan menggunakan operator pada


ekspresi dengan 2 buah operand yang diambil dari
stack.

3. Push hasil perhitungan ke dalam stack

3. Pop hasil proses perhitungan terakhir dari dalam stack sebagai


output.

Contoh penggunaan algorithma:

Ekspresi 1 2 3 + 4 * 5 + 6 * +

3 4 5 6

Stack 2 2 5 5 20 20 25 25 150

1 1 1 1 1 1 1 1 1 1 151

Output 151

pop pop pop


pus pus pus pop pus pop pus pus
Aksi Stack pop pop pop pop
h h h pop h pop h h
push push push
pus pus
h h

3+ 5* 5+ 6* 150 +
Perhitungan
2 4 20 25 1

Hasil 5 20 25 150 151

Infix 1+((2+3)*4+5)*6 = 151

Postfix 1 2 3+ 4*5+ 6*+ = 151

2.4.2 Notasi Infix

Suatu notasi disebut infix jika operator berada diantara


operandnya. Notasi ini merupakan notasi yang sering kita gunakan
sehari hari.

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

Algoritma pengerjaan operasi matematika dengan notasi


infix adalah sebagai berikut :

1. Scan dari kiri ke kanan sampai ketemu dengan kurung tutup


yang paling awal.
2. Scan kembali dari posisi tadi ke kiri sampai ketemu dengan
kurung buka yang pertama.
3. Lakukan operasi yang berada di dalam tanda kurung.
4. Ganti ekspresi di dalam tanda kurung tersebut dengan hasil
operasi.
5. Ulangi langkah 1 sampai 4 sehingga keseluruhan ekspresi
dilaksanakan.
Contoh ((10+15)*20)+200)=700, maka pengerjaan operasi infix
adalah sebagai berikut :
1. ((10 + 15)*20) + 200 (Scan ke kanan sampai ketemu
kurung tutup yang pertama)
2. ((10 + 15)*20)+200 (Scan ke kiri sampai ketemu kurung
buka yang pertama)
3. (25 * 20)+200 (Scan lagi ke kanan sampai ketemu
kurung buka yang pertama)
4. (25 * 20)+200 (Lakukan operasi (10 + 15) dan ganti
ekspresi yang berada dalam tanda
kurung dengan hasil operasi)
5. (25 * 20)+200 (Scan kembali ke kiri sampai ketemu
kurung buka yang pertama)
6. 500 + 200 (Lakukan operasi (25 * 20) dan ganti
ekspresi yang berada dalam tanda
kurung dengan hasil operasi)
7. 700 Tetap lakukan scan kekanan untuk
mencari tanda kurung bila sudah tidak
ketemu maka lakukan
operasi dari kiri ke kanan dengan
memperhatikan prioritas pengerjaan
ekspresi.
Beberapa kelemahan dari notasi infix di antaranya adalah
proses pengerjaan ekspresi sangat lama, diperlukan tanda kurung
untuk menandai operasi yang lebih rendah prioritasnya, dan
pengerjaan sangat tidak efisien.

2.5 Contoh Program Stack dalam Pascal


Program pop_push;
uses crt;
const elemen =255;
type S255 = string [elemen];
tumpukan = record
isi : s255;
atas : 0..elemen;
end;

var
T : tumpukan;
W : char;
kalimat : s255;
i,j : integer;

procedure awalan (var T : tumpukan);


begin
T.Atas := 0;
end;

procedure push (var T : tumpukan; X : char);


begin
T. Atas := T.Atas+1;
T.Isi[T.Atas] := X;
end;

function pop (var T : tumpukan): char;


begin
pop := T.Isi[T.Atas];
T.atas := T.atas-1;
end;

begin
clrscr;
writeln(Masukkan Kalimat : );
read(kalimat);
writeln;
for i := 1 to length (kalimat) do push (T, kalimat [i]);
write(Elemen yang di-push : , kalimat);
writeln;
readln;

{melakukan proses pop}


for i := 1 to length (kalimat) do push (t, kalimat [i]);
writeln;
writeln(Hasil akhir push dibaca dengan pop : );
{menampilkan hasil proses pop}
for j := 1 to length (kalimat) do
begin
w := pop (T);
write(w);
end;
readln;
end.
Screenshot Program :
Screenshot Output Program di atas :
BAB III

PENUTUP

3.1 Kesimpulan
1. Daftar linear atau linear list, merupakan suatu struktur data umum yang
terbentuk dari barisan hingga (yang terurut) dari satuan data ataupun dari
record.
2. Stack adalah suatu bentuk khusus dari linier list, dengan operasi penyisipan
dan penghapusan dibatasi hanya pada satu sisinya, yaitu puncak stack
(TOP).
3. Terdapat empat operasi pada stack, yakni CREATE (stack),
ISEMPTY(stack), PUSH(elemen, stack), dan POP (stack).
4. Stack dapat digunakan untuk mentransformasikan notasi infix ini menjadi
notasi posfix. Pada notasi posfix, kedua operand tampil bersama di depan
operator, misalnya AB+ atau PQ* dan sebagainya.
5. Suatu notasi disebut infix jika operator berada diantara operandnya. Notasi
ini merupakan notasi yang sering kita gunakan sehari hari.

3.2 Saran
Dari uraian di atas, penulis berharap pembaca dapat memahami tentang
pengertian Stack (Tumpukan), Operasi pada Stack, Deklarasi Stack dalam
Pascal, Aplikasi Stack, dan Contoh Program Stack dalam Pascal.

Penulis menyadari bahwa dalam pembuatan makalah ini masih banyak


kesalahan dan kekurangan, baik dari segi penulisan maupun dari segi
pemaparan. Maka dari itu pemakalah menerima dan mengharapkan kritik dan
saran dari pembaca yang sifatnya membangun, agar makalah ini dapat menjadi
lebih sempurna dan menjadi rujukan bagi pembaca nantinya.
PERTANYAAN

1. Stack digunakan buat apa dan dalam kasus bagaimana? (Raudatul


Jannah_201531_Kelompok 4)
2. Apa perbedaan stack dan antrean?(Reni Rahma Utari_201531_Kelompok 1)
3. Jelaskan implementasi antara stack dan array!
(Wahyu Gusti H._201431159_kelompok 1)
4. Fungsi undo termasuk ke dalam stack biasa atau linked list? (Aslab)
Jawaban:
1. Stack digunakan untuk menampilkan data yang terakhir kali diinput
karena mempunyai sifat LIFO. Dalam dunia komputer,
penggunaan stack (tumpukan) merupakan suatu hal yang umum
digunakan seperti untuk penentuan alamat memory, penempatan
ruang data dan aplikasi lain. Sebagai bagian dari struktur data,
aplikasi stack juga digunakan untuk berbagai macam keperluan
seperti pengujian kalimat palindrome, penguji tanda kurung
(matching parentheses), dan juga berfungsi sebagai konversi dari
notasi infix menjadi notasi postfix.
2. Stack memakai sistem LIFO atau last in first out (yang pertama
masuk akan keluar terakhir, begitu pula yang terakhir masuk akan
keluar pertama kali). Sementara queue memakai sistem FIFO atau
first in first out (yang pertama masuk akan keluar pertama, begitu
pula yang masuk terakhir akan keluar terakhir)
3. Stack dapat diimplementasikan dengan array, record maupun
pointer / link-list sedangkan array, record dan pointer / link list
sendiri merupakan tipe data struktur yang dapat terdiri dari byte,
integer, real dll. Hal ini menyebabkan implementasi stack memakai
linked list akan memerlukan memori yang lebih banyak dari pada
kalau di implementasikan dengan Array. Dalam perancangan suatu
program, kadang-kadang diperlukan tipe data yang abstraksinya
lebih tinggi dari sekedar native data type yang tersedia. Type data
yang lebih tinggi abstraksinya pada umumnya tidak disediakan
native data typenya, contohnya stack, tetapi pada tahap
implementasi dari tipe data ini, tetap diperlukan native data type
yang tersedia seperti ; array, record, pointer, dan linked-list.
4. Fungsi undo termasuk ke dalam linked list karena linked list
sifatnya terstruktur
DAFTAR PUSTAKA

http://sisfo.binadarma.ac.id/upload/materi/8868_SD4STACK%20(Tumpukan).pdf

http://bintang_ep.staff.gunadarma.ac.id/Downloads/files/34211/sod+2+-+03+-
+stack.pptx

https://gugunawan.wordpress.com/tag/algoritma-struktur-data-bab-5/