LAPORAN PRAKTIKUM

STRUKTUR DATA
DAN ALGORITME
MODUL VIII
“QUEUE”

Disusun oleh :
Muhamad Taufiq Hidayat
21102206

Dosen Pengampu :
Muhammad Afrizal Amrustian, S. Kom., M. Kom

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS INFORMATIKA
INSTITUT TEKNOLOGI TELKOM PURWOKERTO
2022
 BAB I
‘TUJUAN’

1. Mahasiswa mampu menjelaskan definisi dan konsep dari Double Queque

2. Mahasiswa mampu menerapkan operasi tamba, menghapus pada Queque
3. Mahasiswa mampu menerapkan operasi tampil data pada queque
 BAB II
‘DASAR TEORI’

Introduction
Selamat datang pada bagian 5 dari seri pengenalan Struktur Data. Bagian 4
dari seri ini mengenai List Berkait Ganda dapat dilihat disini) , dan overview
Algoritma dan Struktur Data dapat dilihat disini . Pada bagian ini, saya akan
mendalami struktur data Queue.

Apa itu Queue?

Queue atau Antrian merupakan struktur data yang bisa direpresentasikan
secara kontigu maupun dengan pointer. Struktur data ini menganut prinsip
FIFO (First-In-First-Out / Masuk Pertama Keluar Pertama), sama seperti
antrian pada dunia nyata. Orang yang mengantre duluan, akan dilayani lebih
cepat daripada yang mengantre belakangan.

Mengupas Struktur Data Queue

Lebih Dalam
Mari kita lihat deklarasi sebuah Queue dalam C yang menyimpan data int,
dengan representasi kontigu statik:
typedef struct { int * Tab; /* tabel penyimpan elemen */
int HEAD; /* indeks elemen paling awal (terdepan) */
int MaxEl; /* kapasitas jumlah elemen */
} Queue;
Pada deklarasi ini, sebuah Queue memiliki 3 atribut. *Tab merupakan array of
int yang menyimpan data Queue. Head merupakan alamat indeks penyimpanan
yang terdepan, atau First, dan MaxEl menyatakan kapasitas elemen yang dapat
ditampung Queue.
Disini, atribut yang penting untuk dibahas adalah Head. Dalam semua jenis
representasi Queue, Head penting untuk disimpan karena menandakan elemen
mana yang akan dihapus jika kita melakukan delete, mengingat prinsip
FIFO. Tail atau Last bisa juga disimpan pada Queue untuk mengetahui posisi
penempatan elemen baru, namun pada kasus ini digunakan MaxEl, yang
sebenarnya juga memiliki fungsi yang mirip.

Fungsi-fungsi pada Queue

Pada Queue, karena perubahan data selalu mengacu pada Head, maka hanya
ada 1 jenis insert maupun delete. Prosedur ini sering
disebut Enqueue dan Dequeue pada kasus Queue. Untuk Enqueue, cukup
tambahkan elemen setelah elemen terakhir Queue, dan untuk Dequeue,
cukup "geser"kan Head menjadi elemen selanjutnya.

Representasi Queue Lainnya

Queue bisa juga direpresentasikan dengan pointer. Sebenarnya, tidak ada
perbedaan yang mencolok dari segi fungsinya antara Queue kontigu dengan
Queue berkait, hanya saja membutuhkan next yang "menunjuk" ke elemen
selanjutnya (perhatikan kembali konsep Linked List), dan elemen
terakhirnya menunjuk ke null. Dalam representasi ini, mungkin lebih cocok
menyimpan Last juga supaya tidak perlu melakukan search untuk mencari
elemen terakhirnya setiap kali ingin menambahkan elemen.
Di sisi lain, Queue yang menjalar ke kanan sepertinya tidak efektif jika
dinyatakan secara kontigu dan statik. Apakah ada cara lain
merepresentasikan Queue secara kontigu dan statik? Jawabannya adalah
menggunakan Circular Buffer, seperti demikian:
Dengan demikian, kita harus menyimpan Tail dan Head, dimana kedua atribut
ini akan "bergerak" dalam Queue kita setiap kali ada penyisipan maupun
pengambilan elemen. Jika Head sudah melebihi index maksimum, maka
cukup geser Head kembali ke indeks pertama array. Dengan demikian,
penggunaan memori pada Queue yang statik dan kontigu dapat
dimanfaatkan dengan lebih baik.

Aplikasi Queue dalam Dunia

