LAPORAN PRAKTIKUM

ALGORITMA & STRUKTUR DATA

Laporan ini disusun untuk memenuhi salah satu tugas mata kuliah

Praktikum Algoritma & Struktur Data

Semester 2 Tahun Akademik 2020/2021

Oleh :
Nama : Popy Anisa
NPM : 207006018

LABORATORIUM INFORMATIKA
PROGRAM STUDI INFORMATIKA
FAKULTAS TEKNIK UNIVERSITAS SILIWANGI
TASIKMALAYA
TAHUN
2021
 IX-2

BAB IX

STACK

I. TUJUAN

1. Memahami lebih jau tentang materi Stack

2. Belajar pemograman stack

II. DASAR TEORI

STACK

Stack adalah Tumpukan dapat diartikan sebagai suatu kumpulan data yang
seolah-olah terlihat seperti ada data yang diletakkan di atas data yang lain seperti
pada gambar 01. Saat kita ingin mengambil data A, maka data-data yang berada di
atasnya haruslah lebih dulu dikeluarkan ( di-POP ). Hal ini membuat tumpukan /
stack memiliki ciri-ciri Last In First Out ( LIFO ) yang berarti data yang masuk
terakhir akan keluar pertama.

IX-1
 IX-2

1. Stack : List Linier yang :

A. dikenali element puncaknya (TOP),

B. aturan penyisipan dan penghapusan element tertentu :

• Penyisipan selalu dilakukan “di atas” TOP,

• Penghapusan selalu dilakukan pada TOP.

2. TOP adalah satu-satunya alamat tempat terjadi operasi.

3. Element Stack tersusun secara LIFO (Last In First Out)

Contoh :

IX-2
 IX-3

Contoh 2 :

Tower of Hanoi

https://en.wikipedia.org/wiki/Tower_of_Hanoi#/media/File:Tower_of_Hanoi_4.gif

a. Implementasi Stack dengan list (Array)

➢ Implementasi Stack dengan list (Array)

➢ Ilustrasi stack kosong, maka TOP di set = Nil (-1)

IX-1
 IX-4

Contoh Stack pada Bahasa C :

Diimplementasikan menggunakan ADT

Nama file : Boolean.h

/* File: boolean.h */
/* Definisi type data boolean */
#ifndef BOOLEAN_H
#define BOOLEAN_H
#define boolean unsigned char
#define true 1
#define false 0
#endif

Nama File : stack.h

/* File : stack.h */
/* deklarasi stack yang diimplementasi dengan tabel kontigu */
/* TOP adalah alamat elemen puncak */
#ifndef stack_H
#define stack_H

#include "boolean.h"

#define Nil 0
/* Nil adalah stack dengan elemen kosong . */
/* Karena indeks dalam bhs C dimulai 0 maka tabel dengan indeks
0
tidak dipakai */
typedef int infotype; //tipe dr element yg kita masukan ke stack
typedef int address; /* indeks tabel */
/* Contoh deklarasi variabel bertype stack dengan ciri TOP : */
/* Versi I : dengan menyimpan tabel dan alamat top secara
eksplisit*/
typedef struct { /* type bentukan dlm bahasa c kita pakai
struct*/
infotype *T; /* tabel penyimpan elemen */
address TOP; /* alamat TOP: elemen puncak */
int Size;
/* Ukuran stack */
} Stack;
/* Definisi stack S kosong : S.TOP = Nil */
/* Elemen yang dipakai menyimpan nilai Stack T[1]..T[Size+1] */
/* perhatkan definisi ini dan pakailah untuk mengalokasi T
dengan
benar*/
 IX-5

/* Jika S adalah Stack maka akses elemen : */

/* S.T[(S.TOP)] untuk mengakses elemen TOP */
/* S.TOP adalah alamat elemen TOP */
/* Definisi akses */
#define Top(S) (S).TOP
#define InfoTop(S) (S).T[(S).TOP]
#define Size(S) (S).Size
/* Prototype */
boolean IsEmpty(Stack S);
/* Mengirim true jika Stack kosong: lihat definisi di atas */
boolean IsFull(Stack S);

