Algoritma dan Struktur Data

Stack dan Queue

Christine Dewi. S.Kom

Stack
Stack atau tumpukan adalah suatu stuktur
data yang penting dalam pemrograman
Bersifat LIFO (Last In First Out)
Benda yang terakhir masuk ke dalam stack
akan
menjadi
benda
pertama
yang
dikeluarkan dari stack

Operasi / Fungsi pada Stack

Push : digunakan untuk menambah item pada stack
pada tumpukan paling atas
Pop : digunakan untuk mengambil item pada stack
pada tumpukan paling atas
Clear : digunakan untuk mengosongkan stack
IsEmpty : fungsi yang digunakan untuk mengecek
apakah stack sudah kosong
IsFull : fungsi yang digunakan untuk mengecek
apakah stack sudah penuh

Inisialisasi Stack
Definisikan Stack dengan menggunakan struct
Contoh : typedef struct STACK
{ int top;
char data[10][10];
};
Definisikan MAX_STACK untuk maksimum isi stack
Contoh : #define MAX_STACK 10 //hati-hati mulai dari 0 jadi 0-9
Buatlah variabel array data sebagai implementasi stack secara
nyata
Contoh : STACK tumpuk;
Pada mulanya isi top dengan -1, karena array dalam C dimulai
dari 0, yang berarti stack adalah KOSONG!
Top adalah suatu variabel penanda dalam STACK yang
menunjukkan elemen teratas stack sekarang. Top Of Stack akan
selalu bergerak hingga mencapai MAX of STACK sehingga
menyebabkan stack PENUH!

Ilustrasi Stack Saat Inisialisasi

9

MAX_STACK

8
7
6
5

void inisialisasi()
{
tumpuk.top = -1;
}

4
3
2
1
0

Top=-1

Fungsi IsFull
Untuk memeriksa apakah stack sudah penuh?
Dengan cara memeriksa top of stack, jika sudah sama
dengan MAX_STACK-1 maka full, jika belum (masih
lebih kecil dari MAX_STACK-1) maka belum full.
int IsFull()
{
if(tumpuk.top == MAX_STACK-1)
return 1;
else
return 0;
}

Fungsi IsEmpty
Untuk memeriksa apakah stack masih kosong?
Dengan cara memeriksa top of stack, jika masih -1
maka berarti stack masih kosong!
int IsEmpty()
{
if(tumpuk.top == -1)
return 1;
else
return 0;
}

Fungsi Push
Untuk memasukkan elemen ke stack, selalu menjadi
elemen teratas stack
Tambah satu (increment) nilai top of stack terlebih
dahulu setiap kali ada penambahan elemen stack,
asalkan stack masih belum penuh, kemudian isikan
nilai baru ke stack berdasarkan indeks top of stack
setelah ditambah satu (diincrement)
void Push(char d[10])
{
tumpuk.top++;
strcpy(tumpuk.data[tumpuk.top],d);
}

Fungsi Pop
Untuk mengambil elemen teratas dari stack.
Ambil dahulu nilai elemen teratas stack dengan
mengakses top of stack, tampilkan nnilai yang akan
diambil terlebih dahulu, baru didecrement nilai top
of stack sehingga jumlah elemen stack berkurang