Nyata
Dibandingkan struktur-struktur sebelumnya, aplikasi Queue dalam dunia
nyata lebih mudah dibayangkan. Struktur data ini cocok untuk menyimpan
data seperti waiting list suatu restoran, misalnya. Pelanggan yang sudah
menunggu lebih lama akan lebih dulu mendapatkan tempat duduk setelah
tempat duduknya tersedia dibandingkan pelanggan yang baru datang (ingat
lagi FIFO). Secara low-level, banyak juga task komputer yang dijalankan
dengan Queue, misalnya CPU task scheduling.
Namun, bagaimana jika kita menginginkan sebuah Queue yang tidak
selalu mendahulukan urutan saat insert? Salah satu aplikasi dari konsep ini
adalah Priority Queue, dimana elemen dengan "prioritas" yang lebih besar
akan ditempatkan lebih dekat dengan Head, dan nantinya mengakibatkan
elemen tersebut di-dequeue dengan lebih mudah. Contoh dari aplikasi ini
adalah penyimpanan data antrian Rumah Sakit. Pasien dengan penyakit yang
lebih darurat akan dianggap memiliki "prioritas" yang lebih tinggi, sehingga
akan lebih cepat dilayani (dequeue dari waiting list) dibandingkan pasien
yang penyakitnya ringan.
Referensi
Terima kasih telah membaca bagian 5 dari seri Struktur Data ini, semoga
bermanfaat. Pada bagian berikutnya kita akan membahas struktur data Stack.

https://kotakode.com/blogs/4468/Mengenal-Struktur-Data---5%3A-Queue
 BAB III
• GUIDED

1. Guided 1

#include <iostream>
using namespace std;
//queue array
int maksimalQueue = 5;//maksimal antrian
int front = 0;//penanda antrian
int back = 0;//penanda
string queueTeller[5];
//fungsi pengecekan
bool isFull(){//pengecekan antrian penuh atau tidak
if(back == maksimalQueue){
return true;//=1
}else{
return false;
}
}
//fungsi pengecekan
bool isEmpty(){//antriannya kosong atau tidak
if(back==0){
return true;
}else{
return false;
}
}
//fungsi menambahkan antrian
void enqueueAntrian(string data){
if(isFull()){
cout << "antrian penuh"<<endl;
}else{//nested if, nested for
if(isEmpty()){//kondisi ketika queue kosong
queueTeller[0]=data;
front++;//front = front +1;
back++;
}else{//antrianya ada isi
queueTeller[back]=data;//queueTeller[1]=data

1
 back++;//back=back+1; 2
}
}
}
//fungsi mengurangi antrian
void dequeueAntrian(){
if(isEmpty()){
cout << "antrian kosong"<<endl;
}else{
for(int i=0; i<back; i++){
queueTeller[i]=queueTeller[i+1];
}back--;
}
}
//fungsi menghitung banyak antrian

int countQueue(){
return back;
}
//fungsi menghapus semua antrian
void clearQueue(){
if(isEmpty()){
cout << "antrian kosong"<<endl;
}else{
for(int i=0; i<back; i++){
queueTeller[i]="";
}
back=0;
front=0;
}
}
//fungsi melihat antrian
void viewQueue(){
cout << "data antrian teller : "<<endl;
for(int i =0; i<maksimalQueue; i++){
if(queueTeller[i]!=""){
cout << i+1 << ". " <<queueTeller[i]<<endl;
}else{
cout << i+1 << ". (kosong)" <<endl;
}
}
}

2
int main()
{
enqueueAntrian("Andi");
enqueueAntrian("Maya");
viewQueue();
cout << "jumlah antrian = " << countQueue()<<endl;
dequeueAntrian();
viewQueue();
cout << "jumlah antrian = " << countQueue()<<endl;
clearQueue();
viewQueue();
cout << "jumlah antrian = " << countQueue()<<endl;
return 0;
}

Seperti itulah

3
 • UNGUIDED

Unguided 1
Ubahlah penerapan konsep queue pada bagian guided dari array menjadi linked list

Code
#include <iostream>
using namespace std;

// array Antrian
int maksimalAntrianArray = 5, front = 0, back = 0;
string nama;
int umur;
// ruang antrian array
string antrianAtm[5];
// siapin ruang antrian
struct antrianAtmLL{
// data / member
string nama;
int umur;

// pointer next
antrianAtmLL *next;
}*head, *tail, *cur, *del, *newNode;

int maksimalAntrianLinkedList = 5;

void init()
{
head = NULL;
tail = NULL;
}
// isFull / cek data antrian penuh atau tidak
bool isFullArray()
{
if( back == maksimalAntrianArray ){
return true;
}else{
return false;
}
}

4
// isEmpty
bool isEmptyArray()
{
if( back == 0 ){
return true;
}else{
return false;
}
}

// enqueue / penambahan data antrian