/*Mengirim true jika tabel penampung nilai elemen stack sudah

penuh*/
void CreateEmpty(Stack *S, int Size);
/* I.S. sembarang; */
/* F.S. Membuat sebuah stack S yang kosong berkapasitas Size
*/
/* jadi indeksnya antara 1.. Size+1 karena 0 tidak dipakai */
/* Ciri stack kosong : TOP bernilai Nil */
void Destruct(Stack *S);

/* destruktor */
void Push(Stack *S, infotype X);
/* Menambahkan X sebagai elemen Stack S. */
/* I.S. S mungkin kosong, tabel penampung elemen stack TIDAK
penuh */
/* X menjadi TOP yang baru,TOP bertambah 1 */
void Pop(Stack *S, infotype *X);
/* Menghapus X dari Stack S. */
/* S tidak mungkin kosong */
/* X adalah nilai elemen TOP yang lama, TOP berkurang 1 */
#endif

Nama File : stack.c

/* File : stack.c */
/* realisasi stack yang diimplementasi dengan tabel kontigu */
/* TOP adalah alamat elemen puncak */
#include <malloc.h>
#include "boolean.h"
#include "stack.h"

boolean IsEmpty(Stack S) {
return (Top(S) == Nil);
}
 IX-6

boolean IsFull(Stack S) {
return (Top(S) == Size(S) + 1);
}
void CreateEmpty(Stack *S, int Size) {
(*S).T = (int *) malloc((Size + 1) * sizeof(int));
Top(*S) = Nil;
// S->T[S->TOP] = 7;
Size(*S) = Size;
}

void Destruct(Stack *S) {

free((*S).T);
}

void Push(Stack *S, infotype X) {

Top(*S)++;
InfoTop(*S) = X;
}

void Pop (Stack *S, infotype *X) {

/* Menghapus X dari Stack S. */
/* I.S. S tidak mungkin kosong */
/* F.S. X adalah nilai elemen TOP yang lama, TOP berkurang
1 */
/* Algoritma */
*X = InfoTop(*S);
InfoTop(*S) = 0;
Top(*S)--;
}

Nama File : mstack.c

/* File : mstack.c */
/* driver stack.* stack dg representasi kontigu */
#include <stdio.h>
#include "stack.h"

int main() {
/* KAMUS */
Stack S;
infotype X;
/* Algoritma */
printf(" stack ");
CreateEmpty(&S, 100);
printf("size stack : %d \n", Size(S));
printf("Nilai top dan infonya : %d dan %d\n", Top(S),
InfoTop(S)); Push(&S, 3);
 IX-7

printf("Nilai top dan infonya : %d dan %d\n", Top(S),

InfoTop(S)); Push(&S, 4);
printf("Nilai top dan infonya : %d dan %d\n", Top(S),
InfoTop(S)); Pop(&S, &X);
printf("Nilai top dan infonya : %d dan %d\n", Top(S),
InfoTop(S)); Destruct(&S);
return 0;
}

Tampilan pada layar

Analisis :
Program di atas mengunakan prosedur adt dimana program akan
membutuhkan drivernya agar bisa dijalankan.
1. Header boolean.h pada bahasa C berfungsi untuk melakukan operasi
yang berhubungan dengan ekspresi Boolean
2. File.h merupakan library dari program main sebagai ADT
3. File.c merupakan program main yang sudah bisa di jalankan
4. #include berfungsi untuk memanggil header/library untuk operasi
standar input output pada bahasa C.
5. /**/ dan // merupakan Komentar dalam program digunakan Untuk
keperluan dokumentasi dengan maksud agar program mudah
dipahami
6. %d berfungsi untuk membaca sebuah nilai integer desimal
7. Char mendefinisikan tipe data karakter
8. Void merupakan sebuah prosedur yang tidak mengembalikan nilai.
 IX-8

