Keterangan Bahasa Algoritmik

if Q.first; <> NULL then

(queue tidak kosong)

elmt; : elemen

(inisialisasi)
elmt; <- Q.first;

while elmt; <> NULL do

(proses)
Hasil <- hasil + 1

(iterasi)
Elmt; <- elmt; .nest;
(end while)

(end if)

-> hasil

(end function)

Mendeklarasikan prosedur add yang memasukkan procedure add(nim : string, nama :

elemen ke dalam queue string, nilai : real, Q : queue)

elmt; : elemen
alloc/mem(elmt;)

elmt; . elmt.nim <- nim

elmt; . elmt.nama <- nama
elmt; . elmt.nilai <- nilai
elmt; .next; <- NULL
if Q.first; = NULL then
Q.first; <- elmt;
(end if)
else
Q.last; .next <- elmt;
(end else)
Q.last; <- elmt;
elmt; <- NULL

(end procedure)

Mendeklarasikan prosedur del yang mengeuarkan procedure del (Q : queue)

elemen keluar queue
 if Q.first; <> NULL then
(jika queue bukan queue kosong)
elmt; : elemen
elmt; <- Q.first;

Q.first; <- Q.first; .next;

elmt; .next; <- NULL
deAllocMem(elmt;)
(end if)

(end procedure)

Mendeklarasikan prosedur printQueue yang procedure printQueue(Q : queue)

menampilkan isi queue ke layar
if Q.first; <> NULL then
output(“------isi queue------“)
elmt; : elemen
elmt; <- Q.first;
i : integer
i <- 1

while elmt; <> NULL do

output(“====================”)
output(“elemen ke : “, i)
output(“nim : “,
elmt; .elmt.nim)
output(“nama : “,
elmt; .elmt.nama)
output(“nilai : “,
elmt; .elmt.nilai)

(iterasi)
elmt; <- elmt; .next;
i <- i + 1

(end while)
output(“--------------------“)
(end if)
else
(proses jika queue kosong)
output(“queue kosong”)
(end else)

(end procedure)

Mendeklarasikan algoritma utama yang {algoritma utama}

menggunakan operasi queue
 Q : queue

createEmpty(Q)
printQueue(Q)

output(“====================”)

add(“13507701”, “Nana”, 64.75, Q)

add(“13507702”, “Rudi”, 75.11, Q)
add(“13507703”, “Dea”, 84.63, Q)
printQueue(Q)

output(“====================”)

del(Q)
del(Q)
printQueue(Q)

output(“====================”)

(end algoritma utama)

Bahasa algoritmik di atas jika diimplementasikan pada bahasa pemrograman Pascal dan bahasa
pemrograman C adalah sebagai berikut.

Bahasa Algoritmik Bahasa Pemrograman Pascal

type nilaiMatkul : < type

nim : string, nilaiMatkul = record
nama : string, nim : string[10];
nilai : real nama : string[30];
> nilai : real;
end;

type elemen : < elemen = ^isi;

elmt : nilaiMatkul, isi = record
next : elemen elmt : nilaiMatkul;
> next : elemen;
end;

type queue : < queue = record

first; : elemen, first : elemen;
last; : elemen last : elemen;
> end;
procedure createEmpty(Q : queue) procedure createEmpty(var Q :
queue);
Q.first; <- NULL begin
Q.last; <- NULL Q.first := nil;
Q.last := nil;
(end procedure)
end;

function isEmpty(Q : queue) -> boolean function isEmpty(var Q : queue) :

boolean
hasil : boolean var
hasl <- false hasil : boolean;
if Q.first; = NULL then begin
hasil <- true hasil := false;
(end if)
if Q.first = nil then
-> hasil begin
{end function} hasil := true;
end;

isEmpty := hasil;
end;

function countElement(queue Q) -> function countElement(var Q : queue)

integer : integer;
var
hasil : integer hasil : integer;
elmt; : elemen elmt : elemen;

hasil <- 0 begin

hasil := 0;
if Q.first; <> NULL then
{queue tidak kosong} if Q.first <> nil then
begin
{inisialisasi} {queue tidak kosong}
elmt; <- Q.first;
{inisialisasi}
while elmt; <> NULL do elmt := Q.first;

{proses} while elmt <> nil do

