LAPORAN PRAKTIKUM

STRUKTUR DATA
Modul Praktikum 3

Disusun oleh:

Nama : Desi Maya Sari

Nim : 2107110665

Dosen : T. Yudi Hadiwandra, S.Kom, M.Kom

Asisten : 1. Mamba Ul Izzi (1807124814)

2. Rifqi Al Hanif Simbolon (1807195430)

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS TEKNIK
UNIVERSITAS RIAU
GENAP 2021/2022
A. TUGAS PENDAHULUAN
Flowchart 1: Latihan menggunakan array (tambah)

Start

No
If q->rear == MAX

Yes
q->rear++;
Print antrian penuh q->item[q->rear]==item;
q->count++;

Yes
q->front = 0; if(q->front== -1)

No
return

1
Flowchart 1: Latihan menggunakan array (hapus)

Start

No
if q->front= -1

Yes
data=q->item[q>front]
Print antrian q->count--;
kosong

No
return null q->front++; If(q->front==q->rear)

Yes

q->front=q->rear= -1
return data;

2
Flowchart 2: Antrian menggunakan circular queue (tambah)

Start

False If((q->rear==MAX-1
If(q->rear==MAX-1) && q->front==0) ||
(q->rear+1 ==q->front))

False True

q->rear++ q->rear=0
True

q->item[q->rear]=item; Print antrian penuh

q->count++;

False
if(q->front== -1)

True

q->front=0; End

3
Flowchart 2: Antrian menggunakan circular queue (hapus)

Start

int data

False
If q->front == -1 data=q->item[q->front]
q->count

True

if(q->front == q->rear)
Print antrian
kosong True False
q->front =
q->rear = -1
If(q->front=MAX-1)
return null
True

False
return data; q->front=0;

q->front++;

4
Flowchart 3: Antrian menggunakan linked list (tambah)

Start

Node *ptr
ptr=(Node*)malloc(sizeof(Node));
ptr->item=y;
ptr->link = NULL;