void enqueueArray(string data){

if( isFullArray() ){
cout << "Antrian penuh!!" << endl;
}else{
// cek apakah datanya kosong atau tidak
if( isEmptyArray() ){
// kalau antrian kosong
antrianAtm[0] = data;
front++;
back++;
}else{
// kalo gak kosong
antrianAtm[back] = data;
back++;
}
}

// dequeue / penghapusan data depan

void dequeueArray(){
if( isEmptyArray() ){
cout << "Antrian kosong!!" << endl;
}else{
for( int i = 0; i < back; i++ ){
antrianAtm[i] = antrianAtm[i+1];
}
back--;
}
}

5
// countArray / menghitung banyak data yg ngantri
int countArray()
{

if( isEmptyArray() ){
return 0;
}else if( isFullArray() ){
return maksimalAntrianArray;
}else{
return back;
}

// destroy / clear
void destroyArray(){
if( isEmptyArray() ){
cout << "Antrian kosong!!" << endl;
}else{
for( int i = 0; i < maksimalAntrianArray; i++ ){

if( back > 1 ){

antrianAtm[back - 1] = "";
back--;
}else if( back == 1 ){
antrianAtm[back - 1] = "";
back = 0;
front = 0;
}

}
}
}

// Display / View
void viewArray()
{
cout << "Jumlah data yg ngantri : " << countArray() << "data." << endl;
cout << "Data Antrian Atm : " << endl;
if( isEmptyArray() ){
cout << "Antrian kosong!!" << endl;
}else{

6
 for( int i = 0; i < maksimalAntrianArray; i++ ){
// cek apakah ruang kosong atau tidak
if( antrianAtm[i] != "" ){
// kalau ruang tidak kosong
cout << i+1 << ". " << antrianAtm[i] << endl;
}else{
// kalo kosong
cout << i+1 << ". (kosong)" << endl;
}
}
}
cout << "\n" << endl;
}

// count Linked List

int countLinkedList()
{
if( head == NULL ){
return 0;
}else{
int banyak = 0;
cur = head;
while( cur != NULL ){
cur = cur->next;
banyak++;
}
return banyak;
}
}

// isFull Linked List

bool isFullLinkedList()
{
if( countLinkedList() == maksimalAntrianLinkedList ){
return true;
}else{
return false;
}
}

7
// isEmpty Linked List
bool isEmptyLinkedList()
{
if( countLinkedList() == 0 ){
return true;
}else{
return false;
}
}

// enqueue / penambahan
void enqueueLinkedList( string nama, int umur ){

if( isFullLinkedList() ){
cout << "Antrian Penuh!!!" << endl;
}else{

if( isEmptyLinkedList() ){

head = new antrianAtmLL();

head->nama = nama;
head->umur = umur;
head->next = NULL;
tail = head;
}else{
newNode = new antrianAtmLL();
newNode->nama = nama;
newNode->umur = umur;
newNode->next = NULL;
tail->next = newNode;
tail = newNode;
}

// dequeue Linked List

void dequeueLinkedList()
{
if( isEmptyLinkedList() ){
cout << "Data Antrian Kosong!!" << endl;
}else{
del = head;

8
 head = head->next;
del->next = NULL;
delete del;
}
}

// destroy / clear
void clearLinkedList()
{
if( isEmptyLinkedList() ){
cout << "Data Antrian Kosong!!" << endl;
}else{
cur = head;
while( cur != NULL ){
del = cur;
cur = cur->next;
del->next = NULL;
delete del;
}
head = NULL;
tail = NULL;
}
}

// display Linked List

void displayLinkedList()
{
cout << "Data Antrian : " << endl;
if( isEmptyLinkedList() ){
cout << "Data Antrian Kosong!!" << endl;
}else{
cout << "Banyak data antrian : " << countLinkedList() << endl;
cur = head;
int nomor = 1;
while( nomor <= maksimalAntrianLinkedList ){

if( cur != NULL ){

cout << nomor << ". " << cur->nama << " - " << cur->umur << " tahun." << endl;
cur = cur->next;
}else{
cout << nomor << ". " << "(kosong)" << endl;
}

9
 nomor++;
}

cout << "\n" << endl;

int main()
{

char ulang;
int menu;

do{

system("cls");
cout << "1. Tambah "<<endl;
cout << "2. Hapus " <<endl;
cout << "3. Reset " <<endl;
cout << "4. Tampil " <<endl;
cout << "0. Exit "<<endl;
//char ulang;
cout << "Pilih menu ";
cin >> menu;

switch(menu){
case 0:
return 0;
system("cls");
break;
init();
case 1:
system("cls");
cout << "Masukkan Nama kamu ";
cin >> nama;

10
 cout << "Umur kamu ";
cin >> umur;
enqueueLinkedList(nama, umur);
// menu();
break;
case 2:
system("cls");
dequeueLinkedList();
break;
case 3:
system("cls");
clearLinkedList();
break;
case 4:
system("cls");
displayLinkedList();
break;
;
default:
cout << "Di Luar menu ";
break;
}
cout <<"Maau mengulang ";
cin>> ulang;

}while(ulang == 'y');

return 0;
}

1. Tamilan awal

11
 Menampilkan menu
2. Tambah Data

12
 Sata menulis nama Panjang dengan getline
3. Hapus data

4. Menampilkan data

13
5. Reset data

6. Keluar

14
15
 BAB IV
‘KESIMPULAN’

Dari materi ini menjelaskan ap aitu queue atau yang di sebut antrian jadi
antrian ini kebalikan dari stack