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 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 t entang 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 A
NOEL(S) = 2, TOP(S) = B 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,..., S NOEL], kita katakan bahwa elemen S i, berada di atas elemen S j, 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))
POP(PUSH(E,S)) = S
kondisi error
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 vari abel 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(NEXTCHAR) = “(“ PERFORM PUSH ELSE IF CHAR(NEXTCHAR) = “)” PERFORM
POP
PUSH COMPUTE TOP-PTR = TOP-PTR + 1
MOVE CHAR (NEXT-CHAR)TO STACK (TOPPTR). IF TOP-PTR > 0 COMPUTE TOPPTR – 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
Eks resi A+B A+B* A+B A*B+
Eks resi A+B A+B*C A+B*C A+B*C
Bila ada sub-ekspresi 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 +
TOP(S)
( ( (
( ( Output
B )
+ + (
(
(
(
A
(
B +
*
C /
D +
E ^
F )
/
^
/
* *
/
/
+ +
^
(
(
(
(
+ +
(
(
( C * D /
E
Algorithma: 1. Amati ekspresi dari kiri ke kanan satu persatu.
;
G
/
( F ^+
Jadi, ((A+B)*C/D+E^F)/G akan menjadi AB+C*D/EF^+G/ dalam notasi postfix.
G
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
+
3 Stack 1
4
*
4
5
+
5
6
*
+
6
2
2
5
5
20
20
25
25
150
1
1
1
1
1
1
1
1
1
151
151
Output
pop Aksi Stack
pus pus pus pop pus h
h
h
pop
h
pop pus pop
h
pop push
pus h
pop
pop
pop
pop
push push
pop
Perhitungan
Hasil
Infix
Postfix
pus
pus
h
h
3+
5*
5+
6*
150 +
2
4
20
25
1
5
20
25
150
151
1+((2+3)*4+5)*6 1
2
=
3+ 4*5+ 6*+ =
151 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/
