ANTRIAN

(QUEUE )
 Jenis struktur data antrian sering digunakan
untuk menstimulasikan keadaan dunia nyata.
Antrian banyak dijumpai dalam kehidupan sehari-
hari. Misal : antrian registrasi mahasiswa, tiket
kereta api dan lain-lain.

Pengertian Antrian :
Adalah suatu kumpulan data yang mana
penambahan data / elemen hanya dapat
dilakukan pada sisi belakang sedangkan
penghapusan / pengeluaran elemen dilakukan
pada sisi depan.

Berbeda dg stack, prinsip yg digunakan dalam

antrian adalah FIFO ( First In First Out )
Dengan kata lain, urutan keluar elemen akan
sama dengan urutan masuknya.
 Dalam antrian tidak semuanya dilakukan secara FIFO
murni, contoh yg relevan dalam bidang komputer adalah
Time-sharing Computer System, dimana ada sejumlah
pemakai (user) yg menggunakan sistem tsb secara serempak.
Karena sistem ini biasanya menggunakan processor, dan
sebuah memory utama. Jika processor sedang dipakai oleh
seorang user, maka user yang lain harus antri sampai
gilirannya.

Antrian ini tidak akan dilayani secara FIFO murni tetapi

biasanya didasarkan pada suatu prioritas tertentu.

Antrian yang memasukkan unsur prioritas dinamakan

dengan ANTRIAN PRIORITAS ( PRIORITY QUEUE )
 Implementasi Antrian dengan menggunakan Array

Keluar Masuk
A B C

Depan Belakang

Tambahkan 2 elemen baru yaitu D dan E ke dalam antrian

Keluar Masuk
A B C D E

Depan Belakang
 Hapus / keluarkan 1 elemen dari antrian

Keluar Masuk
B C D E

Depan Belakang

Deklarasi Antrian dengan Menggunakan ARRAY :

CONST Maks_elemen = 6 ;
TYPE antrian = array [1 .. Maks_elemen] of char ;
VAR Q : Antrian ;
Depan, belakang : byte ;
x : char ; dimana x adalah elemen yg akan
dimasukkan ke dalam antrian
 Keadaan awal suatu antrian

Depan = 1
Antrian ( Q ) Belakang = 0
Blk = Blk + 1
 Untuk melakukan operasi pada antrian dapat dilakukan dg
beberapa cara :

Cara 1 :
1. Operasi penambahan elemen ke dalam antrian :
a. Belakang := Belakang + 1;
misal. Tambahkan 1 elemen baru (x) = A
Belakang := Belakang + 1
:= 0 + 1
:= 1
Antrian (Q)

Depan = 1
Belakang = 1
 B. Q[Belakang]:=x; Antrian (Q)
Q[1]:= A
Depan = 1
Belakang = 1

ex. Tambahkan 1 elemen baru (x)= B

Belakang := Belakang + 1
:= 1 + 1 Antrian (Q)
:= 2
Depan = 1
Belakang = 2
B
A
2. Operasi penghapusan elemen dari antrian
Rumus yg digunakan :

Y := Q[depan] ;
Depan := Depan + 1 ;

example :
- Hapus/keluarkan 1 elemen dari antrian
Y := Q[Depan]; C Belakang = 3
B
Y := Q[1];
A Depan = 1
Y := A;
C Belakang = 3
B
Depan = 1
Depan := Depan + 1;
:= 1 + 1;
:= 2
C Belakang = 3
B Depan = 2
 - Hapus/keluarkan lg utk 2 elemen berikutnya dr antrian
yaitu keluarkan elemen B Depan = 2+1=3 , Belakang =
3
C Depan = 3+1=4 , Belakang = 3

C Belakang = 3 , Depan=3

keluarkan B keluarkan C

Antrian kosong = Depan > Belakang

Kelemahan cara 1 :
elemen baru tdk bisa ditambahkan lagi, karena nilai
belakang = maks_elemen (antrian penuh) walaupun masih
ada tempat / lokasi antrian yg kosong.
 Contoh Program
#include<iostream.h>
#include<conio.h>
#include<stdio.h>

#define max 10

typedef struct
{
int data[max];
int head;
int tail;
}Queue;
Queue antrian;

void create()
{
antrian.head=antrian.tail=-1;
}

int IsEmpty()
{
if(antrian.tail==-1)
return 1;
else
return 0;
}
int IsFull()
{
if(antrian.tail==max-1)
return 1;
else
return 0;
}

void Enqueue(int data)

{
if(IsEmpty()==1)
{
antrian.head=antrian.tail=0;
antrian.data[antrian.tail]=data;
cout<<"Data "<<antrian.data[antrian.tail]<<"Masuk !!!";
}
 else if(IsFull()==0)
{
antrian.tail++;
antrian.data[antrian.tail]=data;
cout<<"Data "<<antrian.data[antrian.tail]<<"Masuk !!!";
}
else if(IsFull()==1)
{
cout<<"Ruangan Penuh !!"<<endl;
cout<<data<<"Ga Bisa Masuk !!!";
}
}
void Dequeue()
{
int i;
int e = antrian.data[antrian.head];
if(antrian.tail==-1)
{
cout<<"Ga Ada antrian... Data Kosong"<<endl;
}
else
{
for(i=antrian.head;i<antrian.tail-1;i++)
{
antrian.data[i]=antrian.data[i+1];
}
antrian.tail--;
cout<<"Data yang keluar lebih dulu = "<<e<<endl;
}
}
void clear()
{
antrian.head=antrian.tail=-1;
cout<<"Duh Lega, Ruangan jadi ga sumpek... "<<endl;
cout<<"Data Clear";
}
void tampil()
{
if(IsEmpty()==0)
{
cout<<"Data Dalam Antrian"<<endl;

cout<<"=====================================";
cout<<endl;
for(int i=antrian.head;i<=antrian.tail;i++)
{
cout<<"| " <<antrian.data[i]<<" |";
}
}
 else
{
cout<<"Ga ada antrian... Data kosong";
}
}
void main()
{
int pil;
int data;
create();
do
{
clrscr();
cout<<"Implementasi Antrian dengan Struct"<<endl;

cout<<"==========================================";
cout<<endl;
cout<<"1. Enqueue"<<endl;
cout<<"2. Dqueue "<<endl;
cout<<"3. Print "<<endl;
cout<<"4. Clear "<<endl;
cout<<"5. Exit "<<endl;
cout<<"Masukkan pilihan anda : ";
cin>>pil;
switch(pil)
{
case 1:
{
cout<<endl;
cout<<"Data = ";
cin>>data;
Enqueue(data);
break;
}
case 2:
{
cout<<endl;
Dequeue();
break;
}
case 3:
{
cout<<endl;
tampil();
break;
}
 case 4:
{
cout<<endl;
clear();
break;
}
}
getch();
}
while(pil!=5);
}