Implementasi queue

ImPLEmENTASI QUEUE
DENGAN PASCAL
Disusun oleh:
Renny Dwi Yuni A (121080200076)
Puput Dwi Jayanti (121080200068)
Bayu Pratomo (121080200077)
TEkNIk INformATIkA 2 SorE B
UNIVErSITAS mUHAmmADIYAH SIDoArJo
2012 – 2013

KATA PENGANTAR
Puja dan Puji syukur kehadirat Allah SWT yang telah melimpahkan rahmat dan karunianya
kepada kami , sehingga kami dapat menyelesaikan makalah ini tepat pada waktunya.
Terdorong oleh rasa ingin tahu , kemauan , kerja sama dan kerja keras , kami kerahkan seluruh
upaya demi mewujudkan keinginan ini. Semoga tulisan ini dapat memenuhi kewajiban kami dalam tugas
Algoritma dan Struktur Data bertema Implementasi Queue yang dibimbing dan di motivasi oleh Dosen
Pembimbing Bapak Ir. Rajudin.
Adapun harapan kami, semoga tulisan ini dapat menambah wawasan pembaca mengenai konsep
dasar Queue, dengan maksud nantinya pembaca mampu untuk mengenal dan mengetahui seluk
beluknya. Menyadari bahwa makalah kami ini masih jauh dari sempurna, untuk itu kami mengharapkan
kritik dan saran yang membangun dari pembaca demi kesempurnaan makalah ini.
Hormat Kami,
Penyusun

DAFTAR ISI
KATA PENGANTAR
DAFTAR ISI
BAB I PENDAHULUAN
1.1 Latar Belakang
1.2 Tujuan Penulisan
1.3 Rumusan Masalah
1.4 Metode Penulisan
BAB II PEMBAHASAN ( ISI )
2.1 Definisi dan Gambaran Umum Queue
2.2 Macam Queue
2.3 Queue Representasi Statis
2.3.1 Definisi Queue Statis
2.3.2 Implementasi Queue Statis
2.3.3 Contoh Program Queue Statis Dengan Array
2.4 Queue Representasi Dinamis
2.4.1 Definisi Queue Dinamis
2.4.2 Implementasi Queue Single Linked List
2.4.3 Contoh Program Queue Dengan Single linked List
2.4.4 Implementasi Queue Double Linked List
2.4.5 Contoh Program Queue Dengan Double Linked List
2.5 Queue Berprioritas
2.5.1 Definisi Queue Berprioritas
2.5.2 Implementasi Queue Berprioritas
BAB III PENUTUP
3.1 Kesimpulan
3.2 Penutup

BAB 1
PENDAHULUAN
1.1 Latar Belakang
Dengan adanya kemajuan Tekhnologi di dunia ini akal pikiran manusia semakin mahir dalam menciptakan
sesuatu yang bermanfaat bagi kehidupan mereka, salah satunya dalam pembuatan program – program yang
membantu dalam menyelesaikan pekerjaan mereka dengan cepat, baik, dan memuaskan, maka dari itu kami
menyusun makalah mengenai Queue sebagai salah satu program yang terlahir dari dunia tekhnologi lewat pola
pikir manusia yang bermanfaat untuk menyelesaikan suatu penghitungan.
1.2 Tujuan Pembuatan Makalah
1. Untuk memenuhi tugas mata perkuliahan Algoritma dan Struktur Data
2. Mendeskripsikan konsep dan kegunaan Queue dalam kehidupan sehari-hari
3. Memberikan tambahan informasi kepada pembaca mengenai apa sebenarnya Queue dan bagaimana
penggunaanya
1.3 Rumusan Masalah
Bagaimana sebenarnya pembuatan program Queue untuk memudahkan pekerjaan manusia?
1. Apa Manfaat Queue?
2. Bagaimana sistem kerjanya dalam bahasa pemrograman?
1.4 Metode Penulisan
Metode yang digunakan untuk penulisan ini adalah metode literature yaitu dengan mencari dan
menelaah data dari sumber-sumber yang berhubungan dengan pokok Queue dan pengetahuan penulis yang
didapat dari pembelajaran dalam ruang lingkup perkuliahan.

BAB II
PEMBAHASAN
2.1 Definisi dan Gambaran Umum Queue
Jika diartikan secara harfiah queue berarti antrian, bersifat FIFO (First In First Out) dimana dalam
suatu antrian, yang datang terlebih dahulu akan dilayani lebih dahulu. Queue merupakan salah satu
contoh aplikasi yang cukup sering kita temui dalam kehidupan sehari-hari, misalnya saat Anda
mengantri di loket untuk membeli tiket, antri di puskesmas, antri saat mengisi BBM di SPBU, dll .
Istilah yang cukup sering dipakai seseorang masuk dalam sebuah antrian adalah enqueue /
insert. Istilah yang sering dipakai bila seseorang keluar dari antrian adalah dequeue / delete. Walaupun
berbeda implementasi, struktur data queue setidaknya harus memiliki operasi-operasi sebagai berikut :
1. Deklarasi Sebuah Queue bertipe
2. Prosedur Create / Inisialisasi
Membuat antrian baru yang masih kosong / Inisialisasi
3. Fungsi Full
Untuk memeriksa apakah antrian sudah penuh.
4. Fungsi Empty
Untuk Memeriksa apakah antrian kosong.
5. Prosedur Insert / Push / Enqueue
Menambah sebuah elemen ( data ) kedalam antrian.Syarat: tidak bisa dilakukan jika
antrian sudah penuh.
6. Prosedur Delete / Pop / Dequeue
Mengambil 1 elemen dari sebuah antrian. Syarat: antrian tidak boleh kosong
2.2 Macam Queue
Queue terdiri dari dua macam tipe yaitu yang berprioritas dan yang tidak berprioritas. Queue
berprioritas mengurutkan data berdasarkan besaran prioritas suatu elemen. Sedangkan yang tidak
berprioritas di bagi menjadi dua macam tipe yaitu statis dan dinamis. Dimana dalam Queue statis
biasanya di implementasikan dengan menggunakan array, sedangkan Queue dinamis dengan
menggunakan variabel pointer atau Linked List.

2.3 Queue Representasi Statis
2.3.1 Definisi Queue Statis
Queue Representasi Statis biasanya di implementasikan dengan menggunakan Linear Array.
Linear array adalah suatu array yang dibuat seakan-akan merupakan suatu garis lurus dengan satu pintu
masuk dan satu pintu keluar. Berikut ini diberikan deklarasi kelas Queue Linear sebagai implementasi
dari Queue menggunakan linear array. Dalam prakteknya, anda dapat menggantinya sesuai dengan
kebutuhan Anda. Data diakses dengan field data, sedangkan indeks item pertama dan terakhir disimpan
dalam field Head dan Tail. Konstruktor akan menginisialisasikan nilai Head dan Tail dengan -1 untuk
menunjukkan bahwa antrian masih kosong dan mengalokasikan data sebanyak MAX_QUEUE yang
ditunjuk oleh Data. Destruktor akan mengosongkan antrian kembali dan mendealokasikan memori yang
digunakan oleh antrian. Sebuah array memiliki batasan alokasi elemen di awal sehingga sebuah queue
dapat mengalami kondisi elemen penuh.
in
out
Ilustrasi Queue Array
2.3.2 Implementasi Queue Statis
QUEUE (Antrian) adalah list linier yang :
1. dikenali elemen pertama (HEAD) dan elemen terakhirnya (TAIL),
2. aturan penyisipan dan penghapusan elemennya didefinisikan sebagai berikut:
- Penyisipan selalu dilakukan setelah elemen terakhir
- Penghapusan selalu dilakukan pada elemen pertama
3. satu elemen dengan yang lain dapat diakses melalui informasi NEXT
Kondisi Queue :