void Pop()
{
printf("Data yang terambil = %s\n",tumpuk.data[tumpuk.top
tumpuk.top--;
}

Fungsi Print
Untuk menampilkan semua elemen-elemen stack
Dengan cara looping semua nilai array secara
terbalik, karena kita harus mengaksesdari indeks
array tertinggi terlebih dahulu baru ke indeks yang
kecil!
void TampilStack()
{
for(int i=tumpuk.top;i>=0;i--)
{
printf("Data : %s\n",tumpuk.data[i]);
}
}

Program Lengkap Stack

#include <stdio.h>
#include <conio.h>
#include <string.h>
#define MAX_STACK 10
typedef struct STACK { int top;
char data[10][10];
};
STACK tumpuk;
void inisialisasi()
{ tumpuk.top = -1;}
int IsFull()
{ if(tumpuk.top == MAX_STACK-1) return 1;
else return 0;}
int IsEmpty()
{ if(tumpuk.top == -1) return 1; else return
0;}
void Push(char d[10])
{ tumpuk.top++;
strcpy(tumpuk.data[tumpuk.top],d); }
void Pop()
{ printf("Data yang terambil =
%s\n",tumpuk.data[tumpuk.top]);
tumpuk.top--; }
void Clear()
{ tumpuk.top=-1; }
void TampilStack()
{ for(int i=tumpuk.top;i>=0;i--)
{ printf("Data : %s\n",tumpuk.data[i]); }
}

int main()
{
int pil;
inisialisasi();
char dt[10];
do{ printf("1. push\n");
printf("2. pop\n");
printf("3. print\n");
printf("4. clear\n");
printf("5. exit\n");
printf("Pilihan : ");
scanf("%d",&pil);
switch(pil)
{
case 1: if(IsFull() != 1)
{ printf("Data =
");scanf("%s",dt);
Push(dt); }
else printf("\nSudah
penuh!\n");
break;
case 2: if(IsEmpty() != 1)
Pop();
else
printf("\nMasih
kosong!\n");
break;
case 3: if(IsEmpty() != 1)
TampilStack();
else
printf("\nMasih
kosong!\n");
break;
case 4: Clear();
printf("\nSudah
kosong!\n");
break;
}
getch();
} while(pil != 5);
getch();
}

output

Queue / Antrian
Elemen yang pertama kali masuk ke antrian akan
keluar pertama kalinya.
DEQUEUE adalah mengeluarkan satu elemen dari
suatu Antrian
Terdapat satu buah pintu masuk di suatu ujung dan
satu buah pintu keluar di ujung satunya
Sehingga membutuhkan variabel Head dan Tail
Deklarasi Queue : #define MAX 8
typedef struct{ int data[MAX];
int head;
int tail;
} Queue;
Queue antrian;

Operasi dalam Queue

Create ( )
Untuk menciptakan dan menginisialisasi Queue
Dengan cara membuat Head dan Tail = -1

IsEmpty ( )

void Create()
{
antrian.head=antrian.tail=
}

Untuk memeriksa apakah Antrian sudah penuh atau belum

Dengan cara memeriksa nilai Tail, jika Tail = -1 maka empty
Kita tidak memeriksa Head, karena Head adalah tanda untuk kepala antrian
(elemen pertama dalam antrian) yang tidak akan berubah-ubah
Pergerakan pada Antrian terjadi dengan penambahan elemen Antrian
kebelakang, yaitu menggunakan nilai Tail
int IsEmpty()
{ if(antrian.tail==-1)
return 1;
else
return 0;
}

Operasi dalam Queue

IsFull
Untuk mengecek apakah Antrian sudah penuh atau belum
Dengan cara mengecek nilai Tail, jika Tail >= MAX-1 (karena MAX-1 adalah
batas elemen array pada C) berarti sudah penuh
int IsFull()
{ if(antrian.tail==MAX-1) return 1;
else return 0;
}

void Enqueue(int data)

{if(IsEmpty()==1)
Untuk menambahkan elemen ke dalam
{antrian.head=antrian.tail=0;
antrian.data[antrian.tail]=data;
Antrian, penambahan elemen selalu
printf("%d masuk!",antrian.data[ant
ditambahkan di elemen paling belakang.
} else
Penambahan elemen selalu
if(IsFull()==0)
{antrian.tail++;
menggerakan
antrian.data[antrian.tail]=data;
variabel Tail dengan cara increment
printf("%d masuk!",antrian.data[ant
}
counter Tail
}

Enqueue (data)

Operasi dalam Queue

Dequeue()
Digunakan untuk menghapus elemen terdepan/pertama dari
Antrian
Dengan cara mengurangi counter Tail dan menggeser semua
elemen antrian kedepan.
Penggeseran dilakukan dengan menggunakan looping
int Dequeue()
{
int i;
int e = antrian.data[antrian.head];
for(i=antrian.head;i<=antrian.tail-1;i++)
{ antrian.data[i] = antrian.data[i+1]; }
antrian.tail--;
return e;
}

Operasi dalam Queue

Clear()
Untuk menghapus elemen-elemen Antrian dengan cara
membuat Tail dan Head = -1
Penghapusan elemen-elemen Antrian sebenarnya tidak
menghapus arraynya, namun hanya mengeset indeks
pengaksesan-nya

void Clear()
{antrian.head=antrian.tail=-1;
printf("data clear");}

void Tampil()
Tampil
Untuk menampilkan nilai-nilai { if(IsEmpty()==0)
{ for(int i=antrian.head;i<=antria
elemen Antrian
{ printf("%d ",antrian.data[i]);
Menggunakan looping dari
}
}else printf("data kosong!\n");
head s/d tail
}

See You Next Week