PRAKTIKUM 4

STACK

1. Tujuan
Setelah menyelesaikan modul ini, anda diharapkan dapat:
1. Menjelaskan struktur data stack
2. Mendeklarasikan variabel dan tipe data stack
3. Mengoperasikan struktur data stack
4. Mengaplikasikan stack dalam algoritma

2. Teori Dasar
Stack (tumpukan) dan queue (antrian) sebenarnya adalah dua model dalam
mengorganisasikan data-data atau abstraksi data. Stack dapat dianalogikan seperti jika
seseorang menyimpan buku-bukunya dengan cara ditumpuk. Sementara queue dapat
diibaratkan sebagai antrian di tempat pembayaran listrik. Pada modul ini kita akan membahas
tentang stack terlebih dahulu.
Kaidah utama dalam konsep stack adalah LIFO yang merupakan singkatan dari Last In
First Out, artinya adalah data yang terakhir dimasukkan / disimpan adalah data yang pertama
kali akan diakses / dikeluarkan. Jadi pintu masuk dan keluar hanya dari atas saja. Gambar di
bawah ini mengilustrasikan kerja sebuah stack.

Mendeklarasikan stack
Sebuah stack di dalam program komputer dideklarasikan sebagai sebuah tipe bentukan
baru. Sebuah struktur data dari sebuah stack paling tidak harus mengandung dua buah variabel,
yakni variabel TOP yang akan berguna sebagai penanda bagian atas tumpukan dan sebuah
kumpulan data yang berupa array yang akan menyimpan data-data yang dimasukkan ke dalam
stack tersebut. Berikut adalah syntax untuk mendeklarasikan struktur data dari sebuah stack
menggunakan Bahasa C:
typedef struct
{
int TOP;
int data[max+1];
int max;
}Stack;
dimana, nilai MAX didefinisikan sebagai jumlah tumpukan maksimum yang dapat disimpan
dalam stack. Setelah strukutr data dari stack didefinisikan dengan syntax di atas, maka dapat
dibentuk variabel-variabel baru yang mengacu pada tipe data stack di atas, misalkan membuat
sebuah variabel bernama tumpukan yang bertipe Stack, seperti berikut:
Stack tumpukan;
Dalam modul ini, sebuah stack didefinisikan dengan array berukuran MAX + 1,
maksudnya adalah agar elemen array ke-0 tidak digunakan untuk menyimpan data, melainkan
hanya sebagai tempat sementara untuk variabel TOP. Sehingga, jika TOP berada pada elemen
array ke-0, berarti stack tersebut dalam kondisi kosong (tidak ada data yang disimpan). Berikut
adalah ilustrasi dari sebuah stack kosong dengan ukuran nilai MAX = 6:

6
5
4
3
2
1
TOP  0

Operasi-operasi dasar dalam stack

Sebuah stack setidaknya memiliki lima buah operasi-operasi dasar. Operasi-operasi ini
dibentuk dalam fungsi, yakni:
a. Prosedur createEmpty
Prosedur ini berfungsi untuk mengosongkan stack dengan cara meletakkan TOP ke
posisi ke-0. Berikut adalah deklarasi prosedur createEmpty dalam Bahasa C:
void createEmpty()
{
tumpukan.TOP = 0;
}
b. Prosedur push
Prosedur ini berfungsi untuk memasukkan sebuah nilai/data ke dalam stack.
Sebelum sebuah nilai/data dimasukkan ke dalam stack, prosedur ini terlebih dahulu akan
menaikkan posisi TOP satu level ke atas. Misalkan kondisi stack masih kosong
(TOP=0), lalu prosedur push akan menaikkan posisi TOP satu level ke atas, yakni ke
posisi 1 (TOP=1). Setelah itu data dimasukkan ke dalam array pada indeks ke-1 (indeks
dimana TOP berada). Berikut adalah deklarasi prosedur push dalam Bahasa C:
void push(int x)
{
tumpukan.TOP = tumpukan.TOP + 1;
tumpukan.data[tumpukan.TOP] = x;
}
Pada deklarasi prosedur push di atas, prosedur memiliki sebuah parameter x
yang bertipe integer. Parameter ini berguna untuk menerima kiriman nilai dari
program utama (main) yakni berupa sebuah bilangan integer yang akan dimasukkan
ke dalam stack. Sebelum nilai pada x dimasukkan ke dalam stack, terlebih dahulu posisi
TOP dinaikkan satu level, baru setelah itu nilai pada variabel x dimasukkan ke dalam
array data pada indeks dimana TOP itu berada, seperti tampak pada gambar:
 7 7

6 6 6
5 5 5
4 4 4
3 3 3
2 2 2
1 TOP  1 TOP  17

TOP  0 0 0

c. Prosedur pop
Prosedur ini berfungsi untuk mengeluarkan / menghapus nilai yang berada di posisi
paling atas dari stack, dengan cara menurunkan nilai TOP satu level ke bawah.
Misalkan TOP berada pada indeks ke-5, maka ketika akan mengeluarkan / menghapus
data pada posisi paling atas (pada posisi TOP). Deklarasi prosedur pop dalam Bahasa C
sebagai berikut:
void pop()
{
tumpukan.TOP = tumpukan.TOP - 1;
}
3

6 6
TOP  3 5 5
9 4 TOP  9 4
5 3 5 3
2 2 2 2
7 1 7 1
0 0
 d. Fungsi IsEmpty
Fungsi ini berfungsi untuk melakukan pengecekan terhadap stack, apakah stack
tersebut kosong atau tidak. Jika stack tersebut kosong (artinya, TOP berada pada posisi
0), maka fungsi akan mengembalikan nilai 1 (true), tetapi jika stack tersebut tidak
kosong/ berisi (artinya, TOP tidak berada pada posisi 0), maka fungsi akan
mengembalikan nilai 0 (false). Berikut deklarasi fungsi IsEmpty dalam Bahasa C:
int IsEmpty()
{
if (tumpukan.TOP == 0)
return 1;
else
return 0;

e. Fungsi IsFull
Fungsi ini berfungsi untuk melakukan pengecekan terhadap stack, apakah stack
tersebut penuh atau tidak. Jika stack tersebut penuh (artinya, TOP berada pada posisi
MAX), maka fungsi akan mengembalikan nilai 1 (true), tetapi jika stack tersebut tidak
penuh (artinya, TOP tidak berada pada posisi MAX), maka fungsi akan mengembalikan
nilai 0 (false). Berikut deklarasi fungsi IsFull dalam Bahasa C:
int IsFull()
{
if (tumpukan.TOP == MAX)
return 1;
else
return 0;
}

3. Daftar Alat dan Bahan

1. Personal Komputer 1 Unit
2. Software yang sudah ada
4. Keselamatan Kerja
1. Sebelum melakukan langkah percobaan, pastikan kabel power terhubung ke Power Supply.
2. Matikan komputer setelah praktikum selesai.

5. Langkah Kerja
Buatlah program untuk soal-soal di bawah ini
1. Membuat menu program, dimana user diberikan beberapa menu utama. Menu pertama “Cek
kondisi stack” akan melakukan pengecekan terhadap kondisi stack. Menu kedua “Tambah
data” akan melakukan pengisian sebuah nilai ke dalam stack. Menu ketiga, “Tampilkan isi
stack” akan menampilkan semua isi stack dan akan mengosongkan stack. Menu keempat
“Kosongkan stack” akan melakukan pengosongan stack, dan menu kelima “Keluar” akan
menghentikan eksekusi program.

//program implementasi stack

#include <stdio.h>
#include <conio.h>
#define max 5

typedef struct {
int top; //untuk mencacah indeks dari stack
int data[max+1];
}stack;

stack tumpukan;

void createEmpty();
int IsEmpty();
int IsFull();
void push(int x);
void pop();
void main(){
int lagi; int input; int pilih;
createEmpty();
pilih = 0;
while (pilih != 5){
//Menu utama
puts("=====================================");
puts(" MENU UTAMA");
puts("=====================================");
puts("1. Cek kondisi Stack");
puts("2. Tambah data");
puts("3. Tampilkan isi stack");
puts("4. Kosongkan stack");
puts("5. Keluar");
printf("Pilihan: ");
scanf("%d",&pilih);
switch(pilih){
case 1: if (IsEmpty() == 1)
puts("Stack masih kosong");
else if ((IsEmpty() == 0) && (IsFull() == 0))
puts("Stack sudah terisi, tapi belum penuh");
else
puts("Stack sudah penuh");
getch();
break;
case 2: if (IsFull() == 1)
puts("Stack sudah penuh.");
else {
printf("Masukkan data: ");
scanf("%d",&input);
push(input);
printf("%d",tumpukan.top);
printf("%d",IsFull());
printf("%d",IsEmpty());
}
break;
case 3: while (IsEmpty() == 0)
{
 printf("%d \n",tumpukan.data[tumpukan.top]);
pop();
}
getch();
break;
case 4: createEmpty();
puts("Stack sudah kosong. Top = 0");
getch();
break;
case 5: puts(“Byeee………”);
getch();
break;
}
}
}
//DEKLARASI OPERASI-OPERASI DASAR STACK
void createEmpty(){
tumpukan.top = 0;
}

int IsEmpty(){
if (tumpukan.top == 0)
return 1;
else
return 0;
}

int IsFull(){
if (tumpukan.top == max)
return 1;
else
return 0;
}

void push(int x){

 tumpukan.top = tumpukan.top + 1;
tumpukan.data[tumpukan.top] = x;
}

void pop(){
tumpukan.top = tumpukan.top - 1;
}

2. Susun program untuk menyiapkan array atau dimensi yang akan digunakan sebagai stack S
sebanyak 10 elemen, bertipe integer. Kemudian lakukan proses simpan data ke stack (PUSH)
atau proses mengeluarkan isi stack (POP) dengan proses sebagai berikut:
a. Inputkan data dari keyboard. Bila data yang diinput bernilai 999 maka proses selesai.
b. Bila data yang diinptu bernialai >= 60, maka periksa kondisi stack. Bila stack masih bisa
diisi, maka simpan data tersebut (PUSH) kedalam stack, dan proses diulangi kembali mulai
no1. Tapi bila stack sudah penuh, data tidak jadi disimpan, kemudian cetak perkataan
“stack Penuh”, dan proses selesai.
c. BIla data yang diinput <60, maka periksa kondisi stack. BIla stack ada isinya, maka ambil
isi stack dan cetak ke layar, kemudian proses diulangi kembali mulai no. 1. Bila stack tidak
ada isinya, maka cetak “Stack Kosong”, dan proses selesai.

Dalam contoh program ini, stack mulai terisi dari indeks 0.

#include<stdio.h>
#define n 10
void main ()
{ int S[n], Top, X;

Top = 0;

scanf("%i", &X);
while(X !=999 )
{if(X >= 60)
{
if(Top < n)
{Top = Top + 1; S[Top] = X;
}
else { printf("Stack Penuh");
break;
}
}
else
{ if( Top > 0)
{
X = S[Top]; Top = Top - 1;
 printf("Diambil : %i\n", X);
}
else { printf("Stack KOsong");
break;
}
}
scanf("%i", &X);

}
printf("\nS e l e s a i ");
}

3. Mengisi (PUSH) stack sampai PENUH, dan mengambil (POP) isi stack sampai KOSONG.
Susun Program untuk menyiapkan array satu dimensi yang akan digunakan sebagai stack S
sebanyak 10 elemen, bertipe integer. Kemudian inputkan data (nilai numeric) dan simpan
(PUSH) se stack S. Proses input dan PUSH selesai bila data yang diinput bernilai = 999, atau
stack S penuh. (Nilai 999 dipakai sebagai end of data, tidak ikut diPush ke stacks). Setelah itu
keluarkan (POP) isi stack dan cetak ke layar satu per satu sampai stack menjadi kosong

//program stack
#include<stdio.h>
#define n 4
int S[n+1], Top, X;
void main()
{
Top = 0; //stack kosong
// Input & PUSH
X = 0;
while(X !=999)
{
if(Top < n)
{ Top++;
printf("No %i : ",Top);
scanf("%i", &X);
S[Top] = X;
}
else
{printf("Stack Penuh\n");
break;
}
}

printf("\nInput & PUSH Selesai\n");

// POP & print

 while(Top > 0){
X = S[Top];
printf("%i : %i ", Top, X);
Top--;
}
}
4. Menginput sebuah persamaan matematika (tidak lebih dari 20 karakter). Kemudian periksa
kurung buka dan kurung tutup apakah tepat saling berpasangan. Cetak perkataan ”BENAR”
bila tepat saling berpasangan, atau perkataan “SALAH” bila ada yang tidak tepat saling
berpasangan: (ket: stack kosong ketika top = -1)

Contoh : Bila diinput : maka cetak :

A + B * C – D / E BENAR
A + B * (C – D) / E BENAR
( A + B) * ( C – D ) / E BENAR
( A + B * (C – D) / E) BENAR
( A + B * (C – D) / E SALAH
( A + B * (C – D) / E SALAH
) A + B * (C – D / E SALAH
( A + B ( * (C – D) / E SALAH
(A + B ) * ) C – D) / E SALAH

Petunjuk :
Telusuri karakter per karakter isi pernyataan matematika sampai ditemui karakter NULL ( \0
).
- Bila terbaca karakter kurung buka (, maka simpan (PUSH) kurung buka tersebut ke
dalam stack .
- Bila terbaca karakter kurung tutup ), maka periksa isi stack.
Bila stack ada isinya , maka keluarkan (POP) sebuah isi stack, yaitu sebuah kurung buka (.
Tapi bila isi stack KOSONG berarti kurung buka dan kurung tutup tidak berpasangan,
maka cetak perkataan SALAH dan proses selesai.
- Setelah semua karakter telah ditelusuri, sampai ditemukan karakter NULL, maka periksa
isi stack.
Bila isi stack KOSONG (Top = 1), berarti kurung buka dan kurung tutup telah saling
berpasangan, maka cetak perkataan BENAR dan proses selesai.
Bila isi stack masih ada (Top > - 1), berarti kurung buka lebih banyak dari kurung tutup
sehingga cetak perkataan SALAH dan proses selesai.
#include<stdio.h>
#include<conio.h>
#define n 31
char A[n], S[n], X ;
int Top, I, Flag ;
void PUSH (char X) ;
void POP, (char X) ;
int main ()
{ Flag = 0 ;
Printf (“Inputkan Arithmetic Statement : ” ) ;
scan (“%s”, A ) ;

Top = 1 ;
i = 0 ;
while (A[i] ! = NULL )
{
if ( A[i] == ‘(‘ )
{
PUSH ( A[i] ) ; //simpan kurung di stack
If (Flag == 1) //Flag diubah di dalam fungsi PUSH
Jika Flag == 1, berarti
Break;
PUSH dihentikan
}
segera
else
{
if (A [i] == ‘)’)
{
POP (A [i] ; // ambil kurung buka dari stack
If (Flag == 1 ) // Flag di ubah dalam fungsi POP
Break ;
Jika Flag == 1, berarti POP
}
tida adi dilaksanakan
}
karena Stack sudah kosong
i++ ; .
}
If (Flag == 0 ) Jika Stack penuh, tak bisa
{ if ( Top > -1 ) lagi diisi lagi, sebagai tanda,
printf (“SALAH, kurung buka tak ada Flag dibuat = 1
pasangannya” ) ;
} Jika Stack kosong, tak
Getch () ; ada isi yang bisa di ambi,
Return (0) ; sebagai tanda, Flag
} dibuat =1

void PUSH (char X)

{ if (Top < - 1) { Top++; S[ Top ] = X ; }
Else
{printf (“stack penuh ” ) ; Flag = 1 ; }
}

void POP (char X )

{ if (Top > -1 ) { X = S [Top] = X ; }
else
{ printf (“SALAH kurung tutup tak ada
pasangannya ”) ;
Flag = 1 ;
}
}
Perbaikan

#include<stdio.h>

#include<conio.h>

#define n 31

char A[n], S[n], X ;

int Top, i, Flag ;

void PUSH(char X) ;

void POP(char X) ;

main(){

Flag = 0 ;

printf ("Inputkan Arithmetic Statement : " ) ;

scanf("%s",&A) ;

Top = 0 ;

int i = 0 ;

while(A[i] != NULL)

if(A[i] == '(')

PUSH (A[i]); //simpan kurung di stack

if(Flag == 1) //Flag diubah di dalam fungsi PUSH

break;

else{

if(A[i] == ')'){

POP(A[i]); // ambil kurung buka dari stack

 if(Flag == 1) // Flag di ubah dalam fungsi POP

break ;

i++;

/*if(Flag == 0){

if(Top > -1)

printf ("SALAH, kurung buka tak ada pasangannya");

*/

if(Top == 0){

printf("Persamaan benar");

else

printf("Persamaan salah");

printf("\n");

void PUSH (char X){

if (Top>-1) {

Top++;

S[ Top ] = X ;
 }

else{

printf("stack penuh " ) ;

Flag = 1;

void POP(char X ){

if (Top>-1){

//X = S [Top] = X ;

Top--;

else{

printf ("SALAH kurung tutup tak ada pasangannya ") ;

Flag = 1 ;