Ilustrasi :
Queue Kosong :
Tabel dengan hanya representasi TAIL adalah indeks elemen terakhir, HEAD selalu diset sama
dengan 1 jika Queue tidak kosong. Jika Queue kosong, maka HEAD=0 TAIL = 0.
Algoritma paling sederhana untuk penambahan elemen jika masih ada tempat adalah dengan
“memajukan” TAIL. Kasus khusus untuk Queue kosong karena HEAD harus diset nilainya menjadi 1.
Algoritma paling sederhana untuk penghapusan elemen jika Queue tidak kosong: ambil nilai
elemen HEAD, geser semua elemen mulai dari HEAD+1 s/d TAIL (jika ada), kemudian TAIL “mundur”.
Kasus khusus untuk Queue dengan keadaan awal berelemen 1, yaitu menyesuaikan HEAD dan TAIL
dengan DEFINISI. Algoritma ini mencerminkan pergeseran orang yang sedang mengantri di dunia nyata,
tapi tidak efisien.
Queue dengan 5 elemen
Ilustrasi Queue tidak kosong, dengan 5 elemen, kemungkinan pertama HEAD tidak berada di
posisi awal. Hal ini terjadi akibat algoritma penghapusan yang dilakukan.
Algoritma untuk penambahan elemen sama dengan saat elemen HEAD bernilai 1, jika masih
ada tempat adalah dengan “memajukan” TAIL. Kasus khusus untuk Queue kosong karena HEAD harus
diset nilainyamenjadi 1.
Algoritma untuk penghapusan elemen jika Queue tidak kosong: ambil nilai elemen HEAD,
kemudian HEAD “maju”. Kasus khusus untuk Queue dengan keadaan awal berelemen 1, yaitu
menyesuaikan HEAD dan TAIL dengan DEFINISI. Algoritma ini TIDAK mencerminkan pergeseran orang
yang sedang mengantri di dunia nyata, tapi efisien. Namun suatu saat terjadi keadaan Queue penuh
tetapi “semu”, haruslah dilakukan aksi menggeser elemen untuk menciptakan ruangan kosong.
Pergeseran hanya dilakukan jika dan hanya jika TAIL sudah mencapai IndexMax.

Represetasi Fisik dengan Array
1. Deklarasi Sebuah Queue bertipe Array dan Record
Type
Const Max = 5;
Type:
Nama record = Record
Data : type data;
Top : byte;
array = ARRAY [1..max] of Nama record;
End;
Var
Antri : nama Array;
const max = 5;
type
queue = record
nama: array[1..max] of string;
umur: array[1..max] of integer;
awal: integer;
akhir: integer;
end;
var
antri: queue;
pilih: char;