9. Int merupakan sebuah prosedur yang berguna untuk menampung

nilai.
10. TOP tempat terjadinya oprasi
11. tanda () berfungsi untuk mengapit argumen fungsi yaitu nilai yang
akan digunakan dalam fungsi.
12. tanda {} berfungsi untuk mengawali dan mengakhiri kamus dari
sebuah fungsi atau prosedur dalam program.
13. printf berfungsi untuk membuat sebuah output berupa tampilan di
layar. Printf merupakan sebuah fungsi dalam file header stdio.h.
14. main berfungsi untuk mengawali sebuah program.
15. return 0 berguna untuk mengembalikan nilai di akhir program.
16. Program ini merupakan implementasi stack pada Bahasa c yang akan
menunjukkan nilai top dan info pada stack dengan size yang sudah
ditentukan sebelumnya.

b. Pemakaian Stack
1. Pemanggilan prosedur
2. Perhitungan ekspresi aritmatika
3. Rekursivitas
4. Backtracking Dan algoritma yg lainnya

c. Definisi Fungsional
CreateEmpty : → S {Membuat sebuah sack kosong}

IsEmpty : S → Boolean {Test stack kosong, true jika kosong}

 IX-9

IsFull : S → Boolean {Test stack penuh, true jika stack penuh}

Push : ElmtS x S → S {Menambahkan sebuah elemen ElmtS

sebagai TOP, TOP berubah nilainya.}

Pop : S → S x ElmtS {Mengambil nilai elemen TOP, sehingga

TOP yang baru adalah lemen yang datang sebelum elemen TOP, mungkin
stack menjadi kosong}

Definisi Selektor :
1. jika S adalah sebuah Stack, maka
Top(S) adalah alamat element TOP
InfoTop(S) adalah informasi yang disimpan pada Top(S).
2. Definisi Stack kosong adalah Stack dengan Top(S) = Nil (tidak terdefinisi)

2. EVALUASI EKSPRESI ARITMATIKA

Evaluasi ekspresi aritmatika yang ditulis dengan Reverse Polish

Notation (postfix)

1. Diberikan sebuah aritmatika postfix dengan operator [^, *, / , +, -]

2. Operator mempunyai prioritas (makin besar maka makin tinggi)

 IX-10

a. Contoh : evaluasi Ekspresi Matematika

Digunakan istilah token yaitu satuan “kata” yang mewakili sebuah

operan (konstanta atau nama) atau sebuah operator

Contoh : A B * C /

Contoh : A B * C /
 IX-11

Contoh : A B * C /

Contoh : A B * C /

Contoh : A B * C /
 IX-12

Contoh : A B * C /

Contoh ABC^/DE*+AC*-
 IX-13

TUGAS
1. Diberikan sebuah ekspresi aritmatika postfix dengan operator [‘.’ ; ‘:’ ; ‘+’ ;‘-‘
; ‘^’] dan Operator mempunyai prioritas (prioritas makin besar, artinya makin
tinggi) sebagai berikut :

a. AB.C/ ⇒ (A.B)/C
b. ABC^/DE*+AC*- ⇒ (A/(B^C) +(D*E)) – (A*C)
Tuliskan programnya dan gunakan stack?

JAWABAN :
#include <stack>
#include <stack>
#include <string>

//variabel global
std::stack<float> s_angka;
std::stack<char> s_op;
//prototipe fungsi
short prioritasOperator(const char op);
bool bandingkanPrioritasOperator(const char op1, const char
op2);
void hitung(const std::string ekspresi);
int main()
{
std::string ekspresi;
std::cout << " \n ";
 IX-14

std::cout << "Nama : Popy Anisa \n ";

std::cout << "NPM : 207006018 \n ";
std::cout << "Kelas : A \n ";
std::cout << "Teknik Informatika \n ";
std::cout << "========================\n ";

std::cout << "silahkan Masukkan ekspresi aritmatika: ";

std::getline(std::cin, ekspresi);

hitung(ekspresi);
std::cout << "\n ";
std::cout << "Hasil operasi ekspresi yang dimasukkan
adalah " << s_angka.top();

return 0;
}