if(Q->front==NULL

Q->front=Q->rear=ptr Q->rear->link=ptr;
Q->rear=ptr;

End

5
Flowchart 3: Antrian menggunakan linked list (hapus)

Start

int num

False
If Q->front == NULL

True
num = Q->front->(item)
Print antrian Q->front = Q->front->link
kosong

return 0 If Q->front == NULL

False

True

Q->rear == NULL

return data

6
B. PERCOBAAN
Percobaan 1: Implementasi antrian dengan array
#include <stdio.h>
#define MAX 10

typedef struct
{
int Item[MAX];
int Front;
int Rear;
int Count;
} Queue;
// Inisialisasi antrian
void Inisialisasi(Queue *q)
{
q->Front = q->Rear = -1;
q->Count = 0;
}
// Prosedur untuk menyisipkan data pada antrian
void Tambah(Queue *q, int item)
{
if (q->Rear == MAX-1)
{
printf ("Antrian Penuh");
printf("\n------------------------");
return ;
}
q->Rear++;
q->Item[q->Rear] = item;
q->Count++;
if (q->Front == -1) q->Front = 0;
}
// Prosedur untuk menghapus data dari antrian
int Hapus(Queue *q)
{
int data ;
if (q->Front == -1)
{
printf ("\nAntrian Kosong");
return NULL;
}
data = q->Item[q->Front];
q->Count--;
if (q->Front == q->Rear)
q->Front = q->Rear = -1;
else
q->Front++;
return data;
}
void Tampil(Queue *q)
{
for(int i=0; i<q->Count; i++)
printf("\nData : %d", q->Item[i]);
}
7
int main()
{
Queue q;
int data;

Inisialisasi(&q);
Tambah(&q,11);
Tambah(&q,12);
Tambah(&q,13);
Tambah(&q,14);
Tambah(&q,15);
Tambah(&q,16);
Tambah(&q,17);
Tambah(&q,18);
Tambah(&q,19);
Tambah(&q,20);
Tambah(&q,21);
Tampil(&q);
data = Hapus(&q);
printf("\n------------------------");
printf("\nHapus Item = %d ", data);
data = Hapus(&q);
printf("\nHapus Item = %d ", data);
data = Hapus(&q);
printf("\nHapus Item = %d ", data);
printf("\n------------------------");
Tampil(&q);
}

8
Percobaan 2: Implementasi circular queue
#include <stdio.h>
#define MAX 10
typedef struct {
int Item[MAX];
int Front;
int Rear;
int Count;
} Queue;
// Inisialisasi antrian
void Inisialisasi(Queue *q)
{
q->Front = q->Rear = -1;
q->Count = 0;
}
// Prosedur untuk menyisipkan data pada antrian
void Tambah(Queue *q, int item)
{
if ((q->Rear == MAX-1 && q->Front == 0) || (q->Rear + 1
== q->Front))
{
printf ("\nAntrian Penuh");
return ;
}
if (q->Rear == MAX - 1)
q->Rear = 0;
else
q->Rear++;
q->Item[q->Rear] = item;
q->Count++;
if (q->Front == -1) q->Front = 0;
}
// Prosedur untuk menghapus data dari antrian
int Hapus(Queue *q)
{
int data ;
if (q->Front == -1)
{
}
else
{
printf ("\nAntrian Kosong");
return NULL;

data = q->Item[q->Front];
q->Count--;
if (q->Front == q->Rear)
q->Front = q->Rear = -1;
else
{
if (q->Front == MAX-1)
q->Front = 0;
else
{
}

9
}
}

q->Front++;

return data;
}
void Tampil(Queue *q)
{
for(int i=0; i<q->Count; i++)
printf("\nData : %d", q->Item[i]);
}
int main()
{
Queue q; int
data;
Inisialisasi(&q);
Tambah(&q,11);
Tambah(&q,12);
Tambah(&q,13);
Tambah(&q,14);
Tambah(&q,15);
Tambah(&q,16);
Tambah(&q,17);
Tambah(&q,18);
Tambah(&q,19);
Tambah(&q,20);
Tambah(&q,21);
Tampil(&q);
data = Hapus(&q);
printf("\nHapus Item = %d ", data);
data = Hapus(&q);
printf("\nHapus Item = %d ", data);
data = Hapus(&q);
printf("\nHapus Item = %d ", data);
Tampil(&q);
}

10
11
Percobaan 3: Implementasi antrian dengan linked list

#include<stdio.h>
#include<malloc.h>

typedef struct node

{
int Item;
struct node *link;
}Node;

typedef struct
{
Node *Front;
Node *Rear;
}Queue;

// Prosedur untuk menyisipkan data pada antrian

void Tambah(Queue *Q, int y)
{
Node *ptr;
ptr=(Node *) malloc(sizeof(Node));
ptr->Item=y;
ptr->link=NULL;
if(Q->Front ==NULL)
{
Q->Front = Q->Rear = ptr;
}
else
{
Q->Rear->link=ptr;
Q->Rear=ptr;
}
}

// Prosedur untuk menghapus data dari antrian

int Hapus(Queue *Q)
{
int num;
if(Q->Front==NULL)
{
printf("\n\n\t\tAntrian Kosong\n\n");
return(0);
}
else
{
num=Q->Front->Item;
Q->Front = Q->Front->link;
if(Q->Front == NULL)
Q->Rear = NULL;
//printf("\nNilai yang dihapus : %d \n",num);
return(num);
}
}

12
void Tampil(Node *N)
{
printf ("\nFront -> ");
while (N != NULL)
{
if(N->link == NULL)
{
printf("%5d", N->Item);
printf(" <- Rear");
}
else
printf("%5d", N->Item);
N = N->link;
}
}

int Count(Node *N)

{
int c=0;
while (N != NULL)
{
N = N->link;
c++;
}
return c;
}

int main()
{
int item;
Queue Q;
Q.Front = Q.Rear = NULL;
Tambah(&Q, 11);
Tambah(&Q, 12);
Tambah(&Q, 13);
Tambah(&Q, 14);
Tambah(&Q, 15);
Tambah(&Q, 16);
Tambah(&Q, 17);
Tampil(Q.Front);
printf("\nJumlah data pada antrian : %d",
Count(Q.Front));
item=Hapus(&Q);
printf("\nNilai yang dihapus : %d",item);
item=Hapus(&Q);
printf("\nNilai yang dihapus : %d",item);
item=Hapus(&Q);
printf("\nNilai yang dihapus : %d",item);
Tampil(Q.Front);
printf("\nJumlah data pada antrian : %d",
Count(Q.Front));
}

13
14
C. PRAKTIKUM

1. TUJUAN PRAKTIKUM
1. Memahami struktur data yang digunakan pada antrian (queue), baik
yang berupa array maupun linked list.
2. Memahami karakteristik antrian dan kondisi yang ada, yaitu queue
dalam keadaan kosong atau penuh.
3. Membuat flowchart dan mengimplementasikan antrian pada suatu
permasalahan.

15
2. DASAR TEORI
Antrian (queue) adalah konsep penyimpanan sekumpulan data yang
sering digunakan. Pada antrian, data dapat disimpan dalam array atau
linked list. Pada antrian, penunjuk posisi depan dan belakang harus
disimpan. Apabila akan menambah data pada antrian maka menaikkan
penunjuk belakang dan meletakkan data pada posisi tersebut. Apabila akan
menghapus data pada antrian, maka dihapus pada posisi depan dan
menaikkan penunjuk depan.

1. Antrian dengan Array

Pada implementasi antrian dengan array, digunakan sejumlah array
MAX untuk menyimpan data. Untuk menunjuk bagian depan dan bagian
belakang, digunakan variabel Front dan Rear. Bila antrian kosong,
nilainya diatur -1. Untuk operasi penambahan dan penghapusan,
diimplementasikan dua fungsi yaitu Tambah() dan Hapus().

2. Antrian dengan Linked List

Array yang digunakan untuk mengimplementasikan antrian
dideklarasikan mempunyai ukuran MAX. Ukuran ini ditentukan pada saat
menulis program, tidak dapat diubah pada saat program berjalan. Sehingga
pada saat menulis program, harus ditentukan ukuran memori maksimum
yang diperlukan untuk membangun array. Hal ini berhubungan dengan
deklarasi ruang memori yang tersedia. Jika jumlah elemen yang dapat
disimpan dalam antrian kecil, maka banyak ruang memori yang tidak
digunakan. Sebaliknya, jika jumlah elemen yang akan disimpan pada
antrian terlalu banyak, maka menyebabkan overflow. Untuk menghindari
hal tersebut terjadi dan keterbatasan memory maka digunakan struktur
data yang disebut linked list.

16
3. PEMBAHASAN
Bahasa C++ adalah bahasa pemrograman komputer yang merupakan
pengembangan dari bahasa C yang disempurnakan oleh Bjarne Stroustrup
pada tahun 1980 menjadi C dengan kelas (C With Classes) dan berganti
nama pada tahun 1983 menjadi C++. Awalnya C++ disebut "a better C"
kemudian berganti nama pada tahun 1983 menjadi C++. Simbol ++
merupakan operator C untuk operasi increment (penaikan), digunakan
untuk menunjukkan bahwa bahasa baru ini merupakan versi yang lebih
canggih dari C.
Bahasa C++ diciptakan untuk mendukung pemrograman berorientasi
objek (Object Oriented Programming / OOP) yang tidak dimiliki C.
Sebenarnya reputasi C tidak diragukan lagi dalam menghasilkan program
.EXE berukuran kecil, fleksibilitas pemrograman, eksekusi yang cepat dan
antarmuka (interfacing) yang sederhana. namun C++ merupakan superset
dari C, dimana C++ dapat menjalankan sebagian besar (File Header /
library) dari C, sedangkan C tidak bisa menjalankan / memanggil code
(File Header / library) dari C++, Selain itu dengan adanya standarisasi
ANSI pada C++, membuat bahasa C++ akan memiliki "bahasa" yang sama
pada setiap compiler.

17
4. HASIL
Latihan 1: Menampilkan perubahan variabel Front, Rear, Count

Penjelasan: Program ini menggunakan queue berjenis array. Count akan

mengubah sesuai dengan jumlah angka di dalam antrian. Front akan
bertambah ketika terjadi penghapusan antrian. Rear akan bertambah ketika
dilakukan penambahan elemen pada antrian.

18
Latihan 2: Mengimplementasikan konsep stack dalam dua stack

Penjelasan: Program ini mengimplementasikan konsep stack menggunakan

queue. Program ini menampilkan output berupa data yang dimasukkan
(enqueuing) dan data yang dikeluarkan/dihapus (dequeuing)..

19
Latihan 3: Mengimplementasikan simulasi tempat parkir

20
Penjelasan: Program ini berupa implementasi tempat parkie dengan
menggunakan konsep gabungan stack dan queue. Sehingga di dalam
program ini dapat memasukkan mobil ke dalam parkiran dengan meng-
input nomor platnya dan juga mengeluarkannya, serta dapat menampilkan
mobil yang ada di dalam parkiran.

21
Latihan 4: Simulasi tempat parker dengan struktur data linked list

Penjelasan: Program ini berfungsi sebagai simulasi pada tempat parkir

dengan menggunakan konsep linked list.

22
Latihan 5: Menampilkan output yang diberikan pada soal

Penjelasan: Program ini implementasi dari data mahasiswa yang diurutkan

dari nilai tertinggi. Program ini mengambil input user berupa nomor absen,
nilai, dan huruf awal nama kemudian akan diurutkan berdasarkan nilai
tertinggi dengan menggunakan konsep queue dengan linked list.

23
5. KESIMPULAN
Antrian (queue) adalah konsep penyimpanan sekumpulan data. Pada
antrian, data dapat disimpan di dalam array atau linked list. Lalu,
penunjuk posisi depan dan belakang harus disimpan. Kondisi antrian yang
diperhatikan ada dua, yaitu penuh apabila elemen pada antrian mencapai
kapasitas maksimum antrian kosong apabila elemen pada antrian bernilai
kosong atau NULL.. Pada implementasi, antrian dengan array, digunakan
sejumlah array MAX untuk menyimpan data.

24
6. LISTING PROGRAM
Latihan 1: Menampilkan perubahan variabel Front, Rear, Count

#include <iostream>
#define MAX 5
using namespace std;
typedef struct {
int Item[MAX];
int Front;
int Rear;
int Count;
} Queue;
// Inisialisasi antrian
void Inisialisasi(Queue *q) {
q->Front = q->Rear = -1;
q->Count = 0;
}
// Prosedur untuk menyisipkan data pada antrian
void Tambah(Queue *q, int item) {
if ((q->Rear == MAX - 1 && q->Front == 0) || (q->Rear + 1
== q->Front)) {
cout << "\nAntrian Penuh";
return;
}
if (q->Rear == MAX - 1)
q->Rear = 0;
else
q->Rear++;
q->Item[q->Rear] = item;
q->Count++;
if (q->Front == -1)
q->Front = 0;
}
// Prosedur untuk menghapus data dari antrian
int Hapus(Queue *q) {
int data;
if (q->Front == -1) {
cout << "\nAntrian Kosong";
return NULL;
} else {
data = q->Item[q->Front];
q->Count--;
if (q->Front == q->Rear)
q->Front = q->Rear = -1;
else {
if (q->Front == MAX - 1)
q->Front = 0;
else
q->Front++;
}
}
return data;
}

25
void Tampil(Queue *q) {
cout << "Data :";
for (int i = q->Front; i < q->Count + q->Front; i++){
cout <<q->Item[i] << " ";
}
cout << endl;
}
void trackdata(Queue *q){
cout << "Front : " << q->Front;
cout << " Rear : " << q->Rear;
cout << " Count : " << q->Count << endl << endl;
}
int main() {
Queue q;
int data;
Inisialisasi(&q);
Tambah(&q, 5); // tambah 5
Tampil(&q);
trackdata(&q);
Tambah(&q, 6); // tambah 6
Tampil(&q);
trackdata(&q);
Tambah(&q, 7); // tambah 7
Tampil(&q);
trackdata(&q);
data = Hapus(&q); //hapus 5
Tampil(&q);
trackdata(&q);
Tambah(&q, 8); // tambah 8
Tampil(&q);
trackdata(&q);
data = Hapus(&q); //hapus 6
Tampil(&q);
trackdata(&q);
Tambah(&q, 9); // tambah 9
Tampil(&q);
trackdata(&q);
Tambah(&q, 10); // tambah 10
Tampil(&q);
trackdata(&q);
Tambah(&q, 11); // tambah 11
Tampil(&q);
trackdata(&q);
Tambah(&q, 12); // tambah 12
}

26
Latihan 2: Mengimplementasikan konsep stack dalam dua stack

#include<stdlib.h>
#include<iostream>
using namespace std;

struct nod{//node declaration

int d;
struct nod *n;
};

void push(struct nod** top_ref, int n_d);//functions

prototypes.
int pop(struct nod** top_ref);

struct queue {
struct nod *s1;
struct nod *s2;
};

void enQueue(struct queue *q, int m) {

push(&q->s1, m);
}

int deQueue(struct queue *q) {

int m;
if (q->s1 == NULL && q->s2 == NULL) {
cout << "Queue is empty";
exit(0);
}
if (q->s2 == NULL) {
while (q->s1 != NULL) {
m = pop(&q->s1);
push(&q->s2, m);
}
}
m = pop(&q->s2);
return m;
}

void push(struct nod** top_ref, int n_d) {

struct nod* new_node = (struct nod*)
malloc(sizeof(struct nod));

if (new_node == NULL) {
cout << "Stack underflow \n";
exit(0);
}
//put items on stack
new_node->d= n_d;
new_node->n= (*top_ref);
(*top_ref) = new_node;
}

27
int pop(struct nod** top_ref) {
int res;
struct nod *top;
if (*top_ref == NULL){//if stack is null {
cout << "Stack overflow \n";
exit(0);
}
else { //pop elements from stack
top = *top_ref;
res = top->d;
*top_ref = top->n;
free(top);
return res;
}
}

int main() {
struct queue *q = (struct queue*) malloc(sizeof(struct
queue));
q->s1 = NULL;
q->s2 = NULL;
cout << "Enqueuing..7";
cout << endl;
enQueue(q, 7);
cout << "Enqueuing..6";
cout << endl;
enQueue(q, 6);
cout << "Enqueuing..2";
cout << endl;
enQueue(q, 2);
cout << "Enqueuing..3";
cout << endl;
enQueue(q, 3);
cout << "Dequeuing...";
cout << deQueue(q) << " ";
cout << endl;
cout << "Dequeuing...";
cout << deQueue(q) << " ";
cout << endl;
cout << "Dequeuing...";
cout << deQueue(q) << " ";
cout << endl;
}

28
Latihan 3: Mengimplementasikan simulasi tempat parkir
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 500

struct queue{
int plat[MAX];
int front;
int rear;
int count;
};

struct stack{
int plat[MAX];
int count;
};

void InisialisasiQueue(struct queue *q)

{
q->front = q->rear = 0;
q->count = 0;
}

void InisialisasiStack(struct stack *s)

{
s->count=0;
}
int pop(struct stack *s)
{
int plt;
plt=s->plat[s->count];
s->count--;
return(plt);
}

void normalisasi_queue(int x,struct queue *q, struct stack

*s)
{
do{
q->plat[x]=q->plat[x+1];
x++;
} while(x<q->rear);

q->rear--;
q->count--;

do{
q->front--;
q->plat[q->front]=pop(s);
q->count++;
} while(s->count!=0);
}

29
void push(int plt,struct stack *s)
{
s->count++;
s->plat[s->count]=plt;
}

int cek_mobil(int plt,struct queue *q)

{
int i,hasil;

for(i=q->front;i<=q->rear;i++){
if(q->plat[i]==plt){
hasil=i;
break;
}
else if((q->plat[i]!=plt)&&(i==q->rear)){
hasil=0;
}
}
return(hasil);
}

void masuk(int plt, struct queue *q)

{
if(q->rear==MAX){
printf("\nAntrian Penuh !\n");
return;
}
else if(q->count==0){
q->rear++;
q->plat[q->rear]=plt;
q->count++;
q->front++;
}
else{
q->rear++;
q->plat[q->rear]=plt;
q->count++;
}
}

void keluar(int plt, struct queue *q,struct stack *s)

{
int i,x;

i=q->front;
if(q->count==0){
printf("\nAntrian kosong !\n");
getch();
return;
}
else if(cek_mobil(plt,q)==0){
printf("\nPlat mobil yang anda masukkan tidak ada dalam antrian !\n");
getch();
return;
}

30
else if((cek_mobil(plt,q)==q->front)&&(q->count>1)){
q->front++;
q->count--;
return;

}
else if((cek_mobil(plt,q)==q->front)&&(q->count==1))
InisialisasiQueue(q);
else{
x=cek_mobil(plt,q);
printf("\nMobil yang keluar sementara : \n");
for(i=q->front;i<x;i++){
printf("- Mobil plat nomor %d\n",q->plat[i]);
push(q->plat[i],s);
q->front++;
q->count--;
}
normalisasi_queue(x,q,s);
getch();
return;
}
}

void tampil(struct queue *q)

{
int i,x;
x=q->front;
printf("-------------------------------------------
\n");
printf("Data antrian mobil yang parkir : \n");
printf("-------------------------------------------
\n");
if(q->count==0)
printf("\nTidak ada mobil yang sedang parkir\n");
else {
for(i=1;i<=q->count;i++){
printf("%d. Mobil plat nomor %d\n",i,q-
>plat[x]);
x++;
}
printf("\nJumlah mobil yang parkir : %d\n",q-
>count);
}
printf("\n\n**Tekan sembarang tombol untuk kembali ke
pilihan**");
getch();
return;
}

main()
{
struct queue q;
struct stack s;
int jawab;
int plt;

31
InisialisasiQueue(&q);
InisialisasiStack(&s);

do{
system("cls");
printf("---------------------------\n");
printf("PROGRAM ANTRIAN MOBIL\n");
printf("---------------------------\n");
printf("1. Masukkan mobil\n2. Keluarkan mobil\n3.
Tampilkan antrian\n");
printf("4. Keluar\n");
printf("---------------------------\n");
printf("Pilihan anda : "); scanf("%d",&jawab);
printf("---------------------------\n");

if(jawab==1){
printf("Masukkan nomor plat mobil masuk (tanpa
huruf) : "); scanf("%d",&plt);
masuk(plt,&q);
tampil(&q);
}
else if(jawab==2){
printf("Masukkan plat nomor mobil keluar (tanpa
huruf):"); scanf("%d",&plt);
keluar(plt,&q,&s);
tampil(&q);
}
else if(jawab==3){
tampil(&q);
}
else if(jawab==4)
printf(".............");
else{
printf("\n\nPilihan tidak valid. Silahkan
ulangi!\n");
getch();
}
}while(jawab!=4);
}

32
Latihan 4: Simulasi tempat parker dengan struktur data linked list
#include<stdio.h>
#include<malloc.h>
typedef struct node
{
int Item;
struct node *link;
}Node;

typedef struct {
Node *Front;
Node *Rear;
}Queue;
// Prosedur untuk menyisipkan data pada antrian
void Tambah(Queue *Q, int y)
{
Node *ptr;
ptr=(Node *) malloc(sizeof(Node));
ptr->Item=y;
ptr->link=NULL;
if(Q->Front ==NULL)
{
Q->Front = Q->Rear = ptr;
}
else
{
Q->Rear->link=ptr;
Q->Rear=ptr;
}
}
// Prosedur untuk menghapus data dari antrian
int Hapus(Queue *Q)
{
int num;
if(Q->Front==NULL)
{
printf("\n\n\t\tAntrian Kosong\n\n");
return(0);
}
else
{
num=Q->Front->Item;
Q->Front = Q->Front->link;
if(Q->Front == NULL)
Q->Rear = NULL;
//printf("\nNilai yang dihapus : %d \n",num);
return(num);
}
}
void Tampil(Node *N)
{
printf ("\nFront -> ");
while (N != NULL)
{
if(N->link == NULL)

33
{
printf("%5d", N->Item);
printf(" <- Rear");
}
else
printf("%5d", N->Item);
N = N->link;
}
}
int Count(Node *N)
{
int c=0;
while (N != NULL)
{
N = N->link;
c++;
}
return c;
}
int main()
{
int item;
Queue Q;
Q.Front = Q.Rear = NULL;
Tambah(&Q, 5);
Tampil(Q.Front);
Tambah(&Q, 6);
Tampil(Q.Front);
Tambah(&Q, 7);
Tampil(Q.Front);
item=Hapus(&Q);
Tampil(Q.Front);
Tambah(&Q, 8);
Tampil(Q.Front);
Tambah(&Q, 9);
Tampil(Q.Front);
item=Hapus(&Q);
Tampil(Q.Front);
Tambah(&Q, 10);
Tampil(Q.Front);
Tambah(&Q, 11);
Tampil(Q.Front);

printf("\nJumlah data pada antrian : %d",

Count(Q.Front));
}

34
Latihan 5: Menampilkan output yang diberikan pada soal
#include <iostream>
#include <stdio.h>
#include <cstring>
#include <cstdlib>
using namespace std;

/*
*Deklarasi
*/
struct node
{
int priority;
char info;
char name;
struct node *link;
};
/*
*Priority Queue
*/
class Priority_Queue
{
private:
node *front;
public:
Priority_Queue()
{
front = NULL;
}
/*
* Memasukkkan data Priority Queue
*/
void insert(char item, int priority, char name)
{
node *tmp, *q;
tmp = new node;
tmp->info = item;
tmp->priority = priority;
tmp->name = name;
if (front == NULL || priority < front-
>priority)
{
tmp->link = front;
front = tmp;
}
else
{
q = front;
while (q->link != NULL && q->link->priority <= priority)
q=q->link;
tmp->link = q->link;
q->link = tmp;
}
}

35
 /*
* Menghapus data dari priority queue
*/
void del()
{
node *tmp;
if(front == NULL)
cout<<"Queue Underflow\n";
else
{
tmp = front;
cout<<"\n\t\t\t==========Hasil
Pop==========\n";
cout<<"Nilai yang dipop Nomor absen
Nama huruf awal\n";
cout<<tmp->priority<<"\t\t\t";
cout<<tmp->info<<"\t\t";
cout<<tmp->name<<"\t\t\t\n";
front = front->link;
free(tmp);
}
}
/*
* Menampilkan Priority Queue
*/
void display()
{
node *ptr;
ptr = front;
if (front == NULL)
cout<<"Queue kosong\n";
else
{ cout<<"\n\t\t\t==========Priority
Queue==========\n";
cout<<"Nilai (priority) Nomor
absen Nama huruf awal\n";
while(ptr != NULL)
{
cout<<ptr->priority<<"\t\t\t
"<<ptr->info<<"\t\t\t"<<ptr->name<<endl;
cout<<"\n";
ptr = ptr->link;

}
}
}
};
/*
* Main
*/
int main()
{
int choice, priority;
char name, item;

36
 Priority_Queue pq;
int i;
do
{
program :
cout<<"Masukkan nomor absen : ";
cin>>item;
if(item == '*'){
goto tes;
}
cout<<"Masukkan nilai : ";
cin>>priority;
cout<<"Masukkan nama huruf awal : ";
cin>>name;
pq.insert(item, priority,name);
pq.display();
i++;
}while(i<10);
return 0;
tes:
pq.del();
pq.display();
goto program;
}

37