TUMPUKKAN
(STACK) PADA C++
1.
Definisi
Stack
Stack (tumpukan) merupakan sebuah
cara dalam mengorganisasikan data-data yang dimiliki. Stack digunakan sebagai penyimpanan data didalam memori. Kaidah
utama dalam stack adalah LIFO yang
merupakan singkatan dari Last In First
Out, artinya adalah data yang terakhir dimasukkan adalah data yang pertama
kali akan diakses atau dikeluarkan.
2.
Deklarasi
Stack
Sebuah
struktur data dari sebuah stack setidaknya
memiliki dua buah variabel, yaitu satu variabel yang akan digunakan sebagai
penanda bagian atas tumpukkan dan array data yang akan menyimpan data – data
yang dimasukkan kedalam stack.
Berikut adalah syntax untuk
mendeklarasikan struktur data dari sebuah stack
:
struct
nama_struct
{ int var1;
int var2[max]
}stack;
|
Contoh :
struct
tumpukkan
{ int atas;
int isi[max]
}t;
|
Dimana,
nilai “max” didefinisikan sebagai jumlah tumpukan maksimum yang dapat disimpan
dalam stack. Stack didefinisikan
dengan array berukuran max, berarti
benyaknya data yang dapat disimpan adalah sebanyak max yang nanti ditentukan
ukurannya.
Operasi-Operasi Dasar Dalam Stack :
createEmpty
Prosedur
ini berfungsi untuk mengosongkan stack
dengan cara meletakkan variabel1 ke posisi 0. Pendeklarasiannya adalah sebagai
berikut :
Void
createEmpty ()
{
t.atas=0;
}
|
Push
Prosedur
ini berfungsi untuk memasukkan nilai atau data kedalam stack. pendeklarasiannya adalah sebagai berikut :
Void
push (int data)
{ t.atas++;
t.data[t.atas]=data;
}
|
Pop
Prosedur
ini berfungsi untuk mengeluarkan/menghapus nilai terakhir atau nilai yang
berada paling atas didalam stack.
pendeklarasiannya adalah sebagai berikut:
void
pop()
{
t.atas = t.atas - 1;
}
|
IsEmpty
Fungsi
ini berfungsi untuk melakukan pengecekkan terhadap stack, apakah stack
tersebut kosong atau tidak. Jika stack
kosong artinya variabel atas pada posisi 0 atau stack tersebut tidak ada isinya maka fungsi akan mengembalikan nila
1 (true), namun jika sebaliknya
fungsi akakn mengembalikan nilai 0 (false).
Deklarasinya :
void
isEmpty ()
{
if (t.atas == 0)
return 1;
else
return 0;
}
|
IsFull
Fungsi
ini berfungsi untuk melakukan pengecekkan terhadap stack, apakah stack
tersebut penuh atau tidak. Jika stack penuh yang berarti variabel atas
salam posisi max), maka fungsi akan mengembalikan nilai 1 (true), namun jika kebalikannya adakan mengembalikan nilai 0 (salah).
Deklarasinya
adalah :
void IsFull()
{
if (t.atas == max)
return 1;
else
return 0;
}
|
Contoh Program Implementasi Stack
Berikut
adalah contoh kode program yang mengimplementasikan konsep stack.
Contoh 1:
Pada
program ini, user disuguhi beberapa
menu utama yang akan dipilih. 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, “Keluarkan
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 (selesai menggunakan
program).
Input :
#include
<stdio.h>
#include
<conio.h>
#include
<windows.h>
#define
max 5
struct
tumpukan{
int
atas; //untuk mencacah indeks dari stack
int
data[max+1];
}t;
void
createEmpty();
int
IsEmpty();
int
IsFull();
void
push(int x);
void
pop();
main()
{
int
lagi;
int
input;
int
pilih;
createEmpty();
pilih =
0;
while
(pilih != 5){
system("cls");
puts("=====================================");
puts("
MENU UTAMA");
puts("=====================================");
puts("1.
Cek kondisi Stack");
puts("2.
Tambah data");
puts("3.
Keluarkan 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",t.atas);
printf("%d",IsFull());
printf("%d",IsEmpty());
}
break;
case 3:
while (IsEmpty() == 0)
{
printf("%d
\n",t.data[t.atas]);
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(){
t.atas
= 0;
}
int
IsEmpty(){
if
(t.atas == 0)
return
1;
else
return
0;
}
int
IsFull(){
if
(t.atas == max)
return
1;
else
return
0;
}
void
push(int x){
t.atas
= t.atas + 1;
t.data[t.atas]
= x;
}
void
pop(){
t.atas
= t.atas - 1;
}
|
Output :
Mengecek
kondisi stack
Memasukkan
data kedalam stack. Data yang dimasukkan adalah 6.
Mengeluarkan
isi stack yang tadi dimasukkan, yaitu 6.
Memasukkan
data kedalam stack, data yang dimasukkan adalah 7.
Melakukan
pengecekkan kondisi stack.
Mengosongkan
stack.
Keluar
dari program
Contoh 2
:
Pada
program ini tersedia beberapa pilihan yang akan dipilih oleh user. Pilihan pertama adalah
“Menambahkan Data” yang berfungsi untuk menambahkan data kedalam stack. Pilihan kedua adalah “Menghapus
Data Teratas”, yang berfungsi untuk menghapus data teratas atau data yang
terakhir dimasukkan. Pilihan ketiga adalah “Menampilkan Data Teratas”, yang
berfungsi untuk menampilkan data teratas atau data yang terakhir dimasukkan.
Pilihan keempat adalah “Cek Kondisi Stack”
yang berfungsi untuk mengecek kondisi stack
apakah masih kosong atau sudah penuh, fungsi ini juga akan menampilkan jika stack sudah terisi namun belum penuh dan
masih bisa diisi. Pilihan kelima adalah “Menampilkan Seluruh Data yang
Dimasukkan”, yang berfungsi untuk menampilkan seluruh data yang sudah
dimasukkan. Pilihan keenam adalah “Menghapus Seluruh Data yang Dimasukkan”,
yang berfungsi untuk menghapus seluruh data yang sudah dimasukkan yang
bertujuan untuk mengosongkan stack.
Pilihan ketujuh adalah “Keluar”, yang
berfungsi untuk keluar dari program.
Input :
#include
<iostream>
#include
<conio.h>
#include
<stdlib.h>
#define
max 5
using
namespace std;
struct
tumpukan
{
int atas;
int data[max];
}t;
void
createEmpty ()
{
t.atas=0;
}
int
kosong()
{
if(t.atas==0)
return 1;
else
return 0;
}
int
push(int data)
{
t.atas++;
t.data[t.atas]=data;
cout<<"\tData
"<<t.data[t.atas]<<" masuk ke stack";
}
void
pop()
{
t.atas=t.atas-1;
cout<<"\tData Teratas Sudah di
Hapus";
}
int
isempty()
{
if(t.atas == 0)
{return 1;
cout<<"\tStack Kosong";}
else
{return 0;
cout<<"\tStack ada
isinya";}
}
int
isfull()
{
if(t.atas==max)
{return 1;
cout<<"\tStack Penuh";}
else
{return 0;
cout<<"\tStack masih bisa
diisi";}
}
void
top ()
{
if (kosong()==0)
cout<<"\tData yang paling atas
adalah :"<<t.data[t.atas];
else
cout<<"\tStack kosong";
}
void
tampil()
{
if (kosong()==0)
{
for (int i=t.atas;i>0;i--)
{
cout<<"\n \tTumpukkan
ke "<<i<<"="<<t.data[i];
}
}
else
cout<<"\tTumpukkan
kosong";
}
void
Del ()
{
t.atas=0;
cout<<"\tTumpukkan
kosong";
}
main ()
{
int pil, data;
createEmpty();
do
{
system("cls");
cout<<"\t\tPILIHAN"<<endl;
cout<<"\t1.Menambahkan Data
"<<endl;
cout<<"\t2.Menghapus Data
Teratas"<<endl;
cout<<"\t3.Menampilkan Data
teratas"<<endl;
cout<<"\t4.Cek Kondisi
Stack"<<endl;
cout<<"\t5.Menampilkan
Seluruh Data yang Dimasukkan"<<endl;
cout<<"\t6.Menghapus
Seluruh Data yang Dimasukkan"<<endl;
cout<<"\t7.Keluar"<<endl;
cout<<"\tMasukkan Pilihan :
";cin>>pil;
switch (pil)
{
case 1: cout<<"\tMasukkan
Data = "; cin>>data;
push(data); break;
case 2: pop(); break;
case 3: top(); break;
case 4: if (isempty() == 1)
cout<<"\tStack masih kosong";
else if ((isempty() == 0) &&
(isfull() == 0))
cout<<"\tStack sudah terisi, tapi belum penuh";
else
cout<<"\tStack sudah penuh";break;
case 5: tampil(); break;
case 6: Del(); break;
case 7:
cout<<"\t\tTerimakasih, tekan enter untuk keluar";
}
getch();
}
while (pil!=7);
}
|
Output :
Memasukkan
data kedalam stack.
Melakukan
pengecekkan kondisi stack.
Memasukkan
data kedalam stack.
Menampilkan
data yang berada pada urutan paling atas didalam stack.
Menampilkan
seluruh data yang berada didalam stack.
Menghapus
data teratas.
Menampilkan
data yang berada didalam stack.
Melakukan
pengecekkan kondisi stack.
Keluar Mengahapus
seluruh data yang berada didalam stack dari
program.
Sumber :
Saputri, S. (2016). Stack (Tumpukkan). Modul Alpro 2-1, 56-68.
Komentar
Posting Komentar