short prioritasOperator(const char op)

{
if(op == '+' or op == '-') return 1;
if(op == '*' or op == '/') return 2;

return 0;
}

bool bandingkanPrioritasOperator(const char op1, const char

op2)
{
return (prioritasOperator(op1) < prioritasOperator(op2));
}
void lakukanOperasiAritmatika()
{
float angka_1 = s_angka.top();
s_angka.pop();

float angka_2 = s_angka.top();

s_angka.pop();
switch(s_op.top())
{
case '+':
angka_2 += angka_1;
break;
case '-':
angka_2 -= angka_1;
break;
case '*':
angka_2 *= angka_1;
break;
 IX-15

case '/':
angka_2 /= angka_1;
break;
}
s_angka.push(angka_2);
}

void hitung(const std::string ekspresi)

{
int len = ekspresi.length();
float angka = 0.0f;

for(int i = 0; i < len; ++i)

{
char token = ekspresi.at(i);
bool apakah_angka = false;

if(token == ' ') continue;

if(token >= '0' and token <= '9')

{
apakah_angka = true;

/*
membentuk angka dari array of char
perulangan akan terus berlangsung selama
karakter yang didapat
dari ekspresi adalah angka dan variabel i
tidak melebihi panjang ekspresi
*/
do
{
angka = angka * 10.f + token - '0';
i = i + 1;

//jika index i melebihi panjang ekspresi,

maka keluar dari perulangan
if(i == len)
{
break;
}

token = ekspresi.at(i);
} while(token >= '0' and token <= '9');
}

//jika token yang didapat sebelumnya adalah angka,

maka masukkan angka ke dalam stack angka
if(apakah_angka == true)
{
 IX-16

s_angka.push(angka);
angka = 0.0f;
}

if (token == '+' or token == '-' or token == '*' or

token == '/')
{
if(s_op.empty() or
!bandingkanPrioritasOperator(token, s_op.top()) or s_op.top()
== '(')
{
s_op.push(token);
}
else if(bandingkanPrioritasOperator(token,
s_op.top()))
{
while(!s_op.empty())
{
lakukanOperasiAritmatika();
s_op.pop();
}

s_op.push(token);
}
}
else if(token == '(')
{
s_op.push(token);
}
else if(token == ')')
{
while(s_op.top() != '(')
{
lakukanOperasiAritmatika();
s_op.pop();
}

s_op.pop();
}
}

while(!s_op.empty())
{
lakukanOperasiAritmatika();
s_op.pop();
}
}
 IX-17

Tampilan pada layar 1

Tampilan pada layar 2

Analisis :
Program ini bertujuan untuk menampilkan Ekspresi Aritmatika dAn
memiliki operator prioritas yang diinputkan . Terdapat beberapa operator
yaitu , operator pangkat ( ^ ) , operator bagi ( / ) , operator kali ( *) , operator
tambah ( + ) , dan operator kurang ( - ) .
- #Include berfungsi untuk menginfor fungsi – fungsi yang sudah di
definisikan pada header file .
 IX-18

- Std digunakan untuk memanggil namespace , atau objek .

- Return berfungsi untuk mengakhiri eksekusi
- ( ) , { } berfungsi untuk mengerjakan suatu program tetapi terpisah
dari yang lainnya .
- Cout adalah fungsi untuk menampilkan teks pada layar output .
- Else if adalah pilihan alternative dari penyelesaian untuk mencari
kondisi yang diinginkan .
- Float digunakan untuk menampung angka pecahan .
- Void adalah sebuah fungsi yang ada dalam sebuah bahasa
pemograman .
- Int main sebagai starting untuk program c ++
- Char berfungsi untuk menampung 1 digit karakter , entah itu huruf
atau angka.
- While berfungsi untuk mengulangi pengeksekusian substatement
yang dilakukan ketika memiliki nilai benar .