hasil <- hasil + 1 begin
{proses}
{iterasi} hasil := hasil + 1;
elmt; <- elmt;.next;
{end while} {iterasi}
elmt := elmt^.next;
{end if} end;
 -> hasil end;

{end function} countElement := hasil;

end;

procedure add(nim : string, nama : procedure add(nim : string; nama :

string, nilai : real, Q : queue) string; nilai : real; var q :
queue);
elmt; : elemen var
elmt : elemen;
allocMem(elmt;)
begin
elmt;.elmt.nim <- nim new(elmt);
elmt;.elmt.nama <- nama
elmt;.elmt.nilai <- nilai elmt^.elmt.nim := nim;
elmt;.next; <- NULL elmt^.elmt.nama := nama;
if Q.first; = NULL then elmt^.elmt.nilai := nilai;
elmt^.next := nil;
Q.first; <- elmt; if Q.first = nil then
{end if} begin
else Q.first := elmt;
end
Q.last;.next <- elmt; else
{end else} begin
Q.last; <- elmt; Q.last^.next := elmt;
Elmt; <- NULL end;
Q.last := elmt;
{end procedure} elmt := nil;

end;

procedure del(Q : queue) procedure del(var Q : queue);

var
elmt; : elemen elmt : elemen;

if Q.first; <> NULL then begin

if Q.first <> nil then
{jika queue bukan queue kososng} begin
elmt; <- Q.first; {jika queue bukan queue
Q.first; <- Q.first;.next; kosong}
elmt;.next; <- NULL elmt := Q.first;
delAllocMem(elmt;) Q.first := Q.first^.next;
{end if} elmt^.next := nil;
dispose(elmt);
{end procedure} end;
 end;

procedure printQueue(Q : queue) procedure printQueue(var Q : queue);

var
elmt; : elemen elmt : elemen;
i : integer i : integer;

if Q.first; <> NULL then begin

output(“----isi queue----“) if Q.first <> nil then
elmt; <- Q.first; begin
i <- 1 writeln(‘----isi queue----‘);
elmt := Q.first;
while elmt; <> NULL do i := 1;

output(“====================”) while elmt <> nil do

output(“elemen ke : “, i) begin
output(“nim : “, writeln(‘====================’)
elmt;.elmt.nim) ;
output(“nama : “, writeln(‘elemen ke : ‘, i);
elmt;.elmt.nama) writeln(‘nim : ‘,
output(“nilai : “, elmt^.elmt.nim);
elmt;.elmt.nilai) writeln(‘nama : ‘,
elmt^.elmt.nama);
{iterasi} writeln(‘nilai : ‘,
elmt; <- elmt;.next; elmt^.elmt.nilai);
i <- i + 1
{iterasi}
{end while} elmt := elmt^.next;
output(“--------------------“) i := i + 1;

{end if} end

else writeln(‘--------------------‘)
;
{proses jika queue kosong} end
output(“queue kosong”) else
{end else} begin
{proses jika queue kosong}
{end procedure} writeln(‘queue kosong’);
end;

end;

{algoritma utama} var

Q : queue Q : queue;

createEmpty(Q) begin
printQueue(Q) createEmpty(Q);

output(“====================”)
add(“13507701”, “Nana”, 64.75, Q)
add(“13507702”, “Rudi”, 75.11, Q)
add(“13507703”, “Dea”, 84.63, Q)
printQueue(Q)
output(“====================”)
del(Q)
del(Q)
printQueue(Q)
output(“====================”)
(end algoritma utama)
end.
printQueue(Q);
writeln(‘====================’);
add(‘13507701’, ‘Nana’, 64.75, Q);
add(‘13507702’, ‘Rudi’, 75.11, Q);
add(‘13507703’, ‘Dea’, 84.63, Q);
printQueue(Q);
writeln(‘====================’);
del(Q);
del(Q);
printQueue(Q);
writeln(‘====================’);

type nilaiMatkul : < #include <stdio.h>

nim : string, #include<malloc.h>
nama : string, #include<string.h>
nilai : real
> typedef struct{
char nim[10];
char nama[50];
float nilai;
}nilaiMatkul;

type elemen : < typedef struct elm *alamatelmt;

elmt : nilaiMatkul, typedef struct elm{
next; : elemen nilaiMatkul elmt;
> alamatelmt next;
}elemen;

type queue : < typedef struct{

first; : elemen, elemen *first;
last; : elemen elemen *last;
> }queue;