data: string; umur:integer;
2. Prosedur Create
Membuat antrian baru yang masih kosong.
Procedure create;
Begin
antri.top:=0;
End;
procedure init;
begin
antri.awal:= 0;
end;
3. Fungsi Full
Fuction full:bolean;
Begin
antri.top:=max;
End;
function full: integer;
begin
if(antri.akhir = max)
then full:= 1
else full:= 0;
end;
4. Fungsi Empty
Fuction empty: bolean;
Begin
Empty:=false;
If top:=0 then
empty:=true;
End;
function empty: integer;
begin
if antri.akhir = 0 then
empty:= 1
else empty:= 0;
end;
5. Prosedur Insert / Push
Procedure push ( input:string );
Begin
If not full then
Begin
antri.top:=antri.top;
antri.data:=input;
End;
procedure masukantri(nama: string; usia:integer);
Begin
if empty = 1 then
begin
antri.awal:= 1;
antri.akhir:= 1;
antri.nama[antri.awal]:=nama; writeln;
antri.umur[antri.awal]:=usia;
writeln('nama : ',nama,' dengan usia ',usia,' telah dimasukkan
ke dalam antrian');
end;
6. Prosedur Delete / Pop
Procedure Pop ( elemen:string );
Begin
If not empty then
Begin
Elemen:=antri.data;
antri.top:=top – 1;
End;
End;
Elemen yang Paling awal
di delete (-1)

2.3.3 Program Queue Statis dengan Array dan Record
PROGRAM UTAMA
Program Fifo_Renny;
Uses Wincrt;
const max = 5;
type
queue = record
nama: array[1..max] of string;
umur: array[1..max] of integer;
awal: integer;
akhir: integer;
end;
var antri: queue;
pilih: char;
data: string;
umur:integer;
procedure init;
begin
antri.awal:= 0;
end;
function full: integer;
begin
if(antri.akhir = max)
then full:= 1
else full:= 0;
end;
function empty: integer;
begin
if antri.akhir = 0 then
empty:= 1
else empty:= 0;
end;
procedure masukantri(nama: string; usia:integer);
begin
if empty = 1 then
begin
antri.awal:= 1;
antri.akhir:= 1;
antri.nama[antri.awal]:=nama; writeln;
antri.umur[antri.awal]:=usia;
writeln('nama : ',nama,' dengan usia ',usia,' telah dimasukkan
ke dalam antrian');
end
KONSEP
Deklarasi Type Sebuah Program Fifo
Queue : Coba Type
Nama, Umur : Data Coba = record
Awal : Top Data :string;
Top : byte;
End;
Barang = ARRAY [1..4] of coba;
Var
Antri:barang;
Pendefinisian Suatu Program Fifo
Procedure create;
Begin
antri.top:=0;
End;
Function Full dan Empty untuk menentukan apakah antrian
kosong atau tidak
Fuction full:bolean;
Begin
antri.top:=max;
End; Fuction empty: bolean;
Begin
Empty:=false;
If top:=0 then
empty:=true;
End;
Procedure Untuk Menginput Data
Begin Procedure push ( input:string );
If not full then Begin
begin If not full then
antri.top:=antri.top; Begin
antri.top:=antri.top;
antri.data:=input;
antri.data := input; End;
end
else

begin
if full<>1 then
begin
antri.akhir:= antri.akhir+1;
antri.nama[antri.akhir]:= nama;
antri.umur[antri.akhir]:= usia;
writeln('nama :',nama,' dengan usia ',usia,' telah
dimasukkan ke dalam antrian');
end
else
write('MAAF ANTRIAN PENUH !!...');
end;
end;
function tampilantri: string;
var
isi: string;
i : integer;
begin
if empty<>1 then
begin
isi:= antri.nama[antri.awal];
{isiumur:= antri.umur[antri.awal];}
for i:= antri.awal to antri.akhir do
antri.nama[i]:= antri.nama[i+1];
{antri.umur[i]:= antri.umur[i+1];}
antri.akhir:= antri.akhir-1;
tampilantri:= isi;
writeln('Giliran pengantri bernama ',isi,' untuk masuk ke
ruangan');
writeln('Isi dari antrian sekarang adalah : ');
writeln(i,'. nama : ',antri.nama[i],', usia : ',antri.umur[i]);
writeln;
end
end;
function tampil: integer;
var
i,isiumur : integer;
begin
if empty<>1 then
begin
isiumur:= antri.umur[antri.awal];
antri.umur[i]:= antri.umur[i+1];
tampil:= isiumur;
end
end;
else
begin
if full then
begin
antri.top := antri.top + 1
antri.data(antri.top) := input;
end
else
writeln (‘Maaf Antrian Penuh’);
end;
Function Untuk Memanggil Antrian / Pop
Procedure Pop ( elemen:string );
Begin Begin
If empty then If not empty then
Begin Begin
Elemen := antri.data; Elemen:=antri.data;
antri.top:=top – 1;
End;
End;
Antri.top = antri.top – 1
End;
End;
Procedure lihatantri;

var
i: integer;
begin
writeln('Daftar Pengantri : ');
writeln(i,'. nama : ',antri.nama[i],', usia : ',antri.umur[i]);
writeln;
end;
begin
init;
writeln('SISTEM ANTRIAN PIJAT URUT MBAH SURIP');
writeln('====================================');
writeln;
repeat
writeln('**********************');
writeln('[1] TAMBAH PENGANTRI ');
writeln('[2] MEMANGGIL PENGANTRI TERDEPAN ');
writeln('[3] LIHAT PENGANTRI');
writeln('[4] KELUAR');
writeln;
write('Masukkan Pilihan : ');
readln(pilih);
case pilih of
'1': begin
write('Masukkan nama pengantri : '); readln(data);
write('usia : '); readln(umur);
masukantri(data,umur);
end;
'2': begin
tampil; tampilantri;
end;
'3': lihatantri;
'4': Exit;
else writeln('Anda Memasukkan Pilihan Yang SALAH....!!!!');
end;
writeln;
until (pilih = '4');
end.
Procedure untuk menampilkan data yang berjenis
array dan record
BAGIAN PROGRAM UTAMA
Untuk memanggil procedure dan fungsi program
diatas
Berisi pilihan Menu dengan metode Case --- of
Begin
{program}
End.

2.4. Queue Representasi Dinamis
2.4.1 Definisi Queue Dinamis
Pada bahasan sebelumnya telah dijelaskan mengenai Queue yang bertipe Array, suatu tipe
data yang bersifat statis (ukuran dan urutannya sudah pasti). Selain itu ruang memori yang dipakai
oleh variabel tersebut tidak dapat dihapus jika variabel tersebut tidak digunakan kembali.
Untuk mengatasi masalah diatas maka pascal menawarkan suatu fasilitas yang dimungkinkan
suatu pengubah/variabel bersifat dinamis. Variabel dinamis adalah suatu variabel yang akan
dialokasikan hanya pada saat diperlukan, yaitu setelah program dieksekusi. Variabel-variabel ini
juga dapat dihapus pada saat program dieksekusi, sehingga ukuran variabel akan selalu berubah.
Variabel dinamis tidak dapat dideklarasikan secara eksplisit seperti halnya mendeklarasikan
variabel statik dan tidak dapat secara langsung ditunjukkan oleh suatu pengenal (identifier). Variabel
dinamis hanya dapat ditunjukkan oleh variabel khusus yang berisi alamat memori yang digunakan
oleh variabel dinamis tersebut. Variabel khusus ini disebut juga dengan variabel pointer. Variabel
Pointer adalah suatu variabel yang menunjuk ke alamat memori yang digunakan untuk menampung
data yang akan diproses.
Sekilas Mengenai Variabel Pointer
Pendeklarasian variabel pointer tidak jauh berbeda dengan pendeklarasian variabel biasa,
hanya perlu ditambahkan simbol topi ( ^ ) – biasa juga disebut ceret atau circumflex. Simbol topi
tersebut menandakan bahwa variabel tersebut menunjuk ke lokasi tertentu di memori.
Deklarasi Variabel Pointer :
Var <Nama Variabel> : ^<Tipe Data>
Contoh Pendeklarasian :
Var
JumlahData : ^Integer;
NamaSiswa : ^String[25];
NilaiSiswa : ^Real;
Pada pointer ada dua operasi dasar yang dapat dilakukan yaitu :
1. Operasi mengkopi simpul
2. Operasi mengkopi isi simpul
Untuk memahami operasi di atas perhatikan contoh berikut. Pertama kali kita deklarasikan
variabel pointernya, yaitu :
Var
P1, P2 : ^Byte;
Posisi P1 dan P2 di memory sekarang ini adalah P1 menunjuk ke tipe data Byte dan P2 juga menunjuk
ke tipe data Byte.

Jika kita mengisi variabel P1 dengan 5 san P2 dengan 8 maka posisi P1 dan P2 sekarang adalah :
P1:=5; P2:=8;
Jika kita memberikan statement :
P1:=P2;
Maka gambar diatas berubah menjadi :
Dari gambar diatas dapat di perhatikan bahwa sekarang pointer P2 juga menunjuk ke
simpul yang ditunjuk oleh pointer P1. Simpul yang tadinya ditunjuk oleh P2 menjadi terlepas. Dalam
keadaan seperti ini, karena tidak ditunjuk oleh suatu pointer lain, maka simpul tersebut tidak bisa
dimasuki lagi karena lokasi simpul tersebut dalam variabel tidak diketahui lagi (kecuali apabila
simpul ini ditunjuk oleh pointer yang lain). Operasi inilah yang disebut dengan operasi mengkopi
pointer.
Jika statemen yang diberikan adalah :
P1^:=P2^;
Maka gambar diatas berubah menjadi :
Operasi inilah selanjutnya yang disebut dengan operasi mengkopi isi simpul.
Variabel Dinamis
Variabel dinamis dibentuk dengan menggunakan variabel pointer yang telah dialokasikan.
Pengalokasian variabel ini menggunakan statement New(). Jika kita tidak membutuhkan variabel
dinamis yang telah kita bentuk maka kita dapat menghapusnya dari memory dengan menggunakan
statemen Dispose(). Sampai saat ini kita baru membentuk satu buah variabel dinamis. Jika kita
memakai banyak variabel dinamis maka kita akan membutuhkan banyak variabel pointer. Oleh
karena itu ada baiknya jika kita hanya menggunakan satu variabel pointer saja untuk menyimpan
banyak data dengan metode yang kita sebut dengan linked list.
Linked list merupakan suatu variabel yang bertipe pointer yang membentuk suatu untaian
yang saling berhubungan. Tiap untaian tersebut diletakkan pada memory. Tempat yang disediakan

pada suatu area memori tertentu untuk menyimpan data dikenal dengan sebutan Node/Simpul.
Linked list juga disebut dengan seranai beranai merupakan suatu variabel pointer yang simpulnya
bertipe Record.
Simpul-simpul yang membentuk seranai beranai
Ada beberapa hal yang harus diketahui mengenai linked list, diantaranya adalah :
1. Linked list selalu memiliki pointer petunjuk yang selalu menunjuk pada awal dari list yang disebut
Head.
2. Linked list juga selalu memiliki pointer petunjuk menunjuk pada akhir dari list yang disebut Tail,
kecuali untuk jenis circular.
3. Setiap simpul yang terbentuk selalu memiliki nilai NIL, kecuali jika simpul tersebut sudah ditunjuk
oleh simpul yang lainnya (Linked list belum terhubung).
4. Posisi simpul terakhir pada linked list selalu bernilai NIL karena ia tidak menunjuk pada simpul
yang lainnya, kecuali bentuk circular.
5. Operasi yang dapat dilakukan pada Linked List diantaranya adalah :
a. Menambah Simpul (di Depan, Belakang dan Tengah).
b. Menghapus Simpul (di Depan, Belakang dan Tengah).
c. Membaca isi linked list (Membaca maju dan mundur).
2.4.2 Implementasi Queue dengan Single Linked List
Single Linked List / Linked list satu arah (One Way List) Disebut demikian karena pada setiap
simpul hanya memiliki satu buah field yang berhubungan dengan simpul berikutnya. Pada Single
Linked List umumnya penambahan dilakukan di belakang maksudnya menambahkan simpul-simpul
baru pada posisi Tail.
Procedure Tambah(Var Head, Tail : PSimpul; Elemen : Char);
Var Temp : PSimpul;
Begin
New(Temp);
Temp^.Info := Elemen;
If Head = NIL Then { Jika Linked List Masih Kosong }
Head := Temp
Else
Tail^.Next := Temp; { Gambar 2.3.b. }
Tail := Temp; { Gambar 2.3.c. }
Tail^.Next := NIL;
End;

Untuk menghapus sebuah simpul diperlukan satu buah tambahan variabel pointer yaitu
variabel bantu yang berguna untuk menunjukkan simpul manakah yang akan dihapus.
Procedure Hapus(Var Head, Tail : PSimpul; Elemen : Char);
Var Temp1, Temp2 : PSimpul;
Begin
If Head = NIL Then { Jika Linked List Masih Kosong }
Writeln(‘Linked List Masih Kosong’)
Else
If Head^.Info = Elemen Then { Simpul Pertama dihapus }
Begin
Temp2:=Head;
Head := Temp2^.Next;
Dispose(Temp2);
End
Else {Menghapus simpul tengah / }
Begin {Akhir }
Temp1 := Head
{ Memulai proses pencarian elemen yang akan dihapus }
While (Elemen <> Temp1^.Info) And (Temp1^.Next <> NIL)
Do
Temp1 := Temp1^.Next;
If Temp2 <> NIL Then { Jika simpul ketemu }
Begin
{ Jika Simpul yang di cari ada di tengah }
If Temp2 <> Tail Then
Temp1^.Next := Temp2^.Next
Else
Begin
Tail := Temp1;
Tail^.Next := NIL;
End;
Dispose(Temp2);
End
Else
{ Simpul yang akan dihapus tidak ketemu }
Writeln(‘Simpul Tidak di ketemukan !’);
End;
End;
Ada dua jenis untuk membaca isi linked list yaitu membaca maju dan membaca mundur.
a) Membaca Maju
Membaca maju artinya membaca isi seranai beranai mulai posisi Head sampai ke posisi
Tail.

Procedure Baca_Maju(Head : PSimpul);
Var Temp : PSimpul;
Begin
Temp := Head;
Repeat
Write(Temp^.Info,’ ‘);
Temp := Temp^.Next
Until Temp <> NIL;
End;
b) Membaca Mundur
Membaca mundur artinya membaca isi seranai beranai mulai posisi Tail sampai ke posisi Head.
Procedure Baca_Mundur(Temp : PSimpul);
Begin
If Temp <> NIL Then
Begin
Baca_Mundur(Temp^.Next);
Write(Temp^.Info,’ ‘);
End;
End;

PROCEDURE INSERT
Head
Penggalan procedure INSERT untuk FIFO
{head mula-mula selalu diidentifikasikan sebagai nil}
Now Head Tail
Now
Head Tail
Procedure INSERT(elemen:TipeData);
Var Now:Point;
Begin
New(Now);
If head = nil then
Head:=now
else
Tail^.next:=now;
Tail:=Now;
Tail^.next:=nil;
Now^.isi:=elemen;
End;
Head:=Nil; Nil
Insert (35) New(Now);
Head=Nil then
Head:=Now;
Tail:=Now;
Tail^.next:=nil;
Now^.isi:=35;
35 Nil

Now
Head Tail
Head Tail Now
Head Now Tail
Head Now Tail
Head Now Tail
Insert (5) New(Now);
Head<>nil then
Tail^.next:=now;
35
Tail:=Now;
Tail^.next:=nil;
35 Nil
Now^.isi=5;
35 5 Nil
Insert (9)
35 5 9 Nil
Insert (1)
35 5 1 Nil9

Procedure dan Function Linked List Lainnya
Selain procedure insert di atas, pada linked list juhga terdapat procedure serta function lainnya. Di
bawah ini diberikan procedure-procedure serta function umum dalam aplikasi Linked List.
1. Procedure Create : Membuat sebuah linked list yang baru dan masih kososng. (ket: procedure ini
wajib dilakukan sebelum menggunakan linked list)
Head Tail
2. Function Empty : Function untuk menentukan apakah linked list kosong atau tidak.
3. Find First : Mencari elemen pertama dari linked list
Head Now Tail
4. Find Next : Mencari elemen sesudah elemen yang ditunjuk now.
Head Now Tail
Procedure Create;
Begin
Head:=nil;
Tail:=nil;
End;
Nil
Function Empty : Boolean;
Begin
If head = nil then
Empty:= true
else
empty:= false;
end;
Procedure Find_First;
Begin
Now:= head;
End;
Find_First
35 5 1 Nil9
Procedure Find_Next;
Begin
If Now^.next <> nil then
Now:= Now^.next;
End;
35 5 1 Nil9

5. Retrieve : Mengambil elemen yang ditunjuk oleh now. Elemen tersebut lalu ditampung pada suatu
variabel (di bawah dicontohkan variabel r).
6. Update : Mengubah elemen yang ditunjuk oleh now dengan isi dari suatu variabel (di bawah
dicontohkan variabel u).
Head Now Tail
7. Delete Now : Menghapus elemen yang ditunjuk oleh now. Jika yang dihapus adalah elemen
pertama dari linked list(head), maka head akan berpindah ke elemen berikut.
Head x Now Tail
Procedure Retrieve(var r: TipeData );
Begin
R:= Now^.isi;
End;
Procedure Update(u: TipeData );
Begin
Now^.isi:=u;
End;
35 7 1 Nil9
Update(7)
Procedure DeleteNow;
Var x : point;
Begin
If now<>head then
Begin
x:=head;
while x^.next<>now do
x:=x^.next;
x^.next=now then
x^.next:=now^.next;
dispose(now);
now:=head;
DeleteNow Now<>head then
Begin
x:=head;
35 7 1 Nil9
35 7 1 Nil9

8. Delete Head : Menghapus elemen yang ditunjuj head. Head berpindah ke elemen sesudahnya.
Now Head Tail
Head Now Tail
9. Clear : Untuk menghapus linked list yang sudah ada.wajib dilakukan bila ingin mengakhiri
program yang menggunakan linked list. Jika tidak data-data yang dialokasikan ke memori pada
program sebelumnya akan tetap tertinggal di dalam memori.
Procedure DeleteHead;
Begin
If head<>nil then
Begin
Now:=head;
Head:=Head^.next;
Dispose(Now);
Now:=Head;
End;
End;
DeleteHead If head<>nil then
Begin
Now:=head;
Head:=Head^.next;
35 1 Nil9
Dispose(Now);
Now:=Head;
35 1 Nil9
Procedure Clear;
Begin
While head <> nil do
Begin
Now:=head;
Head:=head^.next;
Dispose(Now);
End;
End;

1. Deklarasi Sebuah Queue Berpointer Single Linked List
Type
Point = ^RecPoint;
RecPoint = Record
Isi : TipeData;
Next : Point;
End;
Var
Head, Tail, Now : Point;
const max:byte=7;
type penunjuk=^data;
data=record
info:string;
berikut:penunjuk;
end;
var awal,akhir:penunjuk;
pil:char;
jml:byte;
cari,nama:string;
2. Prosedur Create
Procedure Create;
Begin
Head := Nil;
Tail := Nil;
End;
procedure inisialisasi;
begin
awal:=nil;
akhir:=nil;
jml:=0;
end;
5. Prosedur Insert / Push
Procedure INSERT(elemen:TipeData);
Var Now : Point;
Begin
New(Now);
If Head = Nil Then
Head := Now;
Else
Tail^.Next := now;
Tail := Now;
Tail^.Next := Nil;
Now^.Isi := Elemen;
End;
procedure tambah_akhir;
new(baru);
baru^.berikut:=nil;
baru^.info:=nama;
if awal=nil then
begin
awal:=baru;
akhir:=baru;
inc(jml);
end
else
begin
akhir^.berikut:=baru;
akhir:=baru;
end;
6. Prosedur Delete
Begin
If head <> nil then
Begin
Now := Head;
Head := Head^.Next;
Dispose(Now);
Now := Head;
End;
Begin
If Now <> Head then
Begin
X := head;
While x^.next <> now do
X := x^.next;
X^.next := now^.next;
End
Else head := head^.next;
Dispose(now);
Now := head;
End;

PROGRAM
KONSEP
2.4.3 Program Queue dengan Single Linked List
Program Queue_Single;
uses wincrt;
const max:byte=7;
type penunjuk=^data;
data=record
info:string;
berikut:penunjuk;
end;
var awal,akhir:penunjuk;
pil:char;
jml:byte;
cari,nama:string;
procedure inisialisasi;
begin
awal:=nil;
akhir:=nil;
jml:=0;
end;
procedure tambah_akhir;
var baru:penunjuk;
nama:string;
begin
if jml=max then
begin
write('Antrian Penuh');
readln;
end
else
begin
write('Nama:');readln(nama);
new(baru);
baru^.berikut:=nil;
baru^.info:=nama;
if awal=nil then
begin
awal:=baru;
akhir:=baru;
inc(jml);
end else
begin
akhir^.berikut:=baru;
akhir:=baru;
Deklarasi Sebuah Queue Dinamis dengan Single
Linked List
Penunjuk = Point
Data = RecPoint
Berikut = Next
Awal = Head
Akhir = Tail
Procedure Create
Awal := nil;
Akhir :=nil;
Procedure Insert
New(Baru);
Tail^.Next:=now;
Now^.Isi:=nil;
If head = nil then
Head := now;
Tail := now;
Type
Point = ^RecPoint;
RecPoint = Record
Isi : TipeData;
Next : Point;
End;
Var
Head, Tail, Now : Point;
Procedure Create;
Begin
Head := Nil;
Tail := Nil;
End;
Procedure INSERT
(elemen:TipeData);
Var Now : Point;
Begin
New(Now);
If Head = Nil Then
Head := Now;
Else
Tail^.Next := now;
Tail := Now;
Tail^.Next := Nil;
Now^.Isi := Elemen;
End;

inc(jml);
end;
end;
end;
procedure hapus_awal;
var bantu:penunjuk;
begin
if awal=nil then
begin
write('Antrian Kosong');
readln;
end
else
begin
bantu:=awal;
awal:=awal^.berikut;
dispose(bantu);
dec(jml);
end;
end;
procedure hapus_tengah;
var bantu1,bantu2:penunjuk;
ketemu:boolean;
begin
if awal=nil then
begin
write('Antrian Kosong');
readln;
end
else
begin
write('Nama Pengantri Yang batal:');readln(cari);
if awal^.info=cari then
hapus_awal
else
begin
ketemu:=false;
bantu1:=awal;
while (bantu1<>nil) and not ketemu do
begin
if bantu1^.berikut^.info=cari then
ketemu:=true
else
bantu1:=bantu1^.berikut;
end;
if ketemu then
begin
bantu2:=bantu1^.berikut;
bantu1^.berikut:=bantu1^.berikut^.berikut;
dispose(bantu2);
end
Procedure Delete Head
If Head = nil then
Begin
Now:=Head;
Head:=Had^.Next;
Dispose (Now);
Prosedure Hapus Now
If Head = nil then
X:=head;
X:=X^.next;
X^.next:=head^.next;
Head:=Head^.next
Dispose(now);
Begin
If head <> nil then
Begin
Now := Head;
Head := Head^.Next;
Dispose(Now);
Now := Head;
End;
End;
Var x : point;
Begin
If Now <> Head then
Begin
X := head;
While x^.next <> now do
X := x^.next;
X^.next := now^.next;
End
Else head := head^.next;
Dispose(now);
Now := head;
End;

else
begin
write('Nama Pengantri Tidak Ada');
readln;
end; end;
end; end;
procedure tampil;
var bantu:penunjuk;
i:integer;
begin
if awal=nil then
write('Antrian Kosong')
else
begin
bantu:=awal;
i:=1;
while bantu<>nil do
begin
writeln(i,'.[',bantu^.info,']');
bantu:=bantu^.berikut;
inc(i);
end;
end;
readln;
end;
procedure menu;
begin
writeln('MENU PILIHAN ANDA');
writeln('=================');
writeln('1.Tambah Antrian');
writeln('2.Batal Antrian');
writeln('3.Memanggil Pengantri');
writeln('4.Tampil Antrian');
writeln('5.Exit');
writeln;
write('Pilihan Anda :');readln(pil);
end;
begin
inisialisasi;
repeat
menu;
case pil of
'1':tambah_akhir;
'2':hapus_tengah;
'3':hapus_awal;
'4':tampil;
end;
until pil='5';
end.
Procedure menampilkan Queue
Prosedure Membua tampilan Menu
Bagian Program Utama
Begin
Isi
End.

2.4.4 Implementasi Queue dengan Double Linked List
Salah satu kelemahan dari Single Linked List adalah Pointer (penujuk) hanya dapat bergerak satu
arah saja, maju atau mundur, kanan atau kiri. Sehingga pencarian data pada single linked list hanya
dapat bergerak dalam satu arah saja. Untuk mengatasinya maka digunakan metode Double Linked List.
Di kenal dengan nama linked list berpointer ganda atau Double Linked List. Secara garis besar Double
linked list adalah linked list yang memiliki dua buah pointer yang menunjuk ke simpul sebelumnya
(Prev) dan yang menunjuk ke simpul sesudahnya (Next).
Ada beberapa hal yang harus diketahui mengenai Double linked list, diantaranya adalah :
1. Double Linked list selalu memiliki pointer petunjuk yang selalu menunjuk pada awal dari list yang
disebut Head.
2. Double Linked list juga selalu memiliki pointer petunjuk menunjuk pada akhir dari list yang
disebut Tail.
3. Setiap simpul yang terbentuk selalu memiliki nilai NIL, kecuali jika simpul tersebut sudah ditunjuk
oleh simpul yang lainnya (Double Linked list belum terhubung).
4. Posisi simpul terakhir pada Doube linked list selalu bernilai NIL karena ia tidak menunjuk pada
simpul yang lainnya, kecuali bentuk circular.
5. Operasi yang dapat dilakukan pada Double Linked list diantaranya adalah :
a. Inisialisasi.
b. Menambah Simpul (di Depan, Belakang dan Tengah).
c. Menghapus Simpul (di Depan, Belakang dan Tengah).
d. Membaca isi linked list (Membaca maju dan mundur).
Deklarasi Double Linked List :
Type
PSimpul = ^Simpul
Simpul = Record
Info : Tipe Data;
Prev : PSimpul;
Next : PSimpul;
End;
Var
Head, Tail : PSimpul;
Double Linked List memiliki beberapa variasi lain diantaranya :
a. Header Double Linked List : Jenis double linked list yang memiliki simpul tambahan pada awal simpul
yang berguna untuk informasi tambahan.
b. Circular Double Linked List : Jenis double linked list yang tidak pernah mempunyai tail atau tidak
pernah NIL selalu berputar Head = Tail;
c. Header Circular Double Linked List : Jenis circular double linked list yang memiliki simpul
tambahan di awal sebagai informasi tambahan.

next
...
Head
prior info
Tiap node memiliki pointer yang menunjuk ke node sesudahnya dan pointer yang menunjuk ke node sebelumnya.
Node Sesudahnya : Next(Node)
Node sebelumnya : Prior(Node)
Next(Prior(P)) = P dan P = Prior(next(P))
Double Linked List Kosong :
nextprior
head
prior head next Prior(Head) = Head
Next(Head) = Head
Deklarasi Queue dengan Double Linked List :
Type nodeptr = ^ nodetype
nodetype = record
prior : nodeptr;
info : nametype;
next : nodeptr
end;
Penyisipan sebuah Node pada Double Linked List
(a) Ambil sebuah node baru dan isikan datanya
(b) Set pointer dari Next node baru menunjuk ke Successor P dan pointer Priornya ke P
IN
P
NEW
AVAIL
(c) Ubah pointer Next P menunjuk ke node baru
(d) Ubah pointer Prior dari Successor P menunjuk ke node baru
IN
P
NEW
AVAIL

Procedure menghapus sebuah node pada Double Linked List
(a) Set pointer P
nextprior info
P
(b) Ubah pointer pada node Next predecessor P ke node Successor P
nextprior info
P
(c) Ubah pointer pada node dari prior Successor P ke node Predeccssor P
nextprior info
P
(d) bebaskan node yang ditunjuk pointer P
Procedure Removep(var p:nodeptr, out : nametype);
Var pred, succ : nodeptr;
Begin
pred := p^.prior;
succ := p^.next;
pred^.next := succ;
succ^.prior := pred;
out := p^.info;
dispose(p)
End;

PROGRAM KONSEP
2.4.5 Program QUEUE dengan Double Linked List
Program Queue_Double;
Uses WinCrt;
Type
Pointer = ^TypeData;
TypeData = Record
Nilai : integer;
Berikutnya : Pointer;
End;
Var
List : Pointer;
{===========================================}
{========== MASUK DATA DARI DEPAN ==========}
{===========================================}
Procedure Masuk_Depan(Var L : Pointer; X : Integer);
Var
Baru : Pointer;
Begin
New(Baru);
Baru^.Nilai := X;
Baru^.Berikutnya := Nil;
if L = Nil then L := Baru
else
Begin
Baru^.Berikutnya :=L;
L :=Baru;
End;
End;
{==========================================}
{============ SISIP DATA DI TENGAH ==========}
{==========================================}
Procedure Sisip_Tengah(Var L : Pointer; X, Y : Integer);
Var
Baru,Bantu : Pointer;
Begin
Bantu := L;
Deklarasi Type Sebuah Program Fifo
Pointer = Point
Type Data = Simpul
Isi : Nilai
Berikutnya
Tipe Data : Integer
Procedure Insert depan dan Insert belakang
Type
Point = ^simpul;
Simpul = record
Isi : TipeData
Next : Point;
End;
Queue = record
Head : Point;
Tail : Point;
End;
Var
Q : Queue;
N : 0 . . Max_Queue;
{Jumlah Antrian}
Procedure InsertBefore
(e:Elemen_Type);
Var Now : Point;
Begin
New(now);
Now^.Isi := e;
If Head=Nil then
Begin
Head := Now;
Now^.Next := Nil;
Now^.Prev := Nil;
End
Else
Begin
Head^.prev := now;
Now^.next := head;
Head := Now;
Head^.Prev := Nil;
End;
End;

While Bantu^.berikutnya <> Nil Do
Begin
If Bantu^.Nilai = X Then
Begin
New(Baru);
Baru^.Nilai := Y;
Baru^.Berikutnya := Bantu^.Berikutnya;
Bantu^.Berikutnya := Baru;
End;
Bantu := Bantu^.Berikutnya;
End;
End;
{============================================}
{========= MASUK DATA DARI BELAKANG =========}
{============================================}
Procedure Masuk_Belakang(Var L : Pointer; X : Integer);
Var
Baru,Bantu : Pointer;
Begin
New(Baru);
Baru^.Nilai := X;
Baru^.Berikutnya := Nil;
Bantu := L;
While Bantu^.Berikutnya <> Nil Do
Bantu := Bantu^.Berikutnya;
Bantu^.Berikutnya := Baru;
End;
{==========================================}
{========= HAPUS DATA DARI DEPAN ===========}
{==========================================}
Procedure Hapus_Depan(Var L : Pointer);
Var
Baru : Pointer;
Begin
Baru := L;
if L = Nil then Writeln('List Kosong...')
else
Begin
L := L^.Berikutnya;
dispose(Baru);
End;
End;
{==========================================}
{========= HAPUS DATA DARI TENGAH =========}
{==========================================}
Procedure Hapus_Tengah(Var L : Pointer; X : Integer);
Var
Bantu,Hapus : Pointer;
Procedure InsertAfter
(e:Elemen_Type);
Var Now : Point;
Begin
New(now);
Now^.Isi := e;
If Head=Nil then
Begin
Head := Now;
Tail := Now;
Now^.Next := Nil;
Now^.Prev := Nil;
End
Else
Begin
Tail^.next := now;
Now^.Prev := Tail;
Tail := Now;
Tail^.Next := Nil;
End;
End;

Begin
Bantu := L;
if L = Nil then Writeln('List Kosong...')
else
Begin
Bantu := L;
New(Hapus);
While Bantu^.Berikutnya <> nil Do
Begin
if Bantu^.Berikutnya^.nilai = X then
begin
Hapus:=Bantu^.Berikutnya;
Bantu^.Berikutnya:=Hapus^.Berikutnya;
dispose(Hapus);
End
else
Bantu:=Bantu^.Berikutnya;
End;
End;
End;
{==========================================}
{======= HAPUS DATA DARI BELAKANG == = ======}
{==========================================}
Procedure Hapus_Belakang(Var L : Pointer);
Var
Baru,bantu : Pointer;
Begin
Bantu := L;
if Bantu = Nil then Writeln('List Kosong...')
else
Begin
While Bantu^.Berikutnya^.Berikutnya <> nil do
Bantu := Bantu^.berikutnya;
New(Baru);
Baru := Bantu^.Berikutnya;
Bantu^.Berikutnya:=nil;
dispose(Baru);
End;
End;
{==========================================}
{========= PROCEDURE CETAK DATA ===========}
{==========================================}
Procedure Cetak(L : Pointer);
Var
Bantu : Pointer;
Begin
Bantu := L;
While Bantu <> Nil Do
Begin
Procedure DeleteAfter;
Var Now : Point;
Begin
Now := Tail;
If Now <> Head then
Begin
Tail := Now^.Prev;
Tail^.Next := Nil;
End
Else
Begin
Tail := Nil;
Head := Nil;
End;
If Now <> Nil then
Dispose(now);
End;

Write(Bantu^.Nilai:3);
Bantu:=Bantu^.Berikutnya;
End;
End;
{==========================================}
{============ PROGRAM UTAMA ==============}
{==========================================}
Var
Bil,Bil1 : integer;
JB : Char;
Begin
New(List);
List:=nil;
Jb := 'Y';
Writeln('MASUK DEPAN');
While UpCase(Jb)='Y' Do
Begin
Write('Masukkan Bilangan : '); Readln(Bil);
Masuk_Depan(List,Bil);
Write('Lagi[Y/T] ');Readln(Jb);
End;
Cetak(List);
Writeln;
Jb := 'Y';
Writeln('MASUK BELAKANG');
Begin
Masuk_Belakang(List,Bil);
End;
Cetak(List);
writeln;
Jb := 'Y';
Writeln('MASUK DEPAN');
Begin
Masuk_Depan(List,Bil);
End;
Cetak(List);
Writeln;
Writeln('SISIP TENGAH');
Write('Masukkan Bilangan Yg akan disisip : ');
Readln(Bil1);
Write('Disisip Setelah Bilangan : ');
Readln(Bil);
Sisip_Tengah(List,Bil,Bil1);
Cetak(List);
Writeln;
Bagian Program utama

writeln('HAPUS DEPAN ');
Hapus_Depan(List);
Cetak(List);
Writeln;
writeln('HAPUS BELAKANG');
Hapus_Belakang(List);
Cetak(List);
Writeln;
Writeln('HAPUS TENGAH');
Write('Masukkan Bilangan Yg akan dihapus : ');
Readln(Bil);
Hapus_Tengah(List,Bil);
Cetak(List);
Writeln;
End.

2.5 Queue Berprioritas
2.5.1 Pengertian Queue Berprioritas
Adalah sebuah antrian dengan setiap elemennya memiliki prioritas masing-masing dimana
prioritas yang tertinggi akan keluar terlebih dahulu. Hal ini dapat dianalogikan dengan system member
pada sebuah perusahaan penyedia jasa, seperti Garuda Airlines
Penjelasan analogi system member adalah sebagai berikut, sebuah perusahaanmenyediakan tiga
jenis member dan juga melayani orang di luar member. Misalkan tiga jenis member tersebut adalah
Silver, Gold dan Platinum, dimana Gold lebih tinggi dari Silverdan Platinum lebih tinggi dari Gold. Suatu
ketika terjadi sebuah antrian untuk pelayanan jasa dimana yang pertama mengantri adalah person
NonMember, namun kemudian di belakangnya berturut-turut mengantri member Silver, Gold dan
Platina, maka antrian akan berubah menjadi Platinum, Gold, Silver, NonMember berturutan dari depan,
yang menyebabkan member Platinum akan dilayani atau keluar dari antrian terlebih dahulu. Hal ini
terjadi karena dalam antrian berprioritas element yang memiliki prioritas tertinggi akan keluar terlebih
dahulu, yang dalam hal ini adalah Platinum.Oleh karenanya, dalam Queue Berprioritas tidak hanya
terjadi First In First Out, tapi ditambah dengan High Priority First Out. Setiap data dengan prioritas tinggi
akandikeluarkan terlebih dahulu dan ketika ada data yang prioritasnya sama maka yang pertama masuk
akan dikeluarkan terlebih dahulu.
2.5.2 Implementasi Queue Berprioritas
Queue berprioritas dapat disajikan dengan array maupun pointer, dengan array maka dapat
digunakan array of record dimana recordnya berupa penyimpan data dan penyimpan prioritas. Namun,
dalam tugas ini saya membahas dengan contoh penggunaannya menggunakan pointer. Jadi saya tidak
membahas queue berprioritas menggunakan array karena akan lebih mudah dibandingkan
menggunakan pointer. Secara logika queue berprioritas sama dengan queue biasa, hanya saja dilakukan
sorting berdasarkan prioritas, data berprioritas tinggi akan berada di bagian depan daripada data
dengan prioritasnya lebih rendah. Dan perbedaan queue berprioritas dan yang tidak, lebih terlihat dari
bagaimana ia meletakkan data ketika ada data baru.
Dari gambar diatas terlihat bahwa data A adalah yang masuk terlebih diikuti data B, C dan yang
terakhir adalah D, ketika ada satu data yang dikeluarkan atau hendak dihapus maka data A yang
dieksekusi.
Gambar diatas adalah antrian dengan prioritas, meski nampaknya data A adalahyang pertama
kali masuk namun dalam kenyataanya bisa saja data B yang masuk terlebih dahulu, begitu pula data-
data yang lain. Hal ini dapat terjadi karena adanya prioritas. Ketika ada satu data yang hendak
dikeluarkan dari antrian maka data A yang dieksekusi terlebih dahulu karena memiliki prioritas yang
paling tinggi. Namun, ketika memasukkan data, kita harus memikirkan tempat yang sesuai untuk data
tersebut akibat prioritasnya. Contoh akan dimasukkan data Z dengan prioritas 1.

Contoh Enqueue
Hasil Enqueue
Enqueue dilakukan dengan mempertimbangkan prioritas data antrian. Pembandingan prioritas
dilakukan dari belakang seperti proses enqueue pada queue biasa, ketika data didepannya prioritasnya
lebih rendah maka data akan berpindah ke bagian depan dari data tersebut. Pembandingan prioritas
terus dilakukan hingga akhirnya mendapati data yang sama prioritasnya, lebih tinggi prioritanya atau
ketika antrian sudah habis. Jika pembandiangan dilakukan terus hingga antrian habis maka data yang
diinputkan akan menempati posisi paling depan.
Algoritma Enqueue
Keterangan :
1. Input data
2. Jika queue kosong masukkan seperti biasa, end
3. Lainnya, Letakkan data dibagian paling belakang
4. bandingkan prioritas input dengan prioritas data di depannya
5. If prioritas input lebih rendah maka end of proses.
6. Lainnya, letakkan data didepan pembanding, back to step 4.
7. End.

Pada Queue beprioritas Operasi-operasi yang di gunakan sama dengan Queue tak berprioritas,
hanya pada operasi insert / enqueue saja yang berbeda. Berikut Implementasi Enqueu pada Queue
Berprioritas.
Procedure Enqueue / Insert
Procedure EnQueue (Q : Kiyu; X : Char; P : integer)
var baru, temp : kiyu;
begin
new(baru);
with baru^ do
begin
info := X;
prioritas := P;
next := nil
end;
if Q^.next = Q then
begin
baru^.next := Q;
Q^.next := Baru
end
Jika Masih Kosong
else
begin
temp := Q;
while (temp^.next^.Prioritas <= P)
and (temp^.next <> Q) do
temp := temp^.next;
if temp^.next = Q then
begin
Baru^.next := Q;
temp^.next := Baru
end
else
begin
Baru^.next := temp^.next;
temp^.next := Baru
end
end
end;
Jika Sudah ada Isi

BAB III
PENUTUP
3.1 Kesimpulan
Queue berarti antrian, bersifat FIFO (First In First Out) dimana dalam suatu antrian, yang datang terlebih
dahulu akan dilayani lebih dahulu. Dalam setiap Queue terdapat operasi-operasi :
1. Deklarasi Sebuah Queue bertipe
2. Prosedur Create / Inisialisasi
Membuat antrian baru yang masih kosong / Inisialisasi
3. Fungsi Full
4. Fungsi Empty
Untuk Memeriksa apakah antrian kosong.
5. Prosedur Insert / Push / Enqueue
Menambah sebuah elemen ( data ) kedalam antrian.Syarat: tidak bisa dilakukan jika
antrian sudah penuh.
6. Prosedur Delete / Pop / Dequeue
Mengambil 1 elemen dari sebuah antrian. Syarat: antrian tidak boleh kosong
Ada beberapa macam Queue:
1. Queue Statis dengan Array
suatu array yang dibuat seakan-akan merupakan suatu garis lurus dengan satu pintu masuk dan
satu pintu keluar.
1. dikenali elemen pertama (HEAD) dan elemen terakhirnya (TAIL),
2. aturan penyisipan dan penghapusan elemennya didefinisikan sebagai berikut:
- Penyisipan selalu dilakukan setelah elemen terakhir
- Penghapusan selalu dilakukan pada elemen pertama
3. satu elemen dengan yang lain dapat diakses melalui informasi NEXT
2. Queue Dinamis dengan Single Linked List
Linked List / Linked list satu arah (One Way List) Disebut demikian karena pada setiap simpul
hanya memiliki satu buah field yang berhubungan dengan simpul berikutnya.
Ada beberapa hal yang harus diketahui mengenai linked list, diantaranya adalah :
1. Linked list selalu memiliki pointer petunjuk yang selalu menunjuk pada awal dari list
yang disebut Head.
2. Linked list juga selalu memiliki pointer petunjuk menunjuk pada akhir dari list yang
disebut Tail, kecuali untuk jenis circular.
3. Setiap simpul yang terbentuk selalu memiliki nilai NIL, kecuali jika simpul tersebut
sudah ditunjuk oleh simpul yang lainnya (Linked list belum terhubung).
4. Posisi simpul terakhir pada linked list selalu bernilai NIL karena ia tidak menunjuk
pada simpul yang lainnya, kecuali bentuk circular.
5. Operasi yang dapat dilakukan pada Linked List diantaranya adalah :
a. Menambah Simpul (di Depan, Belakang dan Tengah).
b. Menghapus Simpul (di Depan, Belakang dan Tengah).
c. Membaca isi linked list (Membaca maju dan mundur).
3. Queue Dinamis dengan Double Linked List

Ada beberapa hal yang harus diketahui mengenai Double linked list, diantaranya adalah :
1. Double Linked list selalu memiliki pointer petunjuk yang selalu menunjuk pada awal dari
list yang disebut Head.
2. Double Linked list juga selalu memiliki pointer petunjuk menunjuk pada akhir dari list
yang disebut Tail.
3. Setiap simpul yang terbentuk selalu memiliki nilai NIL, kecuali jika simpul tersebut sudah
ditunjuk oleh simpul yang lainnya (Double Linked list belum terhubung).
4. Posisi simpul terakhir pada Doube linked list selalu bernilai NIL karena ia tidak menunjuk
pada simpul yang lainnya, kecuali bentuk circular.
4. Queue Berprioritas
Dengan konsep FIFO (first in first out) plus HIFO (high priority first out) Antrian berprioritas
mempertimbangkan prioritas dalam pengeluaran data, dimana data berprioritas tinggi akan di
eksekusi terlebih dahulu, dan jika ada data yang sama prioritasnya maka data yang pertama kali
masuk akan dieksekusi terlebih dahulu. Perbedaan praktek pascal Queue tanpa prioritas dan
berprioritas terletak pada proses EnQueue / Insert.
.2 Penutup
Demikian makalah ini kami susun sedemikian rupa , semoga bermanfaat bagi mahasiswa lainnya dalam
hal pemahaman Struktur Data Queue. Menyadari bahwa masih banyak kekurangan baik dalam hal isi materi ,
tulisan , maupun penyajian Kami sebagai penyusun mohon maaf yang sebesar-besarnya, terimakasih.

Implementasi queue

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Implementasi queue (20)

More from Rhe Dwi Yuni (6)

Recently uploaded (20)

Implementasi queue