procedure createEmpty(Q : queue) Void createEmpty(queue *Q){

Q.first; <- NULL (*Q).first = NULL;

Q.last; <- NULL (*Q).last = NULL;

(end procedure) }
function isEmpty(Q : queue)-> boolean Int isEmpty(queue Q){

hasil : boolean Int hasil = 0;

hasil <- false
If (Q.first == NULL){
if Q.first; = NULL then Hasil = 1;
hasil <- true }
{end if}
Return hasil;
-> hasil
}
(end procedure)

function countElement(queue Q)-> int countElement(queue Q){

integer
int hasil = 0;
hasil : integer
hasil <- 0 if(Q.first != NULL){
/* queue tidak kosong */
if Q.first; <> NULL then
{queue tidak kosong} elemen *elmt;

elmt; : elemen /* inisialisasi */

elmt = Q.first;
{inisialisasi}
elmt; <- Q.first; while(emlt != NULL){
/* proses */
while elmt; <> NULL do hasil = hasil + 1;
{proses}
hasil <- hasil + 1 /* iterasi */
elmt = elmt->next;
{iterasi} }
elmt; <- elmt;.next;
{end while} }
{end if}
-> hasil Return hasil;
{end procedure)
}

Procedure add(nim : string, nama : void add(char nim[], char nama[],

string, nilai : real, Q : queue) float nilai, queue *Q){

elmt; : elemen elemen *elmt;

allocMem(elmt;) elmt = (elemen *) malloc (sizeof
(elemen));
elmt;.elmt.nim <- nim strcpy(elmt->elmt.nim, nim);
 elmt;.elmt.nama <- nama strcpy(elmt->elmt.nama, nama);
elmt;.elmt.nilai <- nilai elmt->elmt.nilai = nilai;
elmt;.next; <- NULL elmt->next = null;
if Q.first; = NULL then if((*Q).first == NULL){
Q.first; <- elmt; (*Q).first = elmt;
{end if} }
else else{
Q.last;.next <- elmt; (*Q).last->next = elmt;
{end else} }
Q.last; <- elmt; (*Q).last = elmt;
elmt; <- NULL elmt = NULL;

{end procedure) }

procedure del(Q : queue) void del(queue *Q){

if Q.first; <> NULL then if((*Q).first != NULL){

{jika queue bukan queue kosong} /* jika queue bukan queue kosong
elmt;: elemen */
elmt; <- Q.first;
Q.first; <- Q.first;.next; elemen *elmt = (*Q).first;
elmt;.next; <- NULL (*Q).first = (*Q).first->next;
delAllocMem(elmt;) elmt->next = NULL;
{end if} free(elmt);
}
{end procedure}
}

procedure printqueue(q : queue) void printQueue(queue Q){

if Q.first; <> NULL then if(Q.first != NULL){

output(“----isi queue----“) printf(“----isi queue----\n”);
elmt; : elemen
elmt; <- Q.first; elemen *elmt = Q.first;
i : integer
i <- 1 int i = 1;

while elmt; <> NULL do while(elmt != NULL){

output(“====================”) printf(“====================\n”)
output(“elemen ke : “, i) ;
output(“nim : “, printf(“elemen ke : %d\n”, i);
elmt;.elmt.nim) printf(“nim : %s\n”,
output(“nama : “, elmt->elmt.nim);
elmt;.elmt.nama) printf(“nama : %s\n”,
output(“nilai : “, elmt->elmt.nama);
elmt;.elmt.nilai) printf(“nilai : %f\n”,
elmt->elmt.nilai);
{iterasi}
 Elmt; <- elmt;.next; /* iterasi */
i <- I +1 elmt = elmt->next;
i = i + 1;
{end while}
output(“--------------------“) }
{end if} printf(“--------------------\n”);
else
{proses jika queue kosong} else{
output(“queue kosong”) /* proses jika queue kosong */
{end else} Print(“queue kosong\n”);
{end procedure} }

{algoritma utama} int main(){

Q : queue queue Q;

createEmpty(Q) createEmpty(&Q);
printQueue(Q) printQueue(Q);

output(“====================”) printf(“====================\n”);

add(“13507701”, “Nana”, 64.75, Q) add(“13507701”, “Nana”, 64.75, &Q);

add(“13507702”, “Rudi”, 75.11, Q) add(“13507702”, “Rudi”, 75.11, &Q)
add(“13507703”, “Dea”, 84.63, Q) add(“13507703”, “Dea”, 84.63, &Q)
printQueue(Q) printQueue(Q);

output(“====================”) printf(“====================\n”);

del(Q) del(&Q);
del(Q) del(&Q);
printQueue(Q) printf(“====================\n”);

output(“====================”) return 0;

{end algoritma utama} }

Setelah dilakukan kompilasi dan eksekusi pada layar akan muncul sebagai berikut:

Queue kosong
===============
-----isi queue-----
==================
Elemen ke : 1
Nim : 13507701
Nama : Nana
Nilai : 64.750000
==================
Elemen ke : 2
Nim : 13507702
Nama : Rudi
Nilai : 75.110001
==================
Elemen ke : 3
Nim : 13507703
Nama : Dea
Nilai : 84.629997
---------------------
=================
-----isi queue-------
====================
Elemen ke : 1
Nim : 13507703
Nama : Dea
Nilai : 84.629997
---------------------
=================

4.3 Antrian Berprioritas (Priority Queue)

Antrian berprioritas atau priority queue mengeluarkan elemen dari queue berdasarkan prioritas pada
elemen itu, oleh karena itu elemen pada antrian berprioritas harus menyimpan nilai prioritas pada
setiap elemen. Untuk memasukkan elemen pda sebuah antrian berprioritas tidak harus melalui sisi
belakang antrian tetapi disisipkan dan diurutkan berdasarkan prioritas elemen, sedangkan
mengeluarkan elemen dari antrian berdasarkan prioritas elemen. Hal yang perlu diperhatikan saat
memasukkan elemen ke antrian berprioritas adalah sebagai berikut:

1. Elemen yang memiilki prioritas lebih tinggi akan lebih dahulu keluar dari queue.
2. Jika ada dua elemen yang memiliki prioritas sama maka yang akan kelar terlebih dahulu dari antrian
adalah yang terlebih dahulu masuk ke dalam antrian.
3.

Operasi memasukkan elemen pada antrian berprioritas adalah sebagai berikut:

Keterangan Representasi
Kondisi awal ada sebuah antrian berprioritas yang
berisi elemen da nada sebuah elemen baru yang
akan dimasukkan ke dalam antrian
Mencari tempat yang sesuai untuk elemen baru
sesuai dengan prioritas elemen baru pada antrian

Menyisipkan elemen baru ke dalam antrian

Langkah-langkah memasukkan elemen ke dalam antrian berprioritas jika diimplementasikan dalam

bahasa algoritmik dengan representasi statis adalah sebagai berikut:

. . . . . . . . . . . . . . .

type elemen : <

elmt : nilaiMatkul,
priority : integer
>

type queue : <

first : integer,
last : integer,
data : array [1_10] of elemen
>
. . . . . . . . . . . . . . .

procedure add(nim : string, nama : string, nilai : real, priority : integer,

Q : queue)

if isEmpty(Q) = true then

{jika queue kosong}
Q.last <- 1
Q..first <- 1
Q.data1.elmt.nim <- nim
Q.data1.elmt.nama <- nama
Q.data1.elmt.nilai <- nilai
Q.data1.priority <- priority
{end if}
Else
{jika queue tidak kosong}
If isFull (Q) <> true then
Indeks : integer
Indeks <- Q.last
Ketemu : Boolean
Ketemu <- false

{mencari tempat untuk elemen baru}

While (indeks ≥ Q.first) AND (ketemu = false) do
If (Q.dataindeks.priority ≥ priority) AND (indeks = Q.last) then
{elemen baru menjadi elemen terakhir}
Q.last <- Q.last + 1
Indeks <- Q.last
Q.dataindeks.elmt.nim <- nim
Q.dataindeks.elmt.nama <- nama
Q.dataindeks.elmt.nilai <- nilai
Q.dataindeks.priority <- priority
Ketemu <- true
{end if}
Else
If (Q.dataindeks-1.priority ≥ priority) AND
(Q.dataindeks.priority < priority) then
{elemen baru menjadi elemen di tengah queue}
{menggeser elemen ke belakang mulai dar elemen paling belakang}
Integer i
For i<-Q.last downto Q.indeks do
Q.data1+1.elmt.nim <- Q.data1.elmt.nim
Q.data1+1.elmt.nama<- Q.data1.elmt.nama
Q.data1+1.elmt.nilai <- Q.data1.elmt.nilai
Q.data1+1.priority <- Q.data1.priority
{end for}

{memasukkan elemen baru}

Q.dataindeks.elmt.nim <- nim
Q.dataindeks.elmt.nama <- nama
Q.dataindeks.elmt.nilai <- nilai
Q.dataindeks.priority <- priority

Q.last <- Q.last + 1

Ketemu <- true
{end if}
else
If (Q.dataQ.first.priority < priority) AND
(indeks = Q.first) then
{elemen baru menjadi elemen pertama queue)

{menggeser elemen ke belakang mulai dari elemen paling belakang}

i : integer
for i<-Q.last downto Q.first do
Q.data1+1.elmt.nim <- Q.data1.elmt.nim
Q.data1+1.elmt.nama<- Q.data1.elmt.nama
Q.data1+1.elmt.nilai <- Q.data1.elmt.nilai
Q.data1+1.priority <- Q.data1.priority
 {end for}

{memasukkan elemen baru}

Q.dataQ.first.elmt.nim <- nim
Q.dataQ.first.elmt.nama<- nama
Q.dataQ.first.elmt.nilai <- nilai
Q.dataQ.first.priority <- priority

Q.last <- Q.last + 1

Ketemu <- true
{end if}
Else
{iterasi}
Indeks <- indeks – 1
{end else}
{end else}
{end else}
{end while}

{end if}
Else
Output(“queue penuh”)
{end else}
{end else}

{end procedure}

. . . . . . . . . . . . . . .

Sedangkan jika dengan representasi dinamis adalah sebagai berikut:

. . . . . . . . . . . . . . .

type elemen : <

elmt : nilaiMatkul,
priority : integer,
next; : elemen
>
. . . . . . . . . . . . . . .

Procedure add(nim : string, nama : string, nilai : real, priority : integer,

Q : queue)

Elmt;: elemen
allocMem(elmt;)

elmt;.elmt.nim <- nim

elmt;.elmt.nama <- nama
elmt;.elmt.nilai <- nilai
elmt;.priority <- priority

if isEmpty(Q) = true then

{jika queue kosong}

elmt;.next; <- NULL

Q.first; <- elmt;
Q.last; <- elmt;

{end if}
else
{jika queue tidak kosong}
posisi; : elemen
posisi; <- Q.first
ketemu : boolean
ketemu <- false

{mencari tempat untuk elemen baru}

while (posisi; <> NULL) AND (ketemu = false) do
if (posisi;.priority ≥ priority) AND (posisi; = Q.last) then
{elemen baru menjadi elemen terakhir}

elmt;.next; <- NULL

Q.last;.next; <- elmt;
Q.last; <- elmt;
ketemu <- true
{end if}
else
if (posisi;.priority ≥ priority) AND
(posisi;.next;.priority < priority) then
{elemen baru menjadi elemen di tengah queue}
elmt;.next; <- posisi;.next
posisi;.next; <- elmt;
ketemu <- true
{end if}
else
if (Q.first;.priority < priority) AND (posisi; = Q.first;) then
{elemen baru menjadi elemen pertama queue}
elmt;.next <- Q.first;
Q.first; <- elmt;
ketemu <- true
{end if}
else
posisi; <- posisi;.next;
{end else}
{end else}
{end else}
{end while}
 {end else}
elmt; <- NULL
{end procedure}

. . . . . . . . . . . . . . .

Operasi mengeluarkan sebuah elemen dari antrian berprioritas sama dengan antrian tidak berprioritas,
karena elemen telah diurutkan berdasarkan prioritasnya.

Soal Latihan
1. Buatlah queue yang memiliki isi elemen berupa data konsumen, lalu buat program utamanya
beserta prosedur dan fungsi yang dibutuhkan, buat simulasi ketika ada konsumen yang masuk
antrian dan ada konsumen yang keluar antrian.
2. Buatlah queue yang memiliki isi elemen berupa data pengunjung kafe beserta pesanan yang
harus dilayani, lalu buat program utamanya beserta prosedur dan fungsi yang dibutuhkan, buat
simulasi ketika ada pegunjung kafe yang masuk antrian dan memesan dan ada pengunjung kafe
yang selesai dilayani yang keluar